7 #define NEED_DEF_WIDGET_OPTS
21 static void set_child_colour_internal(LiVESWidget *, livespointer set_allx);
22 static void set_child_alt_colour_internal(LiVESWidget *, livespointer set_allx);
24 static void async_sig_handler(livespointer instance, livespointer data);
26 typedef void (*
bifunc)(livespointer, livespointer);
28 static void sigdata_free(livespointer, LiVESWidgetClosure *);
30 static boolean show_css =
FALSE;
34 const char *detail,
const char *value);
37 #define NSLEEP_TIME 500
40 #define STD_KEY "_wh_is_standard"
41 #define BACCL_GROUP_KEY "_wh_baccl_group"
42 #define BACCL_ACCL_KEY "_wh_baccl_accl"
43 #define TTIPS_KEY "_wh_lives_tooltips"
44 #define TTIPS_OVERRIDE_KEY "_wh_lives_tooltips_override"
45 #define TTIPS_HIDE_KEY "_wh_lives_tooltips_hide"
46 #define HAS_TTIPS_IMAGE_KEY "_wh_has_ttips_image"
47 #define TTIPS_IMAGE_KEY "_wh_ttips_image"
48 #define WARN_IMAGE_KEY "_wh_warn_image"
49 #define SHOWALL_OVERRIDE_KEY "_wh_lives_showall_override"
50 #define SHOWHIDE_CONTROLLER_KEY "_wh_lives_showhide_controller"
51 #define ROWS_KEY "_wh_rows"
52 #define COLS_KEY "_wh_cols"
53 #define CDEF_KEY "_wh_current_default"
54 #define DEFBUTTON_KEY "_wh_default_button"
55 #define DEFOVERRIDE_KEY "_wh_default_override"
56 #define EXP_LIST_KEY "_wh_expansion_list"
57 #define LROW_KEY "_wh_layout_row"
58 #define EXPANSION_KEY "_wh_expansion"
59 #define JUST_KEY "_wh_justification"
60 #define WADDED_KEY "_wh_widgets_added"
61 #define NWIDTH_KEY "_wh_normal_width"
62 #define FBUTT_KEY "_wh_first_button"
63 #define ISLOCKED_KEY "_wh_is_locked"
64 #define CBUTTON_KEY "_wh_cbutton"
65 #define SPRED_KEY "_wh_sp_red"
66 #define SPGREEN_KEY "_wh_sp_green"
67 #define SPBLUE_KEY "_wh_sp_blue"
68 #define SPALPHA_KEY "_wh_sp_alpha"
69 #define THEME_KEY "_wh_theme"
71 #define SBUTT_SURFACE_KEY "_sbutt_surf"
72 #define SBUTT_TXT_KEY "_sbutt_txt"
73 #define SBUTT_LAYOUT_KEY "_sbutt_layout"
74 #define SBUTT_LW_KEY "_sbutt_lw"
75 #define SBUTT_LH_KEY "_sbutt_lh"
76 #define SBUTT_PIXBUF_KEY "_sbutt_pixbuf"
77 #define SBUTT_FORCEIMG_KEY "_sbutt_forceimg"
78 #define SBUTT_FAKEDEF_KEY "_sbutt_fakedef"
80 static LiVESWindow *modalw = NULL;
83 weed_plant_t *LiVESWidgetObject_to_weed_plant(LiVESWidgetObject *o) {
89 if (!o || !G_IS_OBJECT(o))
return NULL;
94 oclass = G_OBJECT_GET_CLASS(o);
97 pspec = g_object_class_list_properties(oclass, &nprops);
102 weed_plant_t **params = (weed_plant_t **)
lives_malloc(nprops *
sizeof(weed_plant_t *));
103 for (i = 0; i < nprops; i++) {
108 params[i] = weed_plant_new(WEED_PLANT_PARAMETER);
109 weed_set_string_value(params[i], WEED_LEAF_NAME, g_param_spec_get_name(pspec[i]));
110 gtype = G_PARAM_SPEC_VALUE_TYPE(pspec[i]);
126 g_object_get(o, name, &ival, NULL);
128 weed_set_int_value(params[i], WEED_LEAF_VALUE, ival);
147 params[num_params] = NULL;
148 weed_set_plantptr_array(plant, WEED_LEAF_IN_PARAMETERS, nprops, params);
156 if (!(val = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
STD_KEY)))
return FALSE;
157 return (LIVES_POINTER_TO_INT(val));
161 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
STD_KEY, LIVES_INT_TO_POINTER(is));
165 static void edit_state_cb(LiVESWidgetObject *
object, livespointer pspec, livespointer user_data) {
166 LiVESWidget *entry = LIVES_WIDGET(
object);
175 #if !GTK_CHECK_VERSION(3, 16, 0)
176 static boolean widget_state_cb(LiVESWidgetObject *
object, livespointer pspec, livespointer user_data) {
193 LiVESWidget *widget = (LiVESWidget *)
object;
194 LiVESWidgetState state;
203 if (LIVES_IS_TOOL_BUTTON(widget)) {
205 LiVESWidget *icon = gtk_tool_button_get_icon_widget(LIVES_TOOL_BUTTON(widget));
212 label = gtk_tool_button_get_label_widget(LIVES_TOOL_BUTTON(widget));
215 LiVESWidgetColor dimmed_fg;
216 LiVESList *list, *olist;
220 dimval = (0.2 * 65535.);
226 dimval = (0.6 * 65535.);
236 widget = (LiVESWidget *)list->data;
237 if (LIVES_IS_VBOX(widget)) {
242 lives_list_free(olist);
248 if (LIVES_IS_LABEL(widget)) {
250 int themetype = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
THEME_KEY));
251 if (themetype == 2) {
262 if (LIVES_IS_ENTRY(widget) || LIVES_IS_COMBO(widget)) {
268 if (LIVES_IS_ENTRY(widget) && !LIVES_IS_SPIN_BUTTON(widget))
269 edit_state_cb(LIVES_WIDGET_OBJECT(widget), NULL, NULL);
271 if (LIVES_IS_COMBO(widget)) {
286 lives_widget_object_set_data_full(obj, key, data,
lives_free);
290 static void lives_list_free_cb(livespointer list) {lives_list_free((LiVESList *)list);}
293 lives_widget_object_set_data_full(obj, key, list, lives_list_free_cb);
299 livespointer other) {
300 lives_widget_object_set_data_full(obj, key, other, lives_widget_object_unref_cb);
310 lives_painter_t *cr = NULL;
311 #ifdef LIVES_PAINTER_IS_CAIRO
312 cr = cairo_create(target);
314 #ifdef PAINTER_QPAINTER
315 cr =
new lives_painter_t(target);
325 #ifdef LIVES_PAINTER_IS_CAIRO
326 gdk_cairo_set_source_pixbuf(cr, pixbuf, pixbuf_x, pixbuf_y);
329 #ifdef PAINTER_QPAINTER
330 QPointF qp(pixbuf_x, pixbuf_y);
331 const QImage *qi = (
const QImage *)pixbuf;
332 cr->drawImage(qp, *qi);
342 #ifdef LIVES_PAINTER_IS_CAIRO
343 cairo_set_source_surface(cr, surface, x, y);
346 #ifdef PAINTER_QPAINTER
348 cr->drawImage(qp, *surface);
356 #ifdef LIVES_PAINTER_IS_CAIRO
360 #ifdef PAINTER_QPAINTER
368 #ifdef LIVES_PAINTER_IS_CAIRO
372 #ifdef PAINTER_QPAINTER
373 cr->fillPath(*(cr->p), cr->pen.color());
375 cr->p =
new QPainterPath;
383 #ifdef LIVES_PAINTER_IS_CAIRO
387 #ifdef PAINTER_QPAINTER
388 cr->strokePath(*(cr->p), cr->pen);
390 cr->p =
new QPainterPath;
398 #ifdef LIVES_PAINTER_IS_CAIRO
402 #ifdef PAINTER_QPAINTER
403 cr->setClipPath(*(cr->p), Qt::IntersectClip);
405 cr->p =
new QPainterPath;
413 #ifdef LIVES_PAINTER_IS_CAIRO
417 #ifdef PAINTER_QPAINTER
427 double y,
double width,
double height) {
428 #ifdef LIVES_PAINTER_IS_CAIRO
458 #ifdef LIVES_PAINTER_IS_CAIRO
459 cairo_surface_destroy(surf);
462 #ifdef PAINTER_QPAINTER
463 surf->dec_refcount();
471 #ifdef LIVES_PAINTER_IS_CAIRO
472 return cairo_surface_reference(surf);
479 #ifdef LIVES_PAINTER_IS_CAIRO
483 #ifdef PAINTER_QPAINTER
485 cr->p =
new QPainterPath;
493 #ifdef LIVES_PAINTER_IS_CAIRO
494 cairo_translate(cr, x, y);
497 #ifdef PAINTER_QPAINTER
500 cr->setTransform(qt,
true);
508 #ifdef LIVES_PAINTER_IS_CAIRO
509 cairo_set_line_width(cr, width);
512 #ifdef PAINTER_QPAINTER
513 cr->pen.setWidthF(width);
521 #ifdef LIVES_PAINTER_IS_CAIRO
522 cairo_move_to(cr, x, y);
525 #ifdef PAINTER_QPAINTER
534 #ifdef LIVES_PAINTER_IS_CAIRO
535 cairo_line_to(cr, x, y);
538 #ifdef PAINTER_QPAINTER
547 #ifdef LIVES_PAINTER_IS_CAIRO
548 cairo_close_path(cr);
557 #ifdef LIVES_PAINTER_IS_CAIRO
558 cairo_rectangle(cr, x, y, width, height);
561 #ifdef PAINTER_QPAINTER
562 cr->p->addRect(x, y, width, height);
571 #ifdef LIVES_PAINTER_IS_CAIRO
572 cairo_arc(cr, xc, yc, radius, angle1, angle2);
575 #ifdef PAINTER_QPAINTER
576 double l = xc - radius;
577 double t = yc - radius;
578 double w = radius * 2, h = w;
579 angle1 = angle1 /
M_PI * 180.;
580 angle2 = angle2 /
M_PI * 180.;
581 cr->p->arcTo(l, t, w, h, angle1, angle2 - angle1);
591 #ifdef LIVES_PAINTER_IS_CAIRO
592 cairo_set_operator(cr, op);
593 if (op == LIVES_PAINTER_OPERATOR_UNKNOWN)
return FALSE;
596 #ifdef PAINTER_QPAINTER
597 cr->setCompositionMode(op);
606 #ifdef LIVES_PAINTER_IS_CAIRO
607 cairo_set_source_rgb(cr, red, green, blue);
610 #ifdef PAINTER_QPAINTER
611 QColor qc(red * 255., green * 255., blue * 255.);
612 cr->pen.setColor(qc);
622 #ifdef LIVES_PAINTER_IS_CAIRO
623 cairo_set_source_rgba(cr, red, green, blue, alpha);
626 #ifdef PAINTER_QPAINTER
627 QColor qc(red * 255., green * 255., blue * 255., alpha * 255.);
628 cr->pen.setColor(qc);
636 #ifdef LIVES_PAINTER_IS_CAIRO
637 cairo_set_fill_rule(cr, fill_rule);
640 #ifdef PAINTER_QPAINTER
641 cr->p->setFillRule(fill_rule);
649 #ifdef LIVES_PAINTER_IS_CAIRO
650 cairo_surface_flush(surf);
653 #ifdef PAINTER_QPAINTER
661 lives_painter_format_t format,
662 int width,
int height,
int stride) {
663 lives_painter_surface_t *surf = NULL;
664 #ifdef LIVES_PAINTER_IS_CAIRO
665 surf = cairo_image_surface_create_for_data(data, format, width, height, stride);
667 #ifdef PAINTER_QPAINTER
668 surf =
new lives_painter_surface_t(data, format, width, height, stride);
677 lives_painter_surface_t *surf = NULL;
678 #ifdef LIVES_PAINTER_IS_CAIRO
679 surf = cairo_image_surface_create(format, width, height);
681 #ifdef PAINTER_QPAINTER
682 surf =
new lives_painter_surface_t(width, height, format);
690 int width,
int height) {
691 lives_painter_surface_t *surf = gdk_window_create_similar_surface(window, cont, width, height);
703 LIVES_PAINTER_CONTENT_COLOR,
712 lives_painter_surface_t *surf = NULL;
713 #ifdef LIVES_PAINTER_IS_CAIRO
714 surf = cairo_get_target(cr);
716 #ifdef PAINTER_QPAINTER
725 #ifdef LIVES_PAINTER_IS_CAIRO
726 stride = cairo_format_stride_for_width(form, width);
728 #ifdef PAINTER_QPAINTER
736 uint8_t *data = NULL;
737 #ifdef LIVES_PAINTER_IS_CAIRO
738 data = cairo_image_surface_get_data(surf);
740 #ifdef PAINTER_QPAINTER
741 data = (uint8_t *)surf->bits();
749 #ifdef LIVES_PAINTER_IS_CAIRO
750 width = cairo_image_surface_get_width(surf);
752 #ifdef PAINTER_QPAINTER
753 width = ((QImage *)surf)->width();
761 #ifdef LIVES_PAINTER_IS_CAIRO
762 height = cairo_image_surface_get_height(surf);
764 #ifdef PAINTER_QPAINTER
765 height = ((QImage *)surf)->height();
773 #ifdef LIVES_PAINTER_IS_CAIRO
774 stride = cairo_image_surface_get_stride(surf);
776 #ifdef PAINTER_QPAINTER
777 stride = ((QImage *)surf)->bytesPerLine();
784 lives_painter_format_t format = (lives_painter_format_t)0;
785 #ifdef LIVES_PAINTER_IS_CAIRO
786 format = cairo_image_surface_get_format(surf);
788 #ifdef PAINTER_QPAINTER
789 format = ((QImage *)surf)->format();
799 if (LIVES_IS_WIDGET_OBJECT(
object)) g_object_ref(
object);
808 static_cast<LiVESWidgetObject *
>(object)->inc_refcount();
817 if (LIVES_IS_WIDGET_OBJECT(
object)) g_object_unref(
object);
826 static_cast<LiVESWidgetObject *
>(object)->dec_refcount();
834 #if GTK_CHECK_VERSION(3, 0, 0)
836 if (!LIVES_IS_WIDGET_OBJECT(
object)) {
841 g_object_ref_sink(
object);
846 GtkObject *gtkobject;
847 if (!LIVES_IS_WIDGET_OBJECT(
object)) {
851 gtkobject = (GtkObject *)
object;
852 gtk_object_sink(gtkobject);
860 static_cast<LiVESWidgetObject *
>(object)->ref_sink();
868 livespointer instance;
870 livespointer user_data;
871 volatile boolean swapped;
872 unsigned long funcid;
879 static LiVESList *active_sigdets = NULL;
881 static void async_notify_redirect_handler(LiVESWidgetObject *
object, livespointer pspec,
882 livespointer user_data) {
884 async_sig_handler(
object, user_data);
887 static void notify_redirect_handler(LiVESWidgetObject *
object, livespointer pspec,
888 livespointer user_data) {
890 lives_sigdata_t *sigdata = (lives_sigdata_t *)user_data;
891 LiVESWidget *widget = (LiVESWidget *)
object;
892 if (!sigdata->swapped)
893 (*((
bifunc)sigdata->callback))(widget, sigdata->user_data);
895 (*((
bifunc)sigdata->callback))(sigdata->user_data, widget);
899 LiVESGuiCallback c_handler, livespointer data,
900 LiVESConnectFlags flags) {
901 unsigned long func_id;
902 #if LIVES_HAS_SWITCH_WIDGET
903 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))
904 && !strcmp(detailed_signal, LIVES_WIDGET_TOGGLED_SIGNAL)) {
908 lives_sigdata_t *sigdata =
lives_calloc(1,
sizeof(lives_sigdata_t));
909 sigdata->instance = instance;
911 sigdata->user_data = data;
912 sigdata->swapped = (flags & LIVES_CONNECT_SWAPPED) ?
TRUE :
FALSE;
913 sigdata->detsig = lives_strdup(LIVES_WIDGET_TOGGLED_SIGNAL);
914 sigdata->funcid = g_signal_connect_data(instance, LIVES_WIDGET_NOTIFY_SIGNAL
"active",
915 LIVES_GUI_CALLBACK(notify_redirect_handler),
916 sigdata, sigdata_free, (flags & LIVES_CONNECT_AFTER));
917 active_sigdets = lives_list_prepend(active_sigdets, (livespointer)sigdata);
918 return sigdata->funcid;
922 func_id = g_signal_connect(instance, detailed_signal, c_handler, data);
924 if (flags & LIVES_CONNECT_AFTER)
925 func_id = g_signal_connect_after(instance, detailed_signal, c_handler, data);
927 func_id = g_signal_connect_swapped(instance, detailed_signal, c_handler, data);
935 g_signal_handler_block(instance, handler_id);
939 LiVESWidgetObject *obj =
static_cast<LiVESWidgetObject *
>(instance);
940 obj->block_signal(handler_id);
949 g_signal_handler_unblock(instance, handler_id);
953 LiVESWidgetObject *obj =
static_cast<LiVESWidgetObject *
>(instance);
954 obj->unblock_signal(handler_id);
963 g_signal_handler_disconnect(instance, handler_id);
967 LiVESWidgetObject *obj =
static_cast<LiVESWidgetObject *
>(instance);
968 obj->disconnect_signal(handler_id);
977 g_signal_stop_emission_by_name(instance, detailed_signal);
984 static volatile boolean gov_running =
FALSE;
985 static volatile LiVESResponseType dlgresp = LIVES_RESPONSE_NONE;
986 static volatile boolean was_dest =
FALSE;
988 static volatile void *lpt_result = NULL;
989 static volatile void *lpt_retval = NULL;
991 static void sigdata_free(livespointer data, LiVESWidgetClosure *cl) {
992 lives_sigdata_t *sigdata = (lives_sigdata_t *)data;
993 if (cl) active_sigdets = lives_list_remove(active_sigdets, sigdata);
997 if (sigdata->detsig)
lives_free(sigdata->detsig);
1001 static boolean timer_running =
FALSE;
1003 static LiVESList *task_list = NULL;
1005 static lives_sigdata_t *tasks_running(
void) {
1007 lives_sigdata_t *sigdata;
1009 if (!list)
return NULL;
1010 sigdata = (lives_sigdata_t *)list->data;
1012 task_list = task_list->next;
1013 if (task_list) task_list->prev = NULL;
1016 lives_list_free(list);
1017 if (!task_list)
return sigdata;
1019 sigdata_free(sigdata, NULL);
1024 static boolean governor_loop(livespointer data) {
1025 volatile boolean clutch;
1026 static boolean lpt_recurse =
FALSE;
1027 static boolean lpt_recurse2 =
FALSE;
1028 boolean is_timer =
FALSE;
1029 lives_sigdata_t *sigdata = NULL;
1030 lives_sigdata_t *new_sigdata = (lives_sigdata_t *)data;
1034 if (g_main_depth() > 1) {
1040 if (lpt_recurse2)
return TRUE;
1046 lpt_recurse2 =
TRUE;
1047 lpt_result =
fg_run_func(lpttorun, (
void *)lpt_retval);
1050 lpt_recurse2 =
FALSE;
1055 lpt_recurse =
FALSE;
1062 lpt_recurse =
FALSE;
1063 lpt_recurse2 =
FALSE;
1066 if (timer_running) {
1079 if (!(sigdata = tasks_running()) || new_sigdata) {
1082 if (sigdata && new_sigdata) {
1084 if (sigdata->is_timer) {
1087 lives_idle_add_simple(governor_loop, new_sigdata);
1098 task_list = lives_list_prepend(task_list, new_sigdata);
1104 while (task_list && !lpttorun && clutch && !
mainw->
is_exiting && !(sigdata = tasks_running())) {
1121 if (!task_list && !lpttorun && !sigdata) {
1122 gov_running =
FALSE;
1129 if (task_list) sigdata = (lives_sigdata_t *)lives_list_last(task_list)->data;
1130 if (sigdata && sigdata->is_timer) {
1138 if (lpttorun) lpt_recurse =
TRUE;
1140 && lives_widget_context_iteration(NULL,
FALSE));
1141 lives_idle_add_simple(governor_loop, NULL);
1142 gov_running =
FALSE;
1154 gov_running =
FALSE;
1156 if (sigdata->is_timer) {
1157 if (sigdata) sigdata->swapped =
TRUE;
1161 sigdata_free(sigdata, NULL);
1167 static void async_sig_handler(livespointer instance, livespointer data) {
1169 lives_sigdata_t *sigdata =
lives_calloc(1,
sizeof(lives_sigdata_t));
1171 sigdata->detsig = NULL;
1178 if (sigdata->instance != instance)
return;
1184 if (sigdata->swapped) {
1189 governor_loop(sigdata);
1193 static void async_sig_handler3(livespointer instance, livespointer extra, livespointer data) {
1194 lives_sigdata_t *sigdata =
lives_calloc(1,
sizeof(lives_sigdata_t));
1197 sigdata->detsig = NULL;
1198 if (sigdata->swapped)
1203 sigdata->user_data);
1204 governor_loop((livespointer)sigdata);
1208 static boolean async_timer_handler(livespointer data) {
1211 lives_sigdata_t *sigdata =
lives_calloc(1,
sizeof(lives_sigdata_t));
1213 sigdata->detsig = NULL;
1214 sigdata->is_timer =
TRUE;
1218 if (!sigdata->added) {
1221 sigdata->swapped =
FALSE;
1223 "v", sigdata->user_data);
1228 if (!governor_loop(sigdata->added ? NULL : (livespointer)sigdata)) {
1230 sigdata_free(sigdata, NULL);
1233 sigdata->added =
TRUE;
1234 if (sigdata->swapped) {
1238 if (sigdata->proc) weed_plant_free(sigdata->proc);
1239 sigdata_free(sigdata, NULL);
1242 timer_running =
TRUE;
1248 lives_widget_context_iteration(NULL,
FALSE);
1251 timer_running =
FALSE;
1259 livespointer data, LiVESConnectFlags flags) {
1260 static size_t notilen = -1;
1261 lives_sigdata_t *sigdata;
1265 #if LIVES_HAS_SWITCH_WIDGET
1266 boolean swtog =
FALSE;
1267 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))
1268 && !strcmp(detailed_signal, LIVES_WIDGET_TOGGLED_SIGNAL)) swtog =
TRUE;
1272 if (notilen == -1) notilen =
lives_strlen(LIVES_WIDGET_NOTIFY_SIGNAL);
1273 if (!
lives_strncmp(detailed_signal, LIVES_WIDGET_NOTIFY_SIGNAL, notilen)) {
1277 g_signal_query(g_signal_lookup(detailed_signal, G_OBJECT_TYPE(instance)), &sigq);
1278 if (sigq.return_type != 4) {
1282 nvals = sigq.n_params + 2;
1284 if (nvals != 2 && nvals != 3) {
1288 #if LIVES_HAS_SWITCH_WIDGET
1292 sigdata = (lives_sigdata_t *)
lives_calloc(1,
sizeof(lives_sigdata_t));
1293 sigdata->instance = instance;
1295 sigdata->user_data = data;
1296 sigdata->swapped = (flags & LIVES_CONNECT_SWAPPED) ?
TRUE :
FALSE;
1297 active_sigdets = lives_list_prepend(active_sigdets, (livespointer)sigdata);
1299 #if LIVES_HAS_SWITCH_WIDGET
1304 sigdata->detsig = lives_strdup(LIVES_WIDGET_TOGGLED_SIGNAL);
1305 sigdata->funcid = g_signal_connect_data(instance, LIVES_WIDGET_NOTIFY_SIGNAL
"active",
1306 LIVES_GUI_CALLBACK(async_notify_redirect_handler),
1307 sigdata, sigdata_free, (flags & LIVES_CONNECT_AFTER));
1308 return sigdata->funcid;
1312 sigdata->detsig = lives_strdup(detailed_signal);
1315 sigdata->funcid = g_signal_connect_data(instance, detailed_signal,
1316 LIVES_GUI_CALLBACK(async_sig_handler),
1317 sigdata, sigdata_free, (flags & LIVES_CONNECT_AFTER));
1319 sigdata->funcid = g_signal_connect_data(instance, detailed_signal,
1320 LIVES_GUI_CALLBACK(async_sig_handler3),
1321 sigdata, sigdata_free, (flags & LIVES_CONNECT_AFTER));
1323 return sigdata->funcid;
1326 static lives_sigdata_t *find_sigdata(livespointer instance, LiVESGuiCallback func, livespointer data) {
1327 LiVESList *list = active_sigdets;
1328 for (; list; list = list->next) {
1329 lives_sigdata_t *sigdata = (lives_sigdata_t *)list->data;
1330 if (sigdata->instance == instance && sigdata->callback == (
lives_funcptr_t)func
1331 && sigdata->user_data == data)
return sigdata;
1337 LiVESGuiCallback func, livespointer data) {
1339 #if LIVES_HAS_SWITCH_WIDGET
1340 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1344 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1346 g_signal_handler_disconnect(instance, sigdata->funcid);
1351 g_signal_handlers_disconnect_by_func(instance, func, data);
1358 LiVESGuiCallback func, livespointer data) {
1360 #if LIVES_HAS_SWITCH_WIDGET
1361 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1365 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1367 g_signal_handler_block(instance, sigdata->funcid);
1372 g_signal_handlers_block_by_func(instance, func, data);
1379 LiVESGuiCallback func, livespointer data) {
1381 #if LIVES_HAS_SWITCH_WIDGET
1382 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1386 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1388 g_signal_handler_unblock(instance, sigdata->funcid);
1393 g_signal_handlers_unblock_by_func(instance, func, data);
1400 LiVESGuiCallback func, livespointer data) {
1401 #if LIVES_HAS_SWITCH_WIDGET
1402 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1406 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1412 #if LIVES_HAS_SWITCH_WIDGET
1418 LiVESGuiCallback func, livespointer data) {
1419 #if LIVES_HAS_SWITCH_WIDGET
1420 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1424 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1430 #if LIVES_HAS_SWITCH_WIDGET
1436 LiVESGuiCallback func, livespointer data) {
1437 #if LIVES_HAS_SWITCH_WIDGET
1438 if (LIVES_IS_WIDGET(instance) && LIVES_IS_SWITCH(LIVES_WIDGET(instance))) {
1442 lives_sigdata_t *sigdata = find_sigdata(instance, LIVES_GUI_CALLBACK(func), data);
1448 #if LIVES_HAS_SWITCH_WIDGET
1456 gtk_grab_add(widget);
1464 gtk_grab_remove(widget);
1471 static void _lives_widget_set_sensitive_cb(LiVESWidget *w,
void *pstate) {
1472 boolean state = (
boolean)LIVES_POINTER_TO_INT(pstate);
1478 if (!GTK_IS_WIDGET(widget))
break_me(
"non widget in set_sensitive");
1480 gtk_widget_set_sensitive(widget, state);
1481 #ifdef GTK_SUBMENU_SENS_BUG
1482 if (GTK_IS_MENU_ITEM(widget)) {
1486 LIVES_INT_TO_POINTER(state));
1487 gtk_widget_set_sensitive(sub, state);
1499 return gtk_widget_get_sensitive(widget);
1507 gtk_widget_show(widget);
1516 gtk_widget_hide(widget);
1525 gtk_widget_show_all(widget);
1546 gtk_widget_show_now(widget);
1555 if (GTK_IS_WIDGET(widget))
1556 gtk_widget_destroy(widget);
1573 gtk_widget_realize(widget);
1582 if (!GTK_IS_WIDGET(widget)) {
1586 gtk_widget_queue_draw(widget);
1595 #if GTK_CHECK_VERSION(3, 0, 0)
1596 gtk_widget_queue_draw_area(widget, x, y, width, height);
1598 gtk_widget_queue_draw(widget);
1607 gtk_widget_queue_resize(widget);
1617 else gtk_widget_set_size_request(widget, width, height);
1627 GdkWindowHints mask;
1628 GtkWidget *toplevel = gtk_widget_get_toplevel(widget);
1629 if (GTK_IS_WINDOW(toplevel)) {
1630 geom.min_width = width;
1631 geom.min_height = height;
1632 mask = GDK_HINT_MIN_SIZE;
1633 gtk_window_set_geometry_hints(GTK_WINDOW(toplevel), widget, &geom, mask);
1644 GdkWindowHints mask;
1645 GtkWidget *toplevel = gtk_widget_get_toplevel(widget);
1646 if (GTK_IS_WINDOW(toplevel)) {
1647 geom.max_width = width;
1648 geom.max_height = height;
1649 mask = GDK_HINT_MAX_SIZE;
1650 gtk_window_set_geometry_hints(GTK_WINDOW(toplevel), widget, &geom, mask);
1660 LiVESWidgetContext *ctx = lives_widget_context_get_thread_default();
1661 LiVESWindow *win, *modalold = modalw;
1662 boolean was_modal =
TRUE;
1663 if (!ctx || ctx == lives_widget_context_default())
return TRUE;
1665 if (LIVES_IS_WINDOW(widget)) win = (LiVESWindow *)widget;
1666 else if (LIVES_IS_WIDGET(widget))
1669 if (win && LIVES_IS_WINDOW(win)) {
1695 gdk_window_get_origin(xwin, posx, posy);
1704 gdk_window_get_frame_extents(xwin, (GdkRectangle *)rect);
1712 boolean inv_childs) {
1714 gdk_window_invalidate_rect(window, (
const GdkRectangle *)rect, inv_childs);
1723 #if GTK_CHECK_VERSION(3, 14, 0)
1724 GtkWidget *parent = gtk_widget_get_parent(widget);
1725 g_object_ref(widget);
1727 gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(widget)), widget);
1729 gtk_container_add(GTK_CONTAINER(new_parent), widget);
1730 g_object_unref(widget);
1732 gtk_widget_reparent(widget, new_parent);
1742 return gtk_widget_is_ancestor(widget, ancestor);
1750 gtk_widget_set_app_paintable(widget, paintable);
1759 #if GTK_CHECK_VERSION(3, 8, 0)
1761 gtk_widget_set_opacity(widget, opacity);
1772 static LiVESResponseType _lives_dialog_run(LiVESDialog *dialog) {
1774 LiVESResponseType resp;
1776 resp = gtk_dialog_run(dialog);
1779 return LIVES_RESPONSE_INVALID;
1784 LiVESResponseType resp;
1792 boolean waitgov =
FALSE;
1794 LiVESWidgetContext *ctx = lives_widget_context_get_thread_default();
1795 if (!ctx || ctx == lives_widget_context_default()) {
1800 lpt_retval = (
volatile void *)retval;
1802 lives_idle_add_simple(governor_loop, NULL);
1803 while (!gov_running) {
1813 ret = (
void *)lpt_result;
1822 gtk_dialog_response(dialog, response);
1831 return gtk_dialog_get_response_for_widget(dialog, widget);
1833 return LIVES_RESPONSE_NONE;
1837 #if GTK_CHECK_VERSION(3, 16, 0)
1839 #define RND_STRLEN 12
1840 #define RND_STR_PREFIX "XXX"
1842 static char *make_random_string(
const char *prefix) {
1845 size_t psize = strlen(prefix);
1846 size_t rsize = RND_STRLEN << 1;
1849 if (psize > RND_STRLEN)
return NULL;
1852 lives_snprintf(str, psize + 1,
"%s", prefix);
1856 for (i = psize; i < rsize; i++) str[i] = ((
lives_random() & 15) + 65);
1864 #if GTK_CHECK_VERSION(3, 16, 0)
1867 static boolean set_css_value_for_state_flag(LiVESWidget *widget, LiVESWidgetState state,
const char *xselector,
1868 const char *detail,
const char *value) {
1869 GtkCssProvider *provider;
1870 GtkStyleContext *ctx;
1871 char *widget_name, *wname, *selector;
1873 char *state_str, *selstr;
1875 static int widnum = 1;
1876 int brk_widnum = 3128;
1881 char **array = lives_strsplit(xselector,
" ", 2);
1882 widget_name = lives_strdup(array[0]);
1883 selector = lives_strdup(array[1]);
1884 lives_strfreev(array);
1886 widget_name = lives_strdup(xselector);
1887 selector = lives_strdup(
"");
1889 provider = gtk_css_provider_new();
1893 (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 10000);
1895 if (!LIVES_IS_WIDGET(widget))
return FALSE;
1896 selector = (
char *)xselector;
1898 ctx = gtk_widget_get_style_context(widget);
1899 provider = gtk_css_provider_new();
1900 gtk_style_context_add_provider(ctx, GTK_STYLE_PROVIDER
1901 (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 10000);
1903 widget_name = lives_strdup(gtk_widget_get_name(widget));
1905 if (!widget_name || (strncmp(widget_name, RND_STR_PREFIX, strlen(RND_STR_PREFIX)))) {
1910 widget_name = make_random_string(RND_STR_PREFIX);
1912 gtk_widget_set_name(widget, widget_name);
1914 if (widnum == brk_widnum)
break_me(
"widnum");
1919 #ifdef GTK_TEXT_VIEW_CSS_BUG
1920 if (widget && GTK_IS_TEXT_VIEW(widget)) {
1922 widget_name = lives_strdup(
"GtkTextView");
1927 case GTK_STATE_FLAG_ACTIVE:
1928 state_str =
":active";
1930 case GTK_STATE_FLAG_FOCUSED:
1931 #if GTK_CHECK_VERSION(3, 18, 0)
1932 state_str =
":focus";
1935 case GTK_STATE_FLAG_PRELIGHT:
1936 #if GTK_CHECK_VERSION(3, 18, 0)
1937 state_str =
":hover";
1939 state_str =
":prelight";
1942 case GTK_STATE_FLAG_SELECTED:
1943 state_str =
":selected";
1945 case GTK_STATE_FLAG_CHECKED:
1946 state_str =
":checked";
1948 case GTK_STATE_FLAG_INCONSISTENT:
1949 #if GTK_CHECK_VERSION(3, 18, 0)
1950 state_str =
":indeterminate";
1953 case GTK_STATE_FLAG_BACKDROP:
1954 #if GTK_CHECK_VERSION(3, 18, 0)
1955 state_str =
":backdrop";
1958 case GTK_STATE_FLAG_INSENSITIVE:
1959 #if GTK_CHECK_VERSION(3, 24, 0)
1960 state_str =
":disabled";
1962 state_str =
":insensitive";
1971 if (GTK_IS_FRAME(widget)) {
1972 if (selector != xselector)
lives_free(selector);
1973 selector = lives_strdup(
"label");
1974 }
else if (GTK_IS_TEXT_VIEW(widget)) {
1975 if (selector != xselector)
lives_free(selector);
1976 selector = lives_strdup(
"text");
1978 if (GTK_IS_SPIN_BUTTON(widget)) {
1979 if (selector != xselector)
lives_free(selector);
1980 selector = lives_strdup(
"*");
1985 if (!selector || !(*selector)) selstr = lives_strdup(
"");
1988 #if GTK_CHECK_VERSION(3, 24, 0)
1997 if (selector && selector != xselector)
lives_free(selector);
1999 #ifdef GTK_TEXT_VIEW_CSS_BUG
2004 css_string = g_strdup_printf(
" %s {\n %s: %s;}\n", wname, detail, value);
2006 if (show_css) g_print(
"running CSS %s\n", css_string);
2008 #if GTK_CHECK_VERSION(4, 0, 0)
2009 gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),
2012 gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider),
2013 css_string, -1, NULL);
2022 boolean set_css_value(LiVESWidget *widget, LiVESWidgetState state,
const char *detail,
const char *value) {
2023 if (state == GTK_STATE_FLAG_NORMAL) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_NORMAL, NULL, detail, value);
2024 if (state & GTK_STATE_FLAG_ACTIVE) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_ACTIVE, NULL, detail, value);
2025 if (state & GTK_STATE_FLAG_PRELIGHT) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_PRELIGHT, NULL, detail, value);
2026 if (state & GTK_STATE_FLAG_SELECTED) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_SELECTED, NULL, detail, value);
2027 if (state & GTK_STATE_FLAG_INSENSITIVE) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_INSENSITIVE, NULL, detail, value);
2028 if (state & GTK_STATE_FLAG_INCONSISTENT) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_INCONSISTENT, NULL, detail, value);
2029 if (state & GTK_STATE_FLAG_FOCUSED) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_FOCUSED, NULL, detail, value);
2030 if (state & GTK_STATE_FLAG_BACKDROP) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_BACKDROP, NULL, detail, value);
2031 if (state & GTK_STATE_FLAG_CHECKED) set_css_value_for_state_flag(widget, GTK_STATE_FLAG_CHECKED, NULL, detail, value);
2039 boolean set_css_value_direct(LiVESWidget *widget, LiVESWidgetState state,
const char *selector,
const char *detail,
2040 const char *value) {
2041 #if GTK_CHECK_VERSION(3, 16, 0)
2043 #if !GTK_CHECK_VERSION(3, 24, 0)
2049 return set_css_value_for_state_flag(widget, state, selector, detail, value);
2057 const LiVESWidgetColor *color) {
2059 #if GTK_CHECK_VERSION(3, 0, 0)
2060 #if GTK_CHECK_VERSION(3, 16, 0)
2061 char *colref = gdk_rgba_to_string(color);
2062 boolean retb = set_css_value(widget, state,
"background-color", colref);
2067 gtk_widget_override_background_color(widget, state, color);
2070 gtk_widget_modify_bg(widget, state, color);
2071 gtk_widget_modify_base(widget, state, color);
2080 const LiVESWidgetColor *color) {
2082 #if GTK_CHECK_VERSION(3, 0, 0)
2083 #if GTK_CHECK_VERSION(3, 16, 0)
2084 char *colref = gdk_rgba_to_string(color);
2085 boolean retb = set_css_value(widget, state,
"color", colref);
2089 gtk_widget_override_color(widget, state, color);
2092 gtk_widget_modify_text(widget, state, color);
2093 gtk_widget_modify_fg(widget, state, color);
2102 const LiVESWidgetColor *color) {
2104 #if GTK_CHECK_VERSION(3, 0, 0)
2105 #if GTK_CHECK_VERSION(3, 16, 0)
2106 char *colref = gdk_rgba_to_string(color);
2107 boolean retb = set_css_value(widget, state,
"color", colref);
2111 gtk_widget_override_color(widget, state, color);
2114 gtk_widget_modify_text(widget, state, color);
2119 widget->set_text_color(state, color);
2127 const LiVESWidgetColor *color) {
2129 #if GTK_CHECK_VERSION(3, 0, 0)
2130 #if GTK_CHECK_VERSION(3, 16, 0)
2131 char *colref = gdk_rgba_to_string(color);
2132 boolean retb = set_css_value(widget, state,
"background", colref);
2136 gtk_widget_override_color(widget, state, color);
2139 gtk_widget_modify_base(widget, state, color);
2144 widget->set_base_color(state, color);
2152 const LiVESWidgetColor *color) {
2154 #if GTK_CHECK_VERSION(3, 16, 0)
2155 char *colref = gdk_rgba_to_string(color);
2156 boolean retb = set_css_value(widget, state,
"outline-color", colref);
2166 const LiVESWidgetColor *color) {
2168 #if GTK_CHECK_VERSION(3, 16, 0)
2169 char *colref = gdk_rgba_to_string(color);
2170 boolean retb = set_css_value(widget, state,
"border-color", colref);
2182 #if GTK_CHECK_VERSION(3, 16, 0)
2183 boolean retb = set_css_value(widget, state,
"font-size", size);
2192 LiVESWidgetColor *color) {
2194 #if GTK_CHECK_VERSION(3, 0, 0)
2195 #if GTK_CHECK_VERSION(4, 0, 0)
2196 gtk_style_context_get_color(gtk_widget_get_style_context(widget), color);
2198 gtk_style_context_get_color(gtk_widget_get_style_context(widget),
lives_widget_get_state(widget), color);
2214 LiVESWidgetColor *color) {
2216 #if GTK_CHECK_VERSION(3, 0, 0)
2217 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
2218 gtk_style_context_get_background_color(gtk_widget_get_style_context(widget),
lives_widget_get_state(widget), color);
2219 G_GNUC_END_IGNORE_DEPRECATIONS
2235 #if LIVES_WIDGET_COLOR_HAS_ALPHA
2236 if (c1->alpha != c2->alpha)
return FALSE;
2238 if (c1->red != c2->red || c1->green != c2->green || c1->blue != c2->blue)
return FALSE;
2247 if (mixval < 0. || mixval > 1. || !c1 || !c2)
return FALSE;
2249 c1->red = (float)c1->red * mixval + (
float)c2->red * (1. - mixval);
2250 c1->green = (float)c1->green * mixval + (
float)c2->green * (1. - mixval);
2251 c1->blue = (float)c1->blue * mixval + (
float)c2->blue * (1. - mixval);
2260 LiVESWidgetColor *c0 = NULL;
2264 c1->green = c2->green;
2265 c1->blue = c2->blue;
2266 #if GTK_CHECK_VERSION(3, 0, 0)
2267 c1->alpha = c2->alpha;
2269 c1->pixel = c2->pixel;
2272 #if GTK_CHECK_VERSION(3, 0, 0)
2273 c0 = gdk_rgba_copy(c2);
2275 c0 = gdk_color_copy(c2);
2285 LiVESWidget *eventbox = NULL;
2287 eventbox = gtk_event_box_new();
2290 eventbox =
new LiVESEventBox;
2298 gtk_event_box_set_above_child(ebox, set);
2309 LiVESWidget *image = NULL;
2311 image = gtk_image_new();
2314 image =
new LiVESImage;
2322 case LIVES_ICON_SIZE_SMALL_TOOLBAR:
2323 case LIVES_ICON_SIZE_BUTTON:
2324 case LIVES_ICON_SIZE_MENU:
2326 case LIVES_ICON_SIZE_LARGE_TOOLBAR:
2328 case LIVES_ICON_SIZE_DND:
2330 case LIVES_ICON_SIZE_DIALOG:
2340 LiVESPixbuf *pixbuf = NULL;
2341 LiVESWidget *image = NULL;
2342 if (size == LIVES_ICON_SIZE_CUSTOM) {
2346 size = LIVES_ICON_SIZE_SMALL_TOOLBAR;
2348 size = LIVES_ICON_SIZE_LARGE_TOOLBAR;
2355 if (size != LIVES_ICON_SIZE_CUSTOM) {
2357 #if GTK_CHECK_VERSION(3, 10, 0)
2360 GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
2363 image = gtk_image_new_from_stock(stock_id, size);
2373 size = LIVES_ICON_SIZE_DIALOG;
2375 size = LIVES_ICON_SIZE_DND;
2377 size = LIVES_ICON_SIZE_LARGE_TOOLBAR;
2379 size = LIVES_ICON_SIZE_SMALL_TOOLBAR;
2381 size = LIVES_ICON_SIZE_BUTTON;
2383 size = LIVES_ICON_SIZE_MENU;
2386 #if GTK_CHECK_VERSION(3, 10, 0)
2389 GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
2392 image = gtk_image_new_from_stock(stock_id, size);
2394 if (!image)
return NULL;
2402 LiVESWidget *image = NULL;
2413 LiVESIconSize size) {
2420 LiVESWidget *image = NULL;
2422 image = gtk_image_new_from_file(filename);
2429 LiVESWidget *image = NULL;
2431 image = gtk_image_new_from_pixbuf(pixbuf);
2434 image =
new LiVESImage(
static_cast<QImage *
>(pixbuf));
2442 gtk_image_set_from_pixbuf(image, pixbuf);
2446 *(
static_cast<QImage *
>(image)) = pixbuf->copy(0, 0, (
static_cast<QImage *
>(pixbuf))->width(),
2447 (
static_cast<QImage *
>(pixbuf))->height());
2455 LiVESPixbuf *pixbuf = NULL;
2457 pixbuf = gtk_image_get_pixbuf(image);
2460 pixbuf =
new LiVESPixbuf(image);
2467 boolean retval =
FALSE;
2469 #if GTK_CHECK_VERSION(3, 0, 0)
2470 retval = gdk_rgba_parse(color, spec);
2472 retval = gdk_color_parse(spec, color);
2482 #if GTK_CHECK_VERSION(2, 14, 0)
2483 return gtk_dialog_get_content_area(LIVES_DIALOG(dialog));
2485 return LIVES_DIALOG(dialog)->vbox;
2489 return dialog->get_content_area();
2497 #if GTK_CHECK_VERSION(2, 14, 0)
2498 #ifdef G_GNUC_BEGIN_IGNORE_DEPRECATIONS
2499 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
2501 return gtk_dialog_get_action_area(LIVES_DIALOG(dialog));
2502 #ifdef G_GNUC_END_IGNORE_DEPRECATIONS
2503 G_GNUC_END_IGNORE_DEPRECATIONS
2506 return LIVES_DIALOG(dialog)->vbox;
2510 return dialog->get_action_area();
2518 #if GTK_CHECK_VERSION(3, 0, 0)
2519 #if GTK_CHECK_VERSION(3, 12, 0)
2520 gtk_widget_set_margin_start(widget, margin);
2522 gtk_widget_set_margin_left(widget, margin);
2533 #if GTK_CHECK_VERSION(3, 0, 0)
2534 #if GTK_CHECK_VERSION(3, 12, 0)
2535 gtk_widget_set_margin_end(widget, margin);
2537 gtk_widget_set_margin_right(widget, margin);
2548 #if GTK_CHECK_VERSION(3, 0, 0)
2549 gtk_widget_set_margin_top(widget, margin);
2559 #if GTK_CHECK_VERSION(3, 0, 0)
2560 gtk_widget_set_margin_bottom(widget, margin);
2570 #if GTK_CHECK_VERSION(3, 0, 0)
2584 #if GTK_CHECK_VERSION(3, 16, 0)
2599 #if GTK_CHECK_VERSION(3, 0, 0)
2603 gtk_dialog_add_action_widget(dialog, widget, response);
2612 LiVESWidget *window = NULL;
2614 window = gtk_window_new(wintype);
2625 }
else ntitle = lives_strdup(title);
2626 gtk_window_set_title(window, ntitle);
2636 gtk_window_set_transient_for(window, parent);
2643 static void modunmap(LiVESWindow *win, livespointer data) {
if (win == modalw) modalw = NULL;}
2644 static void moddest(LiVESWindow *win, livespointer data) {
if (win == modalw) modalw = NULL;}
2645 static boolean moddelete(LiVESWindow *win, LiVESXEvent *event, livespointer data) {
2646 if (win == modalw) modalw = NULL;
2651 if (window == modalw) {
2658 lives_signal_sync_connect(window, LIVES_WIDGET_DELETE_EVENT,
2659 LIVES_GUI_CALLBACK(moddelete), NULL);
2660 lives_signal_sync_connect(window, LIVES_WIDGET_DESTROY_SIGNAL,
2661 LIVES_GUI_CALLBACK(moddest), NULL);
2662 lives_signal_sync_connect(window, LIVES_WIDGET_UNMAP_SIGNAL,
2663 LIVES_GUI_CALLBACK(modunmap), NULL);
2667 gtk_window_set_modal(window, modal);
2676 return gtk_window_get_modal(window);
2684 gtk_window_set_deletable(window, deletable);
2693 gtk_window_set_resizable(window, resizable);
2702 gtk_window_set_keep_below(window, set);
2711 gtk_window_set_keep_above(window, set);
2720 gtk_window_set_decorated(window, set);
2729 gtk_window_set_auto_startup_notification(set);
2753 if (LIVES_IS_WINDOW(window)) {
2754 #if !GTK_CHECK_VERSION(3, 20, 0)
2757 gtk_window_fullscreen_on_monitor(window,
mainw->
mgeom[monnum].
screen, monnum);
2758 gtk_window_unfullscreen(window);
2769 gtk_window_set_default_size(window, width, height);
2773 if (LIVES_IS_WINDOW(window)) {
2774 window->resize(width, height);
2784 return gtk_window_get_title(window);
2787 return (
const char *)window->windowTitle().toUtf8().constData();
2795 gtk_window_move(window, x, y);
2807 if (GDK_IS_WINDOW(window))
2808 gdk_window_get_position(window, x, y);
2817 gtk_window_get_position(window, x, y);
2826 gtk_window_set_position(window, pos);
2835 #if GTK_CHECK_VERSION(3, 4, 0)
2836 gtk_window_set_hide_titlebar_when_maximized(window, setting);
2849 gtk_window_resize(window, width, height);
2850 gtk_widget_set_size_request(GTK_WIDGET(window), width, height);
2860 gtk_window_present(window);
2873 gtk_window_fullscreen(window);
2882 gtk_window_unfullscreen(window);
2891 gtk_window_maximize(window);
2900 gtk_window_unmaximize(window);
2909 return gtk_window_get_focus(window);
2916 LiVESAccelGroup *group = NULL;
2918 group = gtk_accel_group_new();
2921 group =
new LiVESAccelGroup;
2928 LiVESAccelFlags flags, LiVESWidgetClosure *closure) {
2930 gtk_accel_group_connect(group, key, mod, flags, closure);
2934 group->connect(key, mod, flags, closure);
2942 gtk_accel_group_disconnect(group, closure);
2946 group->disconnect(closure);
2954 LiVESAccelGroup *accel_group,
2955 uint32_t accel_key, LiVESXModifierType accel_mods, LiVESAccelFlags accel_flags) {
2957 gtk_widget_add_accelerator(widget, accel_signal, accel_group, accel_key, accel_mods, accel_flags);
2961 widget->add_accel(accel_signal, accel_group, accel_key, accel_mods, accel_flags);
2970 gtk_window_add_accel_group(window, group);
2974 window->add_accel_group(group);
2984 return gtk_widget_has_focus(widget);
2993 return gtk_widget_is_focus(widget);
3001 return gtk_widget_has_default(widget);
3009 gtk_window_remove_accel_group(window, group);
3013 window->remove_accel_group(group);
3022 gtk_menu_set_accel_group(menu, group);
3026 menu->add_accel_group(group);
3034 LiVESXModifierType mod) {
3036 gtk_accel_groups_activate(
object, key, mod);
3040 object->activate_accel(key, mod);
3050 return gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, width, height);
3059 return gdk_pixbuf_copy(orig);
3067 int rowstride, LiVESPixbufDestroyNotify lives_free_buffer_fn,
3068 livespointer destroy_fn_data) {
3070 return gdk_pixbuf_new_from_data((
const guchar *)buf, GDK_COLORSPACE_RGB, has_alpha, 8, width, height, rowstride,
3071 lives_free_buffer_fn,
3080 return gdk_pixbuf_new_from_file(filename,
error);
3087 boolean preserve_aspect_ratio,
3088 LiVESError **
error) {
3090 return gdk_pixbuf_new_from_file_at_scale(filename, width, height, preserve_aspect_ratio,
error);
3098 return gdk_pixbuf_get_rowstride(pixbuf);
3102 return (
dynamic_cast<const QImage *
>(pixbuf))->bytesPerLine();
3109 return gdk_pixbuf_get_width(pixbuf);
3113 return (
dynamic_cast<const QImage *
>(pixbuf))->width();
3120 return gdk_pixbuf_get_height(pixbuf);
3124 return (
dynamic_cast<const QImage *
>(pixbuf))->height();
3131 return gdk_pixbuf_get_n_channels(pixbuf);
3135 return (
dynamic_cast<const QImage *
>(pixbuf))->depth() >> 3;
3142 return gdk_pixbuf_get_pixels(pixbuf);
3146 return (uchar *)(
dynamic_cast<const QImage *
>(pixbuf))->bits();
3153 return (
const guchar *)gdk_pixbuf_get_pixels(pixbuf);
3157 return (
const uchar *)(
dynamic_cast<const QImage *
>(pixbuf))->bits();
3164 return gdk_pixbuf_get_has_alpha(pixbuf);
3168 return (
dynamic_cast<const QImage *
>(pixbuf))->hasAlphaChannel();
3174 LiVESInterpType interp_type) {
3176 return gdk_pixbuf_scale_simple(src, dest_width, dest_height, interp_type);
3186 gdk_pixbuf_saturate_and_pixelate(src, dest, saturation, pixilate);
3197 double step_increment,
double page_increment,
double page_size) {
3198 LiVESAdjustment *adj = NULL;
3200 #if GTK_CHECK_VERSION(3, 0, 0)
3201 adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
3203 adj = GTK_ADJUSTMENT(gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size));
3207 adj =
new LiVESAdjustment(value, lower, upper, step_increment, page_increment, page_size);
3215 gtk_box_set_homogeneous(box, homogenous);
3227 gtk_box_reorder_child(box, child, pos);
3235 uint32_t padding, LiVESPackType pack_type) {
3237 gtk_box_set_child_packing(box, child, expand, fill, padding, pack_type);
3246 gtk_box_set_spacing(box, spacing);
3254 LiVESWidget *hbox = NULL;
3256 #if GTK_CHECK_VERSION(3, 0, 0)
3257 hbox = gtk_box_new(LIVES_ORIENTATION_HORIZONTAL, spacing);
3260 hbox = gtk_hbox_new(homogeneous, spacing);
3268 LiVESWidget *vbox = NULL;
3270 #if GTK_CHECK_VERSION(3, 0, 0)
3271 vbox = gtk_box_new(LIVES_ORIENTATION_VERTICAL, spacing);
3274 vbox = gtk_vbox_new(homogeneous, spacing);
3284 gtk_box_pack_start(box, child, expand, fill, padding);
3294 gtk_box_pack_end(box, child, expand, fill, padding);
3302 LiVESWidget *hsep = NULL;
3304 #if GTK_CHECK_VERSION(3, 0, 0)
3305 hsep = gtk_separator_new(LIVES_ORIENTATION_HORIZONTAL);
3307 hsep = gtk_hseparator_new();
3316 LiVESWidget *vsep = NULL;
3318 #if GTK_CHECK_VERSION(3, 0, 0)
3319 vsep = gtk_separator_new(LIVES_ORIENTATION_VERTICAL);
3321 vsep = gtk_vseparator_new();
3330 LiVESWidget *bbox = NULL;
3332 #if GTK_CHECK_VERSION(3, 0, 0)
3333 bbox = gtk_button_box_new(LIVES_ORIENTATION_HORIZONTAL);
3335 bbox = gtk_hbutton_box_new();
3343 LiVESWidget *bbox = NULL;
3345 #if GTK_CHECK_VERSION(3, 0, 0)
3346 bbox = gtk_button_box_new(LIVES_ORIENTATION_VERTICAL);
3348 bbox = gtk_vbutton_box_new();
3357 #if !GTK_CHECK_VERSION(3, 12, 0)
3358 if (bstyle == LIVES_BUTTONBOX_EXPAND) {
3359 gtk_box_set_homogeneous(GTK_BOX(bbox),
TRUE);
3360 gtk_box_set_spacing(GTK_BOX(bbox), 0);
3364 gtk_button_box_set_layout(bbox, bstyle);
3374 #if GTK_CHECK_VERSION(3, 2, 0)
3375 gtk_button_box_set_child_non_homogeneous(bbox, child, set);
3384 LiVESWidget *vscale = NULL;
3386 #if GTK_CHECK_VERSION(3, 0, 0)
3387 vscale = gtk_scale_new(LIVES_ORIENTATION_VERTICAL, adj);
3389 vscale = gtk_vscale_new(adj);
3393 vscale =
new LiVESScale(LIVES_ORIENTATION_VERTICAL, adj);
3400 LiVESWidget *hpaned = NULL;
3402 #if GTK_CHECK_VERSION(3, 0, 0)
3403 hpaned = gtk_paned_new(LIVES_ORIENTATION_HORIZONTAL);
3405 hpaned = gtk_hpaned_new();
3413 LiVESWidget *vpaned = NULL;
3415 #if GTK_CHECK_VERSION(3, 0, 0)
3416 vpaned = gtk_paned_new(LIVES_ORIENTATION_VERTICAL);
3418 vpaned = gtk_vpaned_new();
3426 LiVESWidget *hscrollbar = NULL;
3428 #if GTK_CHECK_VERSION(3, 0, 0)
3429 hscrollbar = gtk_scrollbar_new(LIVES_ORIENTATION_HORIZONTAL, adj);
3431 hscrollbar = gtk_hscrollbar_new(adj);
3435 hscrollbar =
new LiVESScrollbar(LIVES_ORIENTATION_HORIZONTAL, adj);
3442 LiVESWidget *vscrollbar = NULL;
3444 #if GTK_CHECK_VERSION(3, 0, 0)
3445 vscrollbar = gtk_scrollbar_new(LIVES_ORIENTATION_VERTICAL, adj);
3447 vscrollbar = gtk_vscrollbar_new(adj);
3451 vscrollbar =
new LiVESScrollbar(LIVES_ORIENTATION_VERTICAL, adj);
3458 LiVESWidget *label = NULL;
3460 label = gtk_label_new(text);
3470 LiVESWidget *arrow = NULL;
3472 #if GTK_CHECK_VERSION(3, 12, 0)
3473 const char *format =
"<b>%s</b>";
3477 switch (arrow_type) {
3478 case LIVES_ARROW_DOWN:
3481 case LIVES_ARROW_LEFT:
3484 case LIVES_ARROW_RIGHT:
3491 arrow = gtk_label_new(
"");
3492 markup = g_markup_printf_escaped(format, str);
3493 gtk_label_set_markup(GTK_LABEL(arrow), markup);
3497 arrow = gtk_arrow_new(arrow_type, shadow_type);
3506 #if GTK_CHECK_VERSION(3, 0, 0)
3507 if (LIVES_IS_LABEL(widget)) {
3508 if (align == LIVES_ALIGN_START) gtk_label_set_xalign(LIVES_LABEL(widget), 0.);
3509 if (align == LIVES_ALIGN_CENTER) gtk_label_set_xalign(LIVES_LABEL(widget), 0.5);
3510 if (align == LIVES_ALIGN_END) gtk_label_set_xalign(LIVES_LABEL(widget), 1.);
3511 }
else gtk_widget_set_halign(widget, align);
3513 if (LIVES_IS_LABEL(widget)) {
3514 float xalign, yalign;
3515 gtk_misc_get_alignment(GTK_MISC(widget), &xalign, &yalign);
3517 case LIVES_ALIGN_START:
3518 gtk_misc_set_alignment(GTK_MISC(widget), 0., yalign);
3520 case LIVES_ALIGN_END:
3521 gtk_misc_set_alignment(GTK_MISC(widget), 1., yalign);
3523 case LIVES_ALIGN_CENTER:
3524 gtk_misc_set_alignment(GTK_MISC(widget), 0.5, yalign);
3539 #if GTK_CHECK_VERSION(3, 0, 0)
3540 gtk_widget_set_valign(widget, align);
3542 if (!LIVES_IS_LABEL(widget))
return FALSE;
3544 float xalign, yalign;
3545 gtk_misc_get_alignment(GTK_MISC(widget), &xalign, &yalign);
3547 case LIVES_ALIGN_START:
3548 gtk_misc_set_alignment(GTK_MISC(widget), xalign, 0.);
3550 case LIVES_ALIGN_END:
3551 gtk_misc_set_alignment(GTK_MISC(widget), xalign, 1.);
3553 case LIVES_ALIGN_CENTER:
3554 gtk_misc_set_alignment(GTK_MISC(widget), xalign, 0.5);
3568 LiVESWidget *alignment = NULL;
3570 #if GTK_CHECK_VERSION(3, 0, 0)
3571 alignment = gtk_aspect_frame_new(NULL, xalign, yalign, xscale / yscale,
TRUE);
3574 alignment = gtk_alignment_new(xalign, yalign, xscale, yscale);
3578 alignment =
new LiVESAlignment(xalign, yalign, xscale, yscale);
3587 #if GTK_CHECK_VERSION(3, 0, 0)
3588 gtk_aspect_frame_set(GTK_ASPECT_FRAME(alignment), xalign, yalign, xscale / yscale,
TRUE);
3590 gtk_alignment_set(LIVES_ALIGNMENT(alignment), xalign, yalign, xscale, yscale);
3595 alignment->set_alignment(xalign, yalign, xscale, yscale);
3603 LiVESWidget *expander = NULL;
3606 else expander = gtk_expander_new_with_mnemonic(label);
3607 #if GTK_CHECK_VERSION(3, 2, 0)
3608 gtk_expander_set_resize_toplevel(GTK_EXPANDER(expander),
TRUE);
3616 LiVESWidget *widget = NULL;
3618 widget = gtk_expander_get_label_widget(expander);
3626 gtk_expander_set_use_markup(expander, val);
3635 gtk_expander_set_expanded(expander, val);
3646 gtk_expander_set_label(expander, labeltext);
3656 return gtk_expander_get_expanded(expander);
3664 gtk_label_set_width_chars(label, nchars);
3665 gtk_label_set_max_width_chars(label, nchars);
3674 gtk_label_set_line_wrap(label, set);
3682 gtk_label_set_line_wrap_mode(label, mode);
3690 gtk_label_set_lines(label, nlines);
3698 gtk_label_set_ellipsize(label, mode);
3706 #if GTK_CHECK_VERSION(3, 16, 0)
3707 gtk_label_set_xalign(label, xalign);
3711 else if (xalign == 1.)
3719 QRect qr = (
static_cast<QFrame *
>(label))->contentsRect();
3720 int pixels = (float)qr.width() * xalign;
3721 label->setIndent(pixels);
3728 LiVESWidget *combo = NULL;
3730 #if GTK_CHECK_VERSION(2, 24, 0)
3731 combo = gtk_combo_box_new_with_entry();
3733 combo = gtk_combo_box_entry_new_text();
3737 combo =
new LiVESCombo;
3744 LiVESWidget *combo = NULL;
3746 #if GTK_CHECK_VERSION(2, 24, 0)
3747 combo = gtk_combo_box_new_with_model_and_entry(model);
3749 combo = gtk_combo_box_entry_new();
3750 gtk_combo_box_set_model(GTK_COMBO_BOX(combo), model);
3754 combo =
new LiVESCombo;
3755 QComboBox *qcombo =
dynamic_cast<QComboBox *
>(combo);
3756 qcombo->setModel(model->to_qsimodel());
3757 if (model->get_qtree_widget()) qcombo->setView(model->get_qtree_widget());
3764 LiVESTreeModel *model = NULL;
3766 model = gtk_combo_box_get_model(combo);
3774 gtk_combo_box_set_model(combo, model);
3784 gtk_combo_box_popup(combo);
3791 #if GTK_CHECK_VERSION(3, 20, 0)
3792 gtk_widget_set_focus_on_click(GTK_WIDGET(combo), state);
3794 gtk_combo_box_set_focus_on_click(combo, state);
3805 if (!GTK_IS_LIST_STORE(tmodel))
return FALSE;
3808 LiVESListStore *lstore = GTK_LIST_STORE(tmodel);
3809 gtk_list_store_append(lstore, &iter);
3827 if (!GTK_IS_LIST_STORE(tmodel))
return FALSE;
3830 LiVESListStore *lstore = GTK_LIST_STORE(tmodel);
3831 gtk_list_store_prepend(lstore, &iter);
3843 if (GTK_IS_TREE_STORE(tmodel)) {
3844 LiVESTreeStore *tstore = GTK_TREE_STORE(tmodel);
3845 gtk_tree_store_clear(tstore);
3846 }
else if (GTK_IS_LIST_STORE(tmodel)) {
3847 LiVESListStore *lstore = GTK_LIST_STORE(tmodel);
3852 gtk_list_store_clear(lstore);
3863 #if GTK_CHECK_VERSION(2, 24, 0)
3864 gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(combo), column);
3866 gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo), column);
3885 gtk_combo_box_set_active(combo, index);
3894 gtk_combo_box_set_active_iter(combo, iter);
3903 return gtk_combo_box_get_active_iter(combo, iter);
3912 if (GTK_IS_TREE_STORE(tmodel)) {
3914 LiVESTreeIter iter, iter1, iter2;
3916 if (gtk_tree_model_iter_children(tmodel, &iter1, NULL)) {
3917 if (gtk_tree_model_iter_children(tmodel, &iter2, &iter1)) {
3919 if (iter2.stamp == iter.stamp)
return count;
3921 if (!gtk_tree_model_iter_next(tmodel, &iter2))
break;
3926 return gtk_combo_box_get_active(combo);
3933 LiVESWidget *tview = NULL;
3935 tview = gtk_text_view_new();
3942 LiVESWidget *tview = NULL;
3944 tview = gtk_text_view_new_with_buffer(tbuff);
3951 LiVESTextBuffer *tbuff = NULL;
3953 tbuff = gtk_text_view_get_buffer(tview);
3961 gtk_text_view_set_editable(tview, setting);
3970 gtk_text_view_set_accepts_tab(tview, setting);
3979 gtk_text_view_set_cursor_visible(tview, setting);
3988 gtk_text_view_set_wrap_mode(tview, wrapmode);
3997 gtk_text_view_set_justification(tview, justify);
4006 #if GTK_CHECK_VERSION(3, 18, 0)
4007 gtk_text_view_set_top_margin(tview, margin);
4017 #if GTK_CHECK_VERSION(3, 18, 0)
4018 gtk_text_view_set_bottom_margin(tview, margin);
4027 LiVESTextBuffer *tbuff = NULL;
4029 tbuff = gtk_text_buffer_new(NULL);
4038 gtk_text_buffer_insert(tbuff, iter, text, len);
4047 gtk_text_buffer_insert_at_cursor(tbuff, text, len);
4056 gtk_text_buffer_set_text(tbuff, text, len);
4064 boolean inc_hidden_chars) {
4066 return gtk_text_buffer_get_text(tbuff, start, end, inc_hidden_chars);
4082 gtk_text_buffer_get_start_iter(tbuff, iter);
4091 gtk_text_buffer_get_end_iter(tbuff, iter);
4100 gtk_text_buffer_place_cursor(tbuff, iter);
4108 const LiVESTextIter *where,
boolean left_gravity) {
4109 LiVESTextMark *tmark;
4111 tmark = gtk_text_buffer_create_mark(tbuff, mark_name, where, left_gravity);
4119 gtk_text_buffer_delete_mark(tbuff, mark);
4128 gtk_text_buffer_delete(tbuff, start, end);
4132 QTextCursor qtc = QTextCursor(tbuff);
4133 qtc.setPosition(*start);
4134 qtc.setPosition(*end, QTextCursor::KeepAnchor);
4135 qtc.removeSelectedText();
4143 LiVESTextMark *mark) {
4145 gtk_text_buffer_get_iter_at_mark(tbuff, iter, mark);
4153 LiVESWidget *dialog = NULL;
4155 dialog = gtk_dialog_new();
4162 LiVESWidget *button = NULL;
4164 button = gtk_button_new();
4172 LiVESWidget *button = NULL;
4182 const char *stock_id) {
4184 if (!strcmp(stock_id, LIVES_STOCK_YES)) stock_id = LIVES_STOCK_APPLY;
4185 if (!strcmp(stock_id, LIVES_STOCK_NO)) stock_id = LIVES_STOCK_STOP;
4187 if (!strcmp(stock_id, LIVES_STOCK_OK)) stock_id = LIVES_STOCK_APPLY;
4188 if (!strcmp(stock_id, LIVES_STOCK_CANCEL)) stock_id = LIVES_STOCK_STOP;
4192 || !strcmp(stock_id, LIVES_STOCK_ADD)
4193 || !strcmp(stock_id, LIVES_STOCK_REMOVE)
4195 LiVESWidget *image = gtk_image_new_from_icon_name(stock_id, LIVES_ICON_SIZE_BUTTON);
4196 if (LIVES_IS_IMAGE(image)) gtk_button_set_image(LIVES_BUTTON(button), image);
4201 #ifdef USE_SPECIAL_BUTTONS
4205 if (LIVES_IS_PIXBUF(pixbuf))
4206 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
SBUTT_PIXBUF_KEY, (livespointer)pixbuf);
4216 LiVESWidget *button = NULL;
4218 #if GTK_CHECK_VERSION(3, 10, 0)
4228 if (!strcmp(stock_id, LIVES_STOCK_APPLY)) {
4232 if (!strcmp(stock_id, LIVES_STOCK_OK)) {
4236 if (!strcmp(stock_id, LIVES_STOCK_CANCEL)) {
4240 if (!strcmp(stock_id, LIVES_STOCK_YES)) {
4244 if (!strcmp(stock_id, LIVES_STOCK_NO)) {
4248 if (!strcmp(stock_id, LIVES_STOCK_CLOSE)) {
4252 if (!strcmp(stock_id, LIVES_STOCK_REVERT_TO_SAVED)) {
4256 if (!strcmp(stock_id, LIVES_STOCK_REFRESH)) {
4260 if (!strcmp(stock_id, LIVES_STOCK_DELETE)) {
4264 if (!strcmp(stock_id, LIVES_STOCK_SAVE)) {
4268 if (!strcmp(stock_id, LIVES_STOCK_SAVE_AS)) {
4272 if (!strcmp(stock_id, LIVES_STOCK_OPEN)) {
4276 if (!strcmp(stock_id, LIVES_STOCK_SELECT_ALL)) {
4280 if (!strcmp(stock_id, LIVES_STOCK_QUIT)) {
4284 if (!strcmp(stock_id, LIVES_STOCK_GO_FORWARD)) {
4288 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_FORWARD)) {
4292 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_REWIND)) {
4296 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_STOP)) {
4300 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_PLAY)) {
4304 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_PAUSE)) {
4308 if (!strcmp(stock_id, LIVES_STOCK_MEDIA_RECORD)) {
4320 button = gtk_button_new_from_stock(stock_id);
4323 if (!LIVES_IS_BUTTON(button)) {
4331 #if GTK_CHECK_VERSION(3, 6, 0)
4346 #ifdef USE_SPECIAL_BUTTONS
4350 gtk_button_set_label(button, label);
4358 #ifdef USE_SPECIAL_BUTTONS
4362 return gtk_button_get_label(button);
4370 gtk_button_clicked(button);
4379 gtk_button_set_relief(button, rstyle);
4388 gtk_button_set_image(button, image);
4397 #if GTK_CHECK_VERSION(3, 20, 0)
4398 gtk_widget_set_focus_on_click(widget, focus);
4400 if (!LIVES_IS_BUTTON(widget))
return FALSE;
4401 gtk_button_set_focus_on_click(LIVES_BUTTON(widget), focus);
4416 return gtk_paned_get_position(paned);
4425 gtk_paned_set_position(paned, pos);
4435 if (where == 1) gtk_paned_pack1(paned, child,
resize, shrink);
4436 else gtk_paned_pack2(paned, child,
resize, shrink);
4440 paned->insertWidget(where - 1, child);
4448 LiVESWidget *darea = NULL;
4450 darea = gtk_drawing_area_new();
4453 darea =
new LiVESDrawingArea;
4461 return gdk_event_get_time(event);
4465 LiVESXEventButton *xevent = (LiVESXEventButton *)event;
4466 return xevent->time;
4474 #if LIVES_HAS_SWITCH_WIDGET
4475 if (LIVES_IS_SWITCH(button))
return gtk_switch_get_active(LIVES_SWITCH(button));
4477 return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
4485 #if LIVES_HAS_SWITCH_WIDGET
4489 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
4498 #if LIVES_HAS_SWITCH_WIDGET
4499 if (!LIVES_IS_SWITCH(button))
4501 gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button), drawind);
4509 LiVESWidget *button = NULL;
4511 button = LIVES_WIDGET(gtk_toggle_tool_button_new());
4519 return gtk_toggle_tool_button_get_active(button);
4527 gtk_toggle_tool_button_set_active(button, active);
4535 LiVESWidget *button = NULL;
4537 button = gtk_radio_button_new(group);
4544 LiVESWidget *swtch = NULL;
4545 #if LIVES_HAS_SWITCH_WIDGET
4546 swtch = gtk_switch_new();
4552 #if LIVES_HAS_SWITCH_WIDGET
4553 return gtk_switch_get_active(swtch);
4559 #if LIVES_HAS_SWITCH_WIDGET
4560 gtk_switch_set_active(swtch, active);
4568 LiVESWidget *spinner = NULL;
4569 #if LIVES_HAS_SPINNER_WIDGET
4570 spinner = gtk_spinner_new();
4577 #if LIVES_HAS_SPINNER_WIDGET
4578 gtk_spinner_start(GTK_SPINNER(spinner));
4588 #if LIVES_HAS_SPINNER_WIDGET
4589 gtk_spinner_stop(GTK_SPINNER(spinner));
4598 LiVESWidget *button = NULL;
4600 button = gtk_check_button_new();
4607 LiVESWidget *button = NULL;
4609 button = gtk_check_button_new_with_label(label);
4615 static LiVESWidget *make_ttips_image_for(LiVESWidget *widget,
const char *text) {
4619 #if GTK_CHECK_VERSION(3, 16, 0)
4626 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(ttips_image),
TTIPS_IMAGE_KEY, ttips_image);
4627 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(ttips_image),
TTIPS_HIDE_KEY, ttips_image);
4630 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(ttips_image),
4635 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
HAS_TTIPS_IMAGE_KEY, ttips_image);
4642 LiVESWidget *img_tips = NULL;
4643 boolean ttips_override =
FALSE;
4644 const char *ttext = tip_text;
4646 if (!widget)
return NULL;
4648 if (tip_text && *tip_text ==
'#' && !lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4650 if (!(img_tips = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
HAS_TTIPS_IMAGE_KEY))) {
4651 img_tips = make_ttips_image_for(widget, ++ttext);
4652 if (img_tips) widget = img_tips;
4657 ttips_override =
TRUE;
4661 (livespointer)(lives_strdup(ttext)));
4663 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_KEY, NULL);
4665 if (!lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4667 if (!lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4669 img_tips = make_ttips_image_for(widget, NULL);
4675 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4678 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4681 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
4683 if ((cntrl = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
4689 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
4695 img_tips = make_ttips_image_for(widget, NULL);
4700 #if GTK_CHECK_VERSION(2, 12, 0)
4701 gtk_widget_set_tooltip_text(widget, ttext);
4704 tips = gtk_tooltips_new();
4705 gtk_tooltips_set_tip(tips, widget, ttext, NULL);
4714 gtk_widget_set_can_focus(widget,
TRUE);
4715 gtk_widget_grab_focus(widget);
4724 gtk_widget_grab_default(widget);
4733 return gtk_radio_button_get_group(rbutton);
4741 return gtk_widget_get_parent(widget);
4744 return widget->get_parent();
4752 if (!GTK_IS_WIDGET(widget))
return NULL;
4753 return gtk_widget_get_toplevel(widget);
4761 #if GTK_CHECK_VERSION(2, 12, 0)
4762 return gtk_widget_get_window(widget);
4764 return GDK_WINDOW(widget->window);
4773 LiVESWidget *window = gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW);
4774 if (GTK_IS_WINDOW(window))
return (LiVESWindow *)window;
4782 gdk_window_set_keep_above(xwin, setting);
4791 #if GTK_CHECK_VERSION(2, 18, 0)
4792 gtk_widget_set_can_focus(widget, state);
4795 GTK_WIDGET_SET_FLAGS(widget, GTK_CAN_FOCUS);
4797 GTK_WIDGET_UNSET_FLAGS(widget, GTK_CAN_FOCUS);
4807 #if GTK_CHECK_VERSION(2, 18, 0)
4808 gtk_widget_set_can_default(widget, state);
4811 GTK_WIDGET_SET_FLAGS(widget, GTK_CAN_DEFAULT);
4813 GTK_WIDGET_UNSET_FLAGS(widget, GTK_CAN_DEFAULT);
4823 gtk_widget_add_events(widget, events);
4832 gtk_widget_set_events(widget, events);
4836 widget->set_events(events);
4844 uint32_t accel_key, LiVESXModifierType accel_mods) {
4846 return gtk_widget_remove_accelerator(widget, acgroup, accel_key, accel_mods);
4849 return (
static_cast<LiVESWidgetObject *
>(widget))->remove_accels(acgroup, accel_key, accel_mods);
4856 LiVESRequisition *nat_size) {
4859 #if GTK_CHECK_VERSION(3, 0, 0)
4860 gtk_widget_get_preferred_size(widget, min_size, nat_size);
4870 gtk_widget_set_no_show_all(widget, set);
4879 return gtk_widget_get_no_show_all(widget);
4888 #if GTK_CHECK_VERSION(2, 18, 0)
4889 return gtk_widget_is_sensitive(widget);
4891 return GTK_WIDGET_IS_SENSITIVE(widget);
4895 return widget->isEnabled();
4903 #if GTK_CHECK_VERSION(2, 18, 0)
4904 return gtk_widget_get_visible(widget);
4906 return GTK_WIDGET_VISIBLE(widget);
4910 return widget->isVisible();
4919 #if GTK_CHECK_VERSION(2, 18, 0)
4920 return gtk_widget_get_realized(widget);
4922 return GTK_WIDGET_REALIZED(widget);
4931 gtk_container_add(container, widget);
4940 gtk_container_remove(container, widget);
4950 gtk_container_set_border_width(container, width);
4958 livespointer cb_data) {
4961 gtk_container_foreach(cont, callback, cb_data);
4969 livespointer cb_data) {
4972 gtk_container_forall(cont, callback, cb_data);
4980 LiVESList *children = NULL;
4982 children = gtk_container_get_children(cont);
4990 gtk_container_set_focus_child(cont, child);
4999 return gtk_container_get_focus_child(cont);
5006 LiVESWidget *pbar = NULL;
5008 pbar = gtk_progress_bar_new();
5016 #ifdef PROGBAR_IS_ENTRY
5020 gtk_entry_set_progress_fraction(pbar, fraction);
5023 "border-width",
"0px");
5026 gtk_progress_bar_set_fraction(pbar, fraction);
5036 #ifdef PROGBAR_IS_ENTRY
5037 gtk_entry_set_progress_pulse_step(pbar, fraction);
5039 gtk_progress_bar_set_pulse_step(pbar, fraction);
5049 #ifdef PROGBAR_IS_ENTRY
5053 gtk_entry_progress_pulse(pbar);
5057 "border-top-width", tmp);
5059 "border-bottom-width", tmp);
5063 gtk_progress_bar_pulse(pbar);
5072 LiVESWidget *sbutton = NULL;
5074 sbutton = gtk_spin_button_new(adj, climb_rate, digits);
5077 sbutton =
new LiVESSpinButton(adj, climb_rate, digits);
5085 return gtk_spin_button_get_value(button);
5093 return gtk_spin_button_get_value_as_int(button);
5100 LiVESAdjustment *adj = NULL;
5102 adj = gtk_spin_button_get_adjustment(button);
5105 adj = button->get_adj();
5113 gtk_spin_button_set_adjustment(button, adj);
5122 gtk_spin_button_set_value(button, value);
5131 gtk_spin_button_set_range(button, min, max);
5140 gtk_spin_button_set_wrap(button, wrap);
5149 gtk_spin_button_set_snap_to_ticks(button, snap);
5158 gtk_spin_button_set_digits(button, digits);
5167 gtk_spin_button_update(button);
5175 LiVESToolItem *button = NULL;
5177 button = gtk_tool_button_new(icon_widget, label);
5184 LiVESToolItem *item = NULL;
5186 item = gtk_tool_item_new();
5193 LiVESToolItem *item = NULL;
5195 item = gtk_separator_tool_item_new();
5203 gtk_tool_button_set_icon_widget(button, icon);
5212 return gtk_tool_button_get_icon_widget(button);
5220 gtk_tool_button_set_label_widget(button, label);
5229 return gtk_tool_button_get_label_widget(button);
5237 gtk_tool_button_set_use_underline(button, use_underline);
5247 #if GTK_CHECK_VERSION(3, 0, 0)
5248 gtk_range_set_range(GTK_RANGE(ruler), lower, upper);
5249 gtk_range_set_value(GTK_RANGE(ruler), position);
5251 gtk_ruler_set_range(ruler, lower, upper, position, max_size);
5260 LiVESMessageType type,
5261 LiVESButtonsType buttons,
const char *msg_fmt, ...) {
5262 LiVESWidget *mdial = NULL;
5264 mdial = gtk_message_dialog_new(parent, flags | GTK_DIALOG_DESTROY_WITH_PARENT, type, buttons, msg_fmt, NULL);
5274 #if GTK_CHECK_VERSION(3, 0, 0)
5275 return gtk_range_get_value(GTK_RANGE(ruler));
5277 return ruler->position;
5286 #if GTK_CHECK_VERSION(3, 0, 0)
5287 gtk_range_set_value(GTK_RANGE(ruler), value);
5289 ruler->position = value;
5298 #if GTK_CHECK_VERSION(3, 0, 0)
5300 if (GIW_IS_TIMELINE(ruler)) {
5301 LiVESAdjustment *adj = giw_timeline_get_adjustment(GIW_TIMELINE(ruler));
5303 giw_timeline_set_range(GIW_TIMELINE(ruler), lower, value, giw_timeline_get_max_size(GIW_TIMELINE(ruler)));
5306 gtk_adjustment_set_upper(gtk_range_get_adjustment(GTK_RANGE(ruler)), value);
5308 ruler->upper = value;
5317 #if GTK_CHECK_VERSION(3, 0, 0)
5319 if (GIW_IS_TIMELINE(ruler)) {
5320 LiVESAdjustment *adj = giw_timeline_get_adjustment(GIW_TIMELINE(ruler));
5322 giw_timeline_set_range(GIW_TIMELINE(ruler), value, upper, giw_timeline_get_max_size(GIW_TIMELINE(ruler)));
5325 gtk_adjustment_set_lower(gtk_range_get_adjustment(GTK_RANGE(ruler)), value);
5327 ruler->lower = value;
5335 LiVESCellRenderer *renderer = NULL;
5337 renderer = gtk_cell_renderer_text_new();
5344 LiVESCellRenderer *renderer = NULL;
5346 #if GTK_CHECK_VERSION(2, 10, 0)
5347 renderer = gtk_cell_renderer_spin_new();
5355 LiVESCellRenderer *renderer = NULL;
5357 renderer = gtk_cell_renderer_toggle_new();
5364 LiVESCellRenderer *renderer = NULL;
5366 renderer = gtk_cell_renderer_pixbuf_new();
5373 LiVESWidget *toolbar = NULL;
5375 toolbar = gtk_toolbar_new();
5383 gtk_toolbar_insert(toolbar, item, pos);
5392 gtk_toolbar_set_show_arrow(toolbar, show);
5401 return gtk_toolbar_get_icon_size(toolbar);
5403 return LIVES_ICON_SIZE_INVALID;
5409 gtk_toolbar_set_icon_size(toolbar, icon_size);
5418 gtk_toolbar_set_style(toolbar, style);
5428 #if GTK_CHECK_VERSION(2, 18, 0)
5429 GtkAllocation alloc;
5430 gtk_widget_get_allocation(widget, &alloc);
5433 x = widget->allocation.x;
5443 #if GTK_CHECK_VERSION(2, 18, 0)
5444 GtkAllocation alloc;
5445 gtk_widget_get_allocation(widget, &alloc);
5448 y = widget->allocation.y;
5458 #if GTK_CHECK_VERSION(2, 18, 0)
5459 GtkAllocation alloc;
5460 gtk_widget_get_allocation(widget, &alloc);
5461 width = alloc.width;
5463 width = widget->allocation.width;
5473 #if GTK_CHECK_VERSION(2, 18, 0)
5474 GtkAllocation alloc;
5475 gtk_widget_get_allocation(widget, &alloc);
5476 height = alloc.height;
5478 height = widget->allocation.height;
5487 #if GTK_CHECK_VERSION(3, 0, 0)
5488 gtk_widget_set_state_flags(widget, state,
TRUE);
5490 gtk_widget_set_state(widget, state);
5500 #if GTK_CHECK_VERSION(3, 0, 0)
5501 return gtk_widget_get_state_flags(widget);
5503 #if GTK_CHECK_VERSION(2, 18, 0)
5504 return gtk_widget_get_state(widget);
5506 return GTK_WIDGET_STATE(widget);
5510 return (LiVESWidgetState)0;
5515 LiVESWidget *child = NULL;
5517 child = gtk_bin_get_child(bin);
5526 #if GTK_CHECK_VERSION(2, 14, 0)
5527 upper = gtk_adjustment_get_upper(adj);
5539 #if GTK_CHECK_VERSION(2, 14, 0)
5540 lower = gtk_adjustment_get_lower(adj);
5550 double page_size = 0.;
5552 #if GTK_CHECK_VERSION(2, 14, 0)
5553 page_size = gtk_adjustment_get_page_size(adj);
5555 page_size = adj->page_size;
5563 double step_increment = 0.;
5565 #if GTK_CHECK_VERSION(2, 14, 0)
5566 step_increment = gtk_adjustment_get_step_increment(adj);
5568 step_increment = adj->step_increment;
5571 return step_increment;
5578 value = gtk_adjustment_get_value(adj);
5586 #if GTK_CHECK_VERSION(2, 14, 0)
5587 gtk_adjustment_set_upper(adj, upper);
5599 #if GTK_CHECK_VERSION(2, 14, 0)
5600 gtk_adjustment_set_lower(adj, lower);
5612 #if GTK_CHECK_VERSION(2, 14, 0)
5613 gtk_adjustment_set_page_size(adj, page_size);
5615 adj->page_size = page_size;
5625 #if GTK_CHECK_VERSION(2, 14, 0)
5626 gtk_adjustment_set_step_increment(adj, step_increment);
5628 adj->step_increment = step_increment;
5638 gtk_adjustment_set_value(adj, value);
5647 gtk_adjustment_clamp_page(adj, lower, upper);
5655 LiVESAdjustment *adj = NULL;
5657 adj = gtk_range_get_adjustment(range);
5665 gtk_range_set_value(range, value);
5674 gtk_range_set_range(range, min, max);
5683 gtk_range_set_increments(range, step, page);
5692 gtk_range_set_inverted(range, invert);
5702 value = gtk_range_get_value(range);
5709 boolean res =
FALSE;
5711 va_start(argList, titer);
5713 gtk_tree_model_get_valist(tmod, titer, argList);
5722 LiVESTreePath *tpath) {
5724 return gtk_tree_model_get_iter(tmod, titer, tpath);
5732 return gtk_tree_model_get_iter_first(tmod, titer);
5739 LiVESTreePath *tpath = NULL;
5741 tpath = gtk_tree_model_get_path(tmod, titer);
5748 LiVESTreeIter *parent) {
5750 return gtk_tree_model_iter_children(tmod, titer, parent);
5758 return gtk_tree_model_iter_n_children(tmod, titer);
5766 return gtk_tree_model_iter_next(tmod, titer);
5774 gtk_tree_path_free(tpath);
5782 LiVESTreePath *tpath = NULL;
5784 tpath = gtk_tree_path_new_from_string(path);
5793 depth = gtk_tree_path_get_depth(tpath);
5800 int *indices = NULL;
5802 indices = gtk_tree_path_get_indices(tpath);
5809 LiVESTreeStore *tstore = NULL;
5811 va_start(argList, ncols);
5816 for (i = 0; i < ncols; i++) {
5817 types[i] = va_arg(argList,
long unsigned int);
5819 tstore = gtk_tree_store_newv(ncols, types);
5822 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tstore),
5823 GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
5824 GTK_SORT_ASCENDING);
5832 LiVESTreeIter *parent) {
5834 gtk_tree_store_append(tstore, titer, parent);
5842 LiVESTreeIter *parent) {
5844 gtk_tree_store_prepend(tstore, titer, parent);
5852 boolean res =
FALSE;
5854 va_start(argList, titer);
5856 gtk_tree_store_set_valist(tstore, titer, argList);
5865 LiVESWidget *tview = NULL;
5867 tview = gtk_tree_view_new_with_model(tmod);
5874 LiVESWidget *tview = NULL;
5876 tview = gtk_tree_view_new();
5884 gtk_tree_view_set_model(tview, tmod);
5892 LiVESTreeModel *tmod = NULL;
5894 tmod = gtk_tree_view_get_model(tview);
5901 LiVESTreeSelection *tsel = NULL;
5903 tsel = gtk_tree_view_get_selection(tview);
5911 gtk_tree_view_append_column(tview, tvcol);
5920 gtk_tree_view_set_headers_visible(tview, vis);
5928 LiVESAdjustment *adj = NULL;
5930 #if GTK_CHECK_VERSION(3, 0, 0)
5931 adj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(tview));
5933 adj = gtk_tree_view_get_hadjustment(tview);
5941 LiVESCellRenderer *crend,
5943 LiVESTreeViewColumn *tvcol = NULL;
5945 va_start(args, crend);
5948 boolean expand =
FALSE;
5951 tvcol = gtk_tree_view_column_new();
5952 gtk_tree_view_column_set_title(tvcol, title);
5953 gtk_tree_view_column_pack_start(tvcol, crend, expand);
5955 attribute = va_arg(args,
char *);
5958 column = va_arg(args,
int);
5959 gtk_tree_view_column_add_attribute(tvcol, crend, attribute, column);
5960 attribute = va_arg(args,
char *);
5970 LiVESTreeViewColumnSizing type) {
5972 gtk_tree_view_column_set_sizing(tvcol, type);
5981 gtk_tree_view_column_set_fixed_width(tvcol, fwidth);
5989 LiVESTreeIter *titer) {
5991 return gtk_tree_selection_get_selected(tsel, tmod, titer);
5999 gtk_tree_selection_set_mode(tsel, tselmod);
6008 gtk_tree_selection_select_iter(tsel, titer);
6016 LiVESListStore *lstore = NULL;
6018 va_start(argList, ncols);
6023 for (i = 0; i < ncols; i++) {
6024 types[i] = va_arg(argList,
long unsigned int);
6026 lstore = gtk_list_store_newv(ncols, types);
6035 boolean res =
FALSE;
6037 va_start(argList, titer);
6039 gtk_list_store_set_valist(lstore, titer, argList);
6049 gtk_list_store_insert(lstore, titer, position);
6058 return gtk_label_get_text(label);
6069 else gtk_label_set_text(label, text);
6079 else gtk_label_set_markup_with_mnemonic(label, markup);
6088 gtk_label_set_mnemonic_widget(label, widget);
6096 LiVESWidget *widget = NULL;
6098 widget = gtk_label_get_mnemonic_widget(label);
6106 gtk_label_set_selectable(label, setting);
6115 return gtk_editable_get_editable(editable);
6124 gtk_editable_set_editable(editable, is_editable);
6133 gtk_editable_select_region(editable, start_pos, end_pos);
6141 LiVESWidget *entry = NULL;
6143 entry = gtk_entry_new();
6152 gtk_entry_set_max_length(entry, len);
6161 gtk_entry_set_activates_default(entry, act);
6170 return gtk_entry_get_activates_default(entry);
6178 gtk_entry_set_visibility(entry, vis);
6187 gtk_entry_set_has_frame(entry, has);
6196 gtk_entry_set_alignment(entry, align);
6205 return gtk_entry_get_text(entry);
6216 gtk_entry_set_text(entry, text);
6226 #if GTK_CHECK_VERSION(3, 12, 0)
6227 gtk_entry_set_max_width_chars(entry, nchars);
6229 gtk_entry_set_width_chars(entry, nchars);
6237 LiVESWidget *swindow = NULL;
6239 swindow = gtk_scrolled_window_new(hadj, vadj);
6246 LiVESAdjustment *adj = NULL;
6248 adj = gtk_scrolled_window_get_hadjustment(swindow);
6255 LiVESAdjustment *adj = NULL;
6257 adj = gtk_scrolled_window_get_vadjustment(swindow);
6264 LiVESPolicyType hpolicy,
6265 LiVESPolicyType vpolicy) {
6267 gtk_scrolled_window_set_policy(scrolledwindow, hpolicy, vpolicy);
6275 LiVESWidget *child) {
6277 #if !GTK_CHECK_VERSION(3, 8, 0)
6278 gtk_scrolled_window_add_with_viewport(scrolledwindow, child);
6291 #if GTK_CHECK_VERSION(3, 0, 0)
6292 gtk_scrolled_window_set_min_content_height(scrolledwindow, height);
6303 #if GTK_CHECK_VERSION(3, 0, 0)
6304 gtk_scrolled_window_set_min_content_width(scrolledwindow, width);
6314 gdk_window_raise(xwin);
6323 if (GDK_IS_WINDOW(xwin)) {
6324 if (!cursor || gdk_window_get_display(xwin) == gdk_cursor_get_display(cursor)) {
6325 gdk_window_set_cursor(xwin, cursor);
6338 #if !GTK_CHECK_VERSION(3, 0, 0)
6339 gtk_dialog_set_has_separator(dialog, has);
6350 #if GTK_CHECK_VERSION(3, 0, 0)
6351 gtk_widget_set_hexpand(widget, state);
6362 #if GTK_CHECK_VERSION(3, 0, 0)
6363 gtk_widget_set_vexpand(widget, state);
6372 LiVESWidget *menu = NULL;
6374 menu = gtk_menu_new();
6381 LiVESWidget *menubar = NULL;
6383 menubar = gtk_menu_bar_new();
6390 LiVESWidget *menuitem = NULL;
6392 menuitem = gtk_menu_item_new();
6399 LiVESWidget *menuitem = NULL;
6402 else menuitem = gtk_menu_item_new_with_mnemonic(label);
6410 gtk_menu_item_set_accel_path(menuitem, path);
6419 return gtk_menu_item_get_submenu(menuitem);
6426 LiVESWidget *menuitem = NULL;
6428 #if GTK_CHECK_VERSION(3, 10, 0)
6430 else menuitem = gtk_menu_item_new_with_mnemonic(label);
6433 else menuitem = gtk_image_menu_item_new_with_mnemonic(label);
6441 LiVESWidget *menuitem = NULL;
6444 else menuitem = gtk_radio_menu_item_new_with_mnemonic(group, label);
6452 return gtk_radio_menu_item_get_group(rmenuitem);
6459 LiVESWidget *menuitem = NULL;
6462 else menuitem = gtk_check_menu_item_new_with_mnemonic(label);
6470 gtk_check_menu_item_set_draw_as_radio(item, setting);
6478 LiVESAccelGroup *accel_group) {
6479 LiVESWidget *menuitem = NULL;
6481 #if GTK_CHECK_VERSION(3, 10, 0)
6482 char *xstock_id = lives_strdup(stock_id);
6483 menuitem = gtk_menu_item_new_with_mnemonic(xstock_id);
6494 menuitem = gtk_image_menu_item_new_from_stock(stock_id, accel_group);
6502 LiVESToolItem *toolitem = NULL;
6504 toolitem = gtk_menu_tool_button_new(icon, label);
6512 gtk_menu_tool_button_set_menu(toolbutton, menu);
6521 gtk_menu_item_set_submenu(menuitem, menu);
6530 gtk_menu_item_activate(menuitem);
6539 gtk_check_menu_item_set_active(item, state);
6548 return gtk_check_menu_item_get_active(item);
6554 #if !GTK_CHECK_VERSION(3, 10, 0)
6558 gtk_image_menu_item_set_image(item, image);
6568 #if !GTK_CHECK_VERSION(3, 10, 0)
6570 gtk_menu_set_title(menu, ntitle);
6581 #if GTK_CHECK_VERSION(3, 22, 0)
6582 gtk_menu_popup_at_pointer(menu, NULL);
6584 gtk_menu_popup(menu, NULL, NULL, NULL, NULL, event->button, event->time);
6594 gtk_menu_reorder_child(menu, child, pos);
6604 gtk_menu_detach(menu);
6613 gtk_menu_shell_append(menushell, child);
6622 gtk_menu_shell_insert(menushell, child, pos);
6631 gtk_menu_shell_prepend(menushell, child);
6641 #if GTK_CHECK_VERSION(2, 16, 0)
6642 #if !GTK_CHECK_VERSION(3, 10, 0)
6643 gtk_image_menu_item_set_always_show_image(item, show);
6662 gtk_scale_set_value_pos(scale, ptype);
6671 gtk_scale_set_digits(scale, digits);
6681 #if GTK_CHECK_VERSION(3, 0, 0)
6682 gtk_orientable_set_orientation(GTK_ORIENTABLE(scale), orientation);
6685 #if GTK_CHECK_VERSION(2, 14, 0)
6686 gtk_scale_button_set_orientation(scale, orientation);
6698 #if GTK_CHECK_VERSION(2, 14, 0)
6699 value = gtk_scale_button_get_value(scale);
6701 value = gtk_adjustment_get_value(gtk_range_get_adjustment(scale));
6710 #if GTK_CHECK_VERSION(2, 14, 0)
6711 gtk_scale_button_set_value(scale, value);
6713 gtk_adjustment_set_value(gtk_range_get_adjustment(scale), value);
6724 fname = gtk_file_chooser_get_filename(chooser);
6731 LiVESSList *fnlist = NULL;
6733 fnlist = gtk_file_chooser_get_filenames(chooser);
6739 #if GTK_CHECK_VERSION(3,2,0)
6741 return gtk_font_chooser_get_font(fc);
6745 const char *fontname) {
6746 gtk_font_chooser_set_font(fc, fontname);
6751 return gtk_font_chooser_get_font_desc(fc);
6755 LingoFontDescription *lfd) {
6756 gtk_font_chooser_set_font_desc(fc, lfd);
6764 LiVESWidget *grid = NULL;
6766 #if GTK_CHECK_VERSION(3,2,0) // required for grid widget
6767 grid = gtk_grid_new();
6776 #if GTK_CHECK_VERSION(3,2,0) // required for grid widget
6777 gtk_grid_set_row_spacing(grid, spacing);
6787 #if GTK_CHECK_VERSION(3,2,0) // required for grid widget
6788 gtk_grid_set_column_spacing(grid, spacing);
6798 #if GTK_CHECK_VERSION(3, 10, 0)
6799 gtk_grid_remove_row(grid, posn);
6809 #if GTK_CHECK_VERSION(3, 10, 0)
6810 gtk_grid_insert_row(grid, posn);
6819 LiVESPositionType side,
int width,
int height) {
6821 #if GTK_CHECK_VERSION(3,2,0) // required for grid widget
6822 gtk_grid_attach_next_to(grid, child, sibling, side, width, height);
6832 LiVESWidget *frame = NULL;
6834 frame = gtk_frame_new(label);
6842 gtk_frame_set_label(frame, label);
6851 gtk_frame_set_label_align(frame, xalign, yalign);
6860 gtk_frame_set_label_widget(frame, widget);
6868 LiVESWidget *widget = NULL;
6870 widget = gtk_frame_get_label_widget(frame);
6878 gtk_frame_set_shadow_type(frame, stype);
6886 LiVESWidget *nbook = NULL;
6888 nbook = gtk_notebook_new();
6895 LiVESWidget *page = NULL;
6897 page = gtk_notebook_get_nth_page(nbook, pagenum);
6906 pagenum = gtk_notebook_get_current_page(nbook);
6914 gtk_notebook_set_current_page(nbook, pagenum);
6922 LiVESWidget *tablabel) {
6924 gtk_notebook_set_tab_label(nbook, child, tablabel);
6932 LiVESWidget *table = NULL;
6934 #if LIVES_TABLE_IS_GRID // required for grid remove row
6937 gtk_grid_set_row_homogeneous(grid, homogeneous);
6938 gtk_grid_set_column_homogeneous(grid, homogeneous);
6940 for (i = 0; i < rows; i++) {
6944 for (i = 0; i < cols; i++) {
6945 gtk_grid_insert_column(grid, 0);
6948 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(grid),
ROWS_KEY, LIVES_INT_TO_POINTER(rows));
6949 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(grid),
COLS_KEY, LIVES_INT_TO_POINTER(cols));
6950 table = (LiVESWidget *)grid;
6952 table = gtk_table_new(rows, cols, homogeneous);
6961 #if LIVES_TABLE_IS_GRID // required for grid remove row
6964 gtk_table_set_row_spacings(table, spacing);
6974 #if LIVES_TABLE_IS_GRID // required for grid remove row
6977 gtk_table_set_col_spacings(table, spacing);
6987 #if LIVES_TABLE_IS_GRID
6988 gtk_grid_set_row_homogeneous(table, homogeneous);
6991 gtk_table_set_homogeneous(table, homogeneous);
7000 #if LIVES_TABLE_IS_GRID
7001 gtk_grid_set_column_homogeneous(table, homogeneous);
7004 gtk_table_set_homogeneous(table, homogeneous);
7013 #if LIVES_TABLE_IS_GRID // required for grid remove row
7016 for (i = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(table),
ROWS_KEY)); i < rows; i++) {
7020 for (i = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(table),
COLS_KEY)); i < cols; i++) {
7021 gtk_grid_insert_column(table, i);
7024 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(table),
ROWS_KEY, LIVES_INT_TO_POINTER(rows));
7025 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(table),
COLS_KEY, LIVES_INT_TO_POINTER(cols));
7027 gtk_table_resize(table, rows, cols);
7036 uint32_t top, uint32_t bottom, LiVESAttachOptions xoptions, LiVESAttachOptions yoptions,
7037 uint32_t xpad, uint32_t ypad) {
7039 #if LIVES_TABLE_IS_GRID // required for grid remove row
7040 gtk_grid_attach(table, child, left, top, right - left, bottom - top);
7041 if (xoptions & LIVES_EXPAND)
7045 if (yoptions & LIVES_EXPAND)
7056 gtk_table_attach(table, child, left, right, top, bottom, xoptions, yoptions, xpad, ypad);
7065 LiVESWidget *cbutton = NULL;
7067 #if GTK_CHECK_VERSION(3, 0, 0)
7068 cbutton = gtk_color_button_new_with_rgba(color);
7070 cbutton = gtk_color_button_new_with_color(color);
7079 #if GTK_CHECK_VERSION(3, 4, 0)
7080 gtk_color_chooser_get_rgba((GtkColorChooser *)button, color);
7082 #if GTK_CHECK_VERSION(3, 0, 0)
7083 gtk_color_button_get_rgba((GtkColorChooser *)button, color);
7085 gtk_color_button_get_color(button, color);
7096 #if GTK_CHECK_VERSION(3, 4, 0)
7097 LiVESWidgetColor color;
7098 gtk_color_chooser_get_rgba((GtkColorChooser *)button, &color);
7099 color.alpha = LIVES_WIDGET_COLOR_SCALE(alpha);
7100 gtk_color_chooser_set_rgba((GtkColorChooser *)button, &color);
7102 gtk_color_button_set_alpha(button, alpha);
7112 #if GTK_CHECK_VERSION(3, 4, 0)
7113 LiVESWidgetColor color;
7114 gtk_color_chooser_get_rgba((GtkColorChooser *)button, &color);
7115 return LIVES_WIDGET_COLOR_STRETCH(color.alpha);
7117 return gtk_color_button_get_alpha(button);
7126 #if GTK_CHECK_VERSION(3, 4, 0)
7127 gtk_color_chooser_set_rgba((GtkColorChooser *)button, color);
7129 #if GTK_CHECK_VERSION(3, 0, 0)
7130 gtk_color_button_set_rgba((GtkColorChooser *)button, color);
7132 gtk_color_button_set_color(button, color);
7144 gtk_color_button_set_title(button, title);
7154 #if GTK_CHECK_VERSION(3, 4, 0)
7155 gtk_color_chooser_set_use_alpha((GtkColorChooser *)button, use_alpha);
7157 #if GTK_CHECK_VERSION(3, 0, 0)
7158 gtk_color_button_set_use_alpha((GtkColorChooser *)button, use_alpha);
7160 gtk_color_button_set_use_alpha(button, use_alpha);
7170 LiVESXModifierType *modmask) {
7173 if (!widget) xwin = gdk_get_default_root_window();
7176 LIVES_ERROR(
"Tried to get pointer for windowless widget");
7179 #if GTK_CHECK_VERSION(3, 0, 0)
7180 gdk_window_get_device_position(xwin, device, x, y, modmask);
7182 gdk_window_get_pointer(xwin, x, y, modmask);
7196 LiVESXModifierType *modmask) {
7201 static boolean lives_widget_destroyed(LiVESWidget *widget,
void **ptr) {
7202 if (ptr) *ptr = NULL;
7207 static boolean lives_widget_timetodie(LiVESWidget *widget, LiVESWidget *getoverhere) {
7214 lives_signal_sync_connect(LIVES_GUI_OBJECT(widget), LIVES_WIDGET_DESTROY_SIGNAL,
7215 LIVES_GUI_CALLBACK(lives_widget_destroyed),
7222 lives_signal_sync_connect(LIVES_GUI_OBJECT(widget), LIVES_WIDGET_DESTROY_SIGNAL,
7223 LIVES_GUI_CALLBACK(lives_widget_timetodie),
7230 LiVESXDisplay *disp = NULL;
7232 disp = gtk_widget_get_display(widget);
7239 (LiVESXDevice *device, LiVESXDisplay *display,
int *win_x,
int *win_y) {
7240 LiVESXWindow *xwindow = NULL;
7242 #if GTK_CHECK_VERSION(3, 0, 0)
7243 if (!device)
return NULL;
7244 xwindow = gdk_device_get_window_at_position(device, win_x, win_y);
7246 xwindow = gdk_display_get_window_at_pointer(display, win_x, win_y);
7254 (LiVESXDevice *device, LiVESXDisplay *display, LiVESXScreen **screen,
int *x,
int *y, LiVESXModifierType *mask) {
7256 #if GTK_CHECK_VERSION(3, 0, 0)
7257 if (!device)
return TRUE;
7258 gdk_device_get_position(device, screen, x, y);
7260 gdk_display_get_pointer(display, screen, x, y, mask);
7269 (LiVESXDevice *device, LiVESXDisplay *display, LiVESXScreen *screen,
int x,
int y) {
7271 #if GTK_CHECK_VERSION(3, 0, 0)
7272 if (!device)
return TRUE;
7273 gdk_device_warp(device, screen, x, y);
7275 #if GLIB_CHECK_VERSION(2, 8, 0)
7276 gdk_display_warp_pointer(display, screen, x, y);
7289 #ifdef GDK_WINDOWING_WAYLAND
7301 #ifdef GDK_WINDOWING_X11
7306 #ifdef GDK_WINDOWING_WIN32
7320 lives_sigdata_t *sigdata = (lives_sigdata_t *)
lives_calloc(1,
sizeof(lives_sigdata_t));
7322 sigdata->user_data = data;
7323 sigdata->is_timer =
TRUE;
7326 #if GTK_CHECK_VERSION(3, 0, 0)
7327 if (interval > 1000) {
7328 sigdata->funcid = g_timeout_add_seconds(interval / 1000., async_timer_handler, sigdata);
7330 sigdata->funcid = g_timeout_add(interval, async_timer_handler, sigdata);
7333 sigdata->funcid = gtk_timeout_add(interval, async_timer_handler, sigdata);
7337 return sigdata->funcid;
7343 g_source_remove(timer);
7351 lives_sigdata_t *sigdata = (lives_sigdata_t *)
lives_calloc(1,
sizeof(lives_sigdata_t));
7353 sigdata->user_data = data;
7354 sigdata->is_timer =
TRUE;
7356 sigdata->funcid = g_idle_add(async_timer_handler, sigdata);
7357 return sigdata->funcid;
7368 return gtk_accelerator_get_default_mod_mask();
7376 #if !GTK_CHECK_VERSION(3, 22, 0)
7377 return gdk_screen_get_width(screen);
7386 #if !GTK_CHECK_VERSION(3, 22, 0)
7387 return gdk_screen_get_height(screen);
7396 char *tmp = g_filename_to_uri(full_file_name, NULL, NULL);
7397 gtk_recent_manager_add_item(gtk_recent_manager_get_default(), tmp);
7406 LiVESXCursor *cursor = NULL;
7408 cursor = gdk_cursor_new_from_pixbuf(disp, pixbuf, x, y);
7416 return gtk_window_has_toplevel_focus(LIVES_WINDOW(widget));
7435 LiVESPixbuf *pixbuf;
7436 if (!LIVES_IS_IMAGE(image))
return FALSE;
7450 boolean expand, fill;
7452 gtk_box_query_child_packing(box, child, &expand, &fill, &padding, NULL);
7465 #define H_ALIGN_ADJ (22. * widget_opts.scale) // why 22 ? no idea
7469 GtkWidget *fixed = gtk_fixed_new();
7490 #if GTK_CHECK_VERSION(2, 12, 0)
7491 boolean mustfree =
TRUE;
7492 char *text = (
char *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(source),
TTIPS_KEY);
7493 if (!text) text = gtk_widget_get_tooltip_text(source);
7494 else mustfree =
FALSE;
7498 GtkTooltipsData *td = gtk_tooltips_data_get(source);
7500 gtk_tooltips_set_tip(td->tooltips, dest, td->tip_text, td->tip_private);
7504 dest->setToolTip(source->toolTip());
7519 if (lives_list_length(list) > COMBO_LIST_LIMIT) {
7521 LiVESTreeIter iter1, iter2;
7524 for (revlist = list; revlist; revlist = revlist->next) {
7525 cat = lives_strndup((
const char *)revlist->data, 1);
7539 for (revlist = lives_list_last(list); revlist; revlist = revlist->prev) {
7540 gtk_list_store_prepend(lstore, &iter);
7541 gtk_list_store_set(GTK_LIST_STORE(lstore), &iter, 0, revlist->data, -1);
7553 LiVESWidget *volume_scale = NULL;
7555 #if GTK_CHECK_VERSION(2, 14, 0)
7556 volume_scale = gtk_volume_button_new();
7557 gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_scale), volume);
7560 if (orientation == LIVES_ORIENTATION_HORIZONTAL)
7561 volume_scale = gtk_hscale_new(adj);
7563 volume_scale = gtk_vscale_new(adj);
7565 gtk_scale_set_draw_value(GTK_SCALE(volume_scale),
FALSE);
7568 return volume_scale;
7574 LiVESWidget *deflt = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(toplevel),
DEFBUTTON_KEY);
7577 if (button == deflt)
7578 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(LIVES_WIDGET_OBJECT(toplevel)),
7580 #ifdef USE_SPECIAL_BUTTONS
7581 sbutt_render(button, 0, NULL);
7593 LiVESWidget *deflt = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(toplevel),
DEFBUTTON_KEY);
7594 if (button == deflt)
return TRUE;
7595 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(LIVES_WIDGET_OBJECT(toplevel)),
7597 #ifdef USE_SPECIAL_BUTTONS
7598 sbutt_render(button, 0, NULL);
7599 if (deflt) sbutt_render(deflt, 0, NULL);
7605 static void _set_css_min_size(LiVESWidget *w,
const char *sel,
int mw,
int mh) {
7606 #if GTK_CHECK_VERSION(3, 16, 0)
7621 static void set_css_min_size(LiVESWidget *w,
int mw,
int mh) {
7622 _set_css_min_size(w,
"", mw, mh);
7623 _set_css_min_size(w,
"*", mw, mh);
7626 static void set_css_min_size_selected(LiVESWidget *w,
char *selector,
int mw,
int mh) {
7627 _set_css_min_size(w, selector, mw, mh);
7636 ? LIVES_EXPAND : 0)), (LiVESAttachOptions)(0), 0, 0);
7641 LiVESList *xwidgets = (LiVESList *)lives_widget_object_steal_data(LIVES_WIDGET_OBJECT(layout),
EXP_LIST_KEY);
7642 LiVESWidget *box = NULL;
7651 columns = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
COLS_KEY));
7652 rows = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY));
7661 xwidgets = lives_list_prepend(xwidgets, box);
7663 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(box),
LROW_KEY, LIVES_INT_TO_POINTER(rows) - 1);
7667 if (widget)
return widget;
7672 static boolean lives_layout_resize(LiVESLayout *layout,
int rows,
int columns) {
7673 LiVESList *xwidgets = (LiVESList *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
EXP_LIST_KEY);
7675 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY, LIVES_INT_TO_POINTER(rows));
7676 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
COLS_KEY, LIVES_INT_TO_POINTER(columns));
7678 LiVESWidget *widget = (LiVESWidget *)xwidgets->data;
7679 int row = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
LROW_KEY));
7680 int expansion = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
EXPANSION_KEY));
7681 LiVESJustification justification = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
7693 xwidgets = xwidgets->next;
7700 LiVESWidget *layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(box),
WH_LAYOUT_KEY);
7702 LiVESList *xwidgets = (LiVESList *)lives_widget_object_steal_data(LIVES_WIDGET_OBJECT(layout),
EXP_LIST_KEY);
7703 int row = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY)) - 1;
7706 LiVESList *list = xwidgets;
7707 for (; list; list = list->next) {
7708 if (LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(xwidgets->data),
7710 if (list->prev) list->prev->next = list->next;
7711 else xwidgets = list->next;
7712 if (list->next) list->next->prev = list->prev;
7713 list->prev = list->next = NULL;
7714 lives_list_free(list);
7735 if (LIVES_IS_VBOX(box)) {
7743 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY, LIVES_INT_TO_POINTER(1));
7744 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
COLS_KEY, LIVES_INT_TO_POINTER(0));
7745 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
WADDED_KEY, LIVES_INT_TO_POINTER(0));
7759 #if GTK_CHECK_VERSION(3, 0, 0)
7760 LiVESWidget *widget = hbox;
7764 ? 1. : 0., .5, 0., 0.);
7765 LiVESWidget *widget = alignment;
7769 int nadded = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
WADDED_KEY));
7770 int rows = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY));
7771 int columns = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
COLS_KEY));
7772 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, layout);
7773 if (++nadded > columns) lives_layout_resize(layout, rows, nadded);
7775 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
WADDED_KEY, LIVES_INT_TO_POINTER(nadded));
7784 int rows = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY));
7785 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
ROWS_KEY, LIVES_INT_TO_POINTER(++rows));
7786 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(layout),
WADDED_KEY, LIVES_INT_TO_POINTER(0));
7799 char *markup, *full_markup;
7801 else markup = (
char *)text;
7842 LiVESWidget *widget;
7856 LiVESWidget *separator;
7867 static LiVESWidget *add_warn_image(LiVESWidget * widget, LiVESWidget * hbox) {
7877 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(warn_image),
TTIPS_OVERRIDE_KEY, warn_image);
7878 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
WARN_IMAGE_KEY, warn_image);
7880 #if GTK_CHECK_VERSION(3, 16, 0)
7890 LiVESWidget *warn_image;
7891 if (!(warn_image = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
WARN_IMAGE_KEY)))
return FALSE;
7900 LiVESWidget *warn_image;
7901 if (!(warn_image = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
WARN_IMAGE_KEY)))
return FALSE;
7908 static LiVESWidget *make_inner_hbox(LiVESBox * box,
boolean start) {
7925 if (LIVES_IS_HBOX(box)) {
7938 box = LIVES_BOX(hbox);
7966 #if GTK_CHECK_VERSION(3, 16, 0)
7976 #ifdef USE_SPECIAL_BUTTONS
7978 #define BT_PRE_WIDTH 4.0
7979 #define BT_UNPRE_WIDTH 2.0
7981 static void lives_painter_psurface_destroy_cb(livespointer data) {
7982 lives_painter_surface_t **pbsurf = (lives_painter_surface_t **)data;
7984 lives_painter_surface_t *bsurf = *pbsurf;
7990 static void lives_widget_object_set_data_psurface(LiVESWidgetObject * obj,
const char *key, livespointer data) {
7991 lives_widget_object_set_data_full(obj, key, data,
7992 (LiVESDestroyNotify)lives_painter_psurface_destroy_cb);
7995 void sbutt_render(LiVESWidget *
sbutt, LiVESWidgetState state, livespointer user_data) {
7999 lives_painter_surface_t **pbsurf =
8000 (lives_painter_surface_t **)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
8003 if (!pbsurf || !(*pbsurf))
return;
8005 lives_painter_t *cr;
8006 lives_painter_surface_t *bsurf;
8007 LingoLayout *layout =
8008 (LingoLayout *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(
sbutt),
8012 LiVESWidget *deflt = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(toplevel),
DEFBUTTON_KEY);
8013 LiVESWidget *defover = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(toplevel),
DEFOVERRIDE_KEY);
8014 LiVESPixbuf *pixbuf = NULL;
8015 double offs_x = 0., offs_y = 0;
8018 boolean prelit = (state & LIVES_WIDGET_STATE_PRELIGHT) == 0 ?
FALSE :
TRUE;
8019 boolean insens = (state & LIVES_WIDGET_STATE_INSENSITIVE) == 0 ?
FALSE :
TRUE;
8024 int lw = 0, lh = 0, x_pos, y_pos, w_, h_;
8025 int pbw = 0, pbh = 0;
8027 if (insens) prelit = focused =
FALSE;
8032 themetype = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(
sbutt),
THEME_KEY));
8034 if (themetype == 1) {
8063 offs_x += BT_PRE_WIDTH;
8064 offs_y += BT_PRE_WIDTH;
8071 offs_x += BT_PRE_WIDTH;
8072 offs_y += BT_PRE_WIDTH;
8075 offs_x += BT_UNPRE_WIDTH;
8076 offs_y += BT_UNPRE_WIDTH;
8082 if (offs_x < 0.) offs_x = 0.;
8083 if (offs_y < 0.) offs_y = 0.;
8090 if (!pixbuf) pixbuf = (LiVESPixbuf *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(
sbutt),
8099 const char *text = (
const char *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(
sbutt),
8103 LingoContext *ctx = gtk_widget_get_pango_context(widget);
8104 char *markup, *full_markup;
8105 layout = pango_layout_new(ctx);
8106 lingo_layout_set_alignment(layout, LINGO_ALIGN_CENTER);
8108 markup = lives_markup_escape_text(text, -1);
8112 lingo_layout_set_markup_with_accel(layout, full_markup, -1,
'_', &acc);
8116 else topl = toplevel;
8118 if (topl && LIVES_IS_WINDOW(topl)) {
8119 LiVESAccelGroup *accel_group =
8120 (LiVESAccelGroup *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(topl),
BACCL_GROUP_KEY);
8122 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(topl),
BACCL_GROUP_KEY, accel_group);
8126 uint32_t oaccl = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(topl),
BACCL_ACCL_KEY));
8130 acc, (LiVESXModifierType)LIVES_ALT_MASK, (LiVESAccelFlags)0);
8131 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(topl),
BACCL_ACCL_KEY, LIVES_INT_TO_POINTER(acc));
8134 lingo_layout_get_size(layout, &w_, &h_);
8137 lw = ((double)w_) / (double)LINGO_SCALE;
8138 lh = ((double)h_) / (double)LINGO_SCALE;
8140 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
SBUTT_LW_KEY,
8141 LIVES_INT_TO_POINTER(lw));
8142 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
SBUTT_LH_KEY,
8143 LIVES_INT_TO_POINTER(lh));
8145 (livespointer)layout);
8148 lw = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
8150 lh = LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
8154 if (focused || fake_default || (
sbutt == deflt && !defover)) {
8155 if (!fake_default && deflt &&
sbutt != deflt) {
8158 sbutt_render(deflt, 0, NULL);
8166 if (
sbutt == defover) {
8167 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(toplevel),
DEFOVERRIDE_KEY, NULL);
8168 if (deflt) sbutt_render(deflt, 0, NULL);
8178 x_pos = (width - lw) >> 1;
8179 y_pos = (height - lh) >> 1;
8182 if (pixbuf && lw && layout) {
8189 if (lh && lw && layout) {
8191 &bg, lw, lh, x_pos, y_pos, x_pos, y_pos);
8192 if (LINGO_IS_LAYOUT(layout))
8193 lingo_painter_show_layout(cr, layout);
8208 }
else x_pos -= pbw >> 1;
8209 y_pos = (height - pbh) >> 1;
8222 LiVESWidget * img) {
8229 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(
sbutt),
8232 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(
sbutt),
8234 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(
sbutt),
8237 sbutt_render(LIVES_WIDGET(
sbutt), 0, NULL);
8243 lives_painter_surface_t **pbsurf =
8244 (lives_painter_surface_t **)
lives_calloc(1,
sizeof(lives_painter_surface_t *));
8245 LiVESWidget *button, *da;
8253 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
THEME_KEY,
8254 LIVES_INT_TO_POINTER(2));
8256 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
THEME_KEY,
8259 #if GTK_CHECK_VERSION(3, 16, 0)
8260 set_css_min_size(button, width, height);
8270 lives_widget_object_set_data_psurface(LIVES_WIDGET_OBJECT(da),
8278 lives_signal_sync_connect(LIVES_GUI_OBJECT(button), LIVES_WIDGET_STATE_CHANGED_SIGNAL,
8279 LIVES_GUI_CALLBACK(sbutt_render), NULL);
8280 #ifdef USE_SPECIAL_BUTTONS
8295 txt ? lives_strdup(txt) : NULL);
8301 int width,
int height) {
8315 static LiVESWidget *_lives_standard_button_set_full(LiVESWidget *
sbutt, LiVESBox * box,
8316 boolean fake_default,
const char *ttips) {
8317 LiVESWidget *img_tips = NULL, *hbox;
8324 LiVESWidget *layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(box),
WH_LAYOUT_KEY);
8325 int packing_width = 0;
8330 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
8332 }
else hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
8342 expand, packing_width);
8347 add_warn_image(
sbutt, hbox);
8353 #ifdef USE_SPECIAL_BUTTONS
8356 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(LIVES_WIDGET_OBJECT(
sbutt)),
8359 sbutt_render(
sbutt, 0, NULL);
8367 int height, LiVESBox * box,
8368 boolean fake_default,
8369 const char *ttips) {
8371 return _lives_standard_button_set_full(
sbutt, box, fake_default, ttips);
8376 int width,
int height, LiVESBox * box,
8377 boolean fake_default,
8378 const char *ttips) {
8380 return _lives_standard_button_set_full(
sbutt, box, fake_default, ttips);
8384 LiVESWidget *hpaned;
8386 #if !GTK_CHECK_VERSION(3, 0, 0)
8389 hpaned = gtk_paned_new(LIVES_ORIENTATION_HORIZONTAL);
8390 gtk_paned_set_wide_handle(GTK_PANED(hpaned),
TRUE);
8393 #if GTK_CHECK_VERSION(3, 16, 0)
8399 "background-image", tmp);
8411 LiVESWidget *vpaned;
8413 #if GTK_CHECK_VERSION(3, 0, 0)
8416 vpaned = gtk_paned_new(LIVES_ORIENTATION_VERTICAL);
8417 gtk_paned_set_wide_handle(GTK_PANED(vpaned),
TRUE);
8420 #if GTK_CHECK_VERSION(3, 16, 0)
8426 "background-image", tmp);
8444 #if !GTK_CHECK_VERSION(3, 16, 0)
8462 #if !GTK_CHECK_VERSION(3, 16, 0)
8480 #if !GTK_CHECK_VERSION(3, 16, 0)
8498 #if !GTK_CHECK_VERSION(3, 16, 0)
8517 #if !GTK_CHECK_VERSION(3, 16, 0)
8535 #if !GTK_CHECK_VERSION(3, 16, 0)
8554 #if !GTK_CHECK_VERSION(3, 16, 0)
8565 static void togglevar_cb(LiVESWidget * w,
boolean * var) {
if (var) *var = !(*var);}
8572 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(mi), LIVES_WIDGET_TOGGLED_SIGNAL,
8573 LIVES_GUI_CALLBACK(togglevar_cb),
8582 #if GTK_CHECK_VERSION(3, 16, 0)
8584 char *colref = gdk_rgba_to_string(bg_color);
8590 colref = gdk_rgba_to_string(act_color);
8602 LiVESWidget *label = NULL;
8611 #if !GTK_CHECK_VERSION(3, 24, 0)
8622 #if !GTK_CHECK_VERSION(3, 16, 0)
8623 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(label), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
8624 LIVES_GUI_CALLBACK(widget_state_cb),
8626 widget_state_cb(LIVES_WIDGET_OBJECT(label), NULL, NULL);
8636 LiVESWidget *img_tips = make_ttips_image_for(label, tips);
8637 LiVESWidget *hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
8640 add_warn_image(label, hbox);
8650 char *text, *text2, *text3;
8651 va_start(xargs, fmt);
8652 text = lives_strdup_vprintf(fmt, xargs);
8654 text2 = lives_markup_escape_text(text, -1);
8694 LiVESWidget *darea = NULL;
8696 darea = gtk_drawing_area_new();
8700 #if GTK_CHECK_VERSION(4, 0, 0)
8701 gtk_drawing_area_set_draw_func(darea, callback, (livespointer)ppsurf, NULL);
8704 LIVES_GUI_CALLBACK(callback),
8705 (livespointer)ppsurf);
8707 lives_signal_sync_connect(LIVES_GUI_OBJECT(darea), LIVES_WIDGET_CONFIGURE_EVENT,
8709 (livespointer)ppsurf);
8721 LiVESWidget *label = NULL;
8734 LiVESWidget *label = NULL;
8753 #if !GTK_CHECK_VERSION(3, 24, 0)
8762 "border-color", colref);
8767 "border-color", colref);
8780 if (justify == LIVES_JUSTIFY_CENTER)
return LIVES_ALIGN_CENTER;
8781 else return LIVES_ALIGN_END;
8787 #if GTK_CHECK_VERSION(3, 4, 0)
8789 if (gdk_event_get_scroll_deltas(LIVES_XEVENT(event), &dx, &dy)) {
8790 if (dy < 0.)
return LIVES_SCROLL_UP;
8791 if (dy > 0.)
return LIVES_SCROLL_DOWN;
8794 #if GTK_CHECK_VERSION(3, 2, 0)
8795 LiVESScrollDirection direction;
8796 gdk_event_get_scroll_direction(LIVES_XEVENT(event), &direction);
8799 return event->direction;
8802 return LIVES_SCROLL_UP;
8806 static LiVESWidget *_make_label_eventbox(
const char *labeltext, LiVESWidget * widget,
boolean add_sens) {
8818 if (widget && (LIVES_IS_TOGGLE_BUTTON(widget) || LIVES_IS_TOGGLE_TOOL_BUTTON(widget))) {
8819 lives_signal_sync_connect(LIVES_GUI_OBJECT(eventbox), LIVES_WIDGET_BUTTON_PRESS_EVENT,
8834 #if !GTK_CHECK_VERSION(3, 16, 0)
8835 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(label), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
8836 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
8843 return _make_label_eventbox(labeltext, widget,
TRUE);
8847 static void sens_insens_cb(LiVESWidgetObject *
object, livespointer pspec, livespointer user_data) {
8848 LiVESWidget *widget = (LiVESWidget *)
object;
8849 LiVESWidget *other = (LiVESWidget *)user_data;
8859 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(w1), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
8860 LIVES_GUI_CALLBACK(sens_insens_cb),
8866 static void lives_widget_show_all_cb(LiVESWidget * other, livespointer user_data) {
8867 LiVESWidget *controller;
8869 if (LIVES_IS_WIDGET_OBJECT(other)) {
8871 controller = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(other),
8880 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(other),
TTIPS_HIDE_KEY)) {
8904 if (!widget || !other)
return FALSE;
8905 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(other),
8908 lives_signal_sync_connect(LIVES_GUI_OBJECT(other), LIVES_WIDGET_SHOW_SIGNAL,
8909 LIVES_GUI_CALLBACK(lives_widget_show_all_cb),
8910 (livespointer)(widget));
8912 lives_signal_sync_connect_swapped(LIVES_GUI_OBJECT(widget), LIVES_WIDGET_SHOW_SIGNAL,
8913 LIVES_GUI_CALLBACK(lives_widget_show_all_cb),
8914 (livespointer)(other));
8916 lives_signal_sync_connect_swapped(LIVES_GUI_OBJECT(widget), LIVES_WIDGET_HIDE_SIGNAL,
8918 (livespointer)(other));
8926 if (!widget || !other)
return FALSE;
8928 (widget, LIVES_GUI_CALLBACK(lives_widget_show_all_cb), (livespointer)other);
8930 (other, LIVES_GUI_CALLBACK(lives_widget_show_all_cb), (livespointer)widget);
8931 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(other),
8945 const char *tooltip) {
8946 LiVESWidget *swtch = NULL;
8947 #if !LIVES_HAS_SWITCH_WIDGET
8950 LiVESWidget *eventbox = NULL;
8951 LiVESWidget *container = NULL;
8953 LiVESWidget *img_tips = NULL;
8955 #if GTK_CHECK_VERSION(3, 14, 0)
8969 int packing_width = 0;
8989 !eventbox ? packing_width : 0);
8996 add_warn_image(swtch, hbox);
9004 #if GTK_CHECK_VERSION(3, 0, 0)
9005 #if GTK_CHECK_VERSION(3, 16, 0)
9012 #if GTK_CHECK_VERSION(3, 16, 0)
9019 "background-image", tmp);
9026 "background-image", tmp);
9035 "background-image", tmp);
9049 const char *tooltip) {
9050 LiVESWidget *checkbutton = NULL;
9051 LiVESWidget *eventbox = NULL;
9053 LiVESWidget *container = NULL;
9054 LiVESWidget *img_tips = NULL;
9056 #if GTK_CHECK_VERSION(3, 14, 0)
9063 #if LIVES_HAS_SWITCH_WIDGET
9074 int packing_width = 0;
9094 !eventbox ? packing_width : 0);
9101 add_warn_image(checkbutton, hbox);
9111 #if GTK_CHECK_VERSION(3, 0, 0)
9113 #if GTK_CHECK_VERSION(3, 16, 0)
9122 "background-image", tmp);
9124 "background-image", tmp);
9126 "border-image", tmp);
9149 "background-color", colref);
9164 boolean active =
FALSE;
9165 LiVESWidget *checkbutton;
9166 #if GTK_CHECK_VERSION(3, 16, 0)
9169 if (togglevalue) active = *togglevalue;
9172 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(checkbutton), LIVES_WIDGET_TOGGLED_SIGNAL,
9183 lives_signal_sync_connect(LIVES_GUI_OBJECT(checkbutton), LIVES_WIDGET_EXPOSE_EVENT,
9188 "box-shadow",
"4px 0 alpha(white, 0.5)");
9189 #if GTK_CHECK_VERSION(3, 16, 0)
9194 "background-color", colref);
9207 "transition-duration",
"0.2s");
9216 boolean * togglevalue) {
9229 LiVESToolItem *toolitem = NULL;
9237 LiVESWidget *widget = (LiVESWidget *)list->data;
9238 if (LIVES_IS_VBOX(widget)) {
9242 LiVESWidget *child = (LiVESWidget *)list2->data;
9250 list2 = list2->next;
9253 list2 = list2->next;
9254 lives_list_free(children2);
9258 lives_list_free(children);
9266 LiVESWidget *radiobutton = NULL;
9270 LiVESWidget *eventbox = NULL;
9271 LiVESWidget *img_tips = NULL;
9274 #if GTK_CHECK_VERSION(3, 16, 0)
9289 int packing_width = 0;
9306 !eventbox ? packing_width : 0);
9315 add_warn_image(radiobutton, hbox);
9325 #if GTK_CHECK_VERSION(3, 16, 0)
9335 "background-image", tmp);
9349 "background-image", tmp);
9386 size_t maxlen = strlen(txt);
9389 if (strlen(txt) > maxlen) maxlen = strlen(txt);
9391 if (dp > 0) maxlen += dp + 1;
9398 double max,
double step,
double page,
int dp, LiVESBox * box,
9399 const char *tooltip) {
9401 LiVESWidget *spinbutton = NULL;
9402 LiVESWidget *img_tips = NULL;
9403 LiVESWidget *eventbox = NULL;
9404 LiVESWidget *container = NULL;
9406 LiVESAdjustment *adj;
9408 #if GTK_CHECK_VERSION(3, 14, 0)
9435 gtk_spin_button_set_numeric(LIVES_SPIN_BUTTON(spinbutton),
TRUE);
9436 gtk_entry_set_overwrite_mode(LIVES_ENTRY(spinbutton),
TRUE);
9440 LiVESWidget *layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(box),
9442 int packing_width = 0;
9464 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9477 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9484 add_warn_image(spinbutton, hbox);
9494 #if !GTK_CHECK_VERSION(3, 16, 0)
9518 set_css_value_direct(spinbutton, LIVES_WIDGET_STATE_NORMAL,
"entry selection",
"background-color", colref);
9521 set_css_value_direct(spinbutton, LIVES_WIDGET_STATE_NORMAL,
"entry selection",
"color", colref);
9533 static void setminsz(LiVESWidget * widget, livespointer data) {
9535 if (LIVES_IS_BUTTON(widget)) {
9539 if (LIVES_IS_CONTAINER(widget)) {
9545 LiVESWidget *combo = NULL;
9551 LiVESWidget *eventbox = NULL;
9552 LiVESWidget *container = NULL;
9554 LiVESWidget *img_tips = NULL;
9581 lives_signal_sync_connect_swapped(LIVES_GUI_OBJECT(entry), LIVES_WIDGET_BUTTON_RELEASE_EVENT,
9585 LiVESWidget *layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(box),
WH_LAYOUT_KEY);
9586 int packing_width = 0;
9605 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9614 expand, !eventbox ? packing_width : 0);
9621 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9628 add_warn_image(combo, hbox);
9644 #if GTK_CHECK_VERSION(3, 0, 0)
9648 set_css_value_direct(LIVES_WIDGET(entry), LIVES_WIDGET_STATE_NORMAL,
"",
"border-radius",
"5px");
9650 #if !GTK_CHECK_VERSION(3, 16, 0)
9657 set_css_value_direct(LIVES_WIDGET(entry), LIVES_WIDGET_STATE_NORMAL,
"",
"border-color", colref);
9665 #if !GTK_CHECK_VERSION(3, 16, 0)
9668 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(entry), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
9669 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
9670 widget_state_cb(LIVES_WIDGET_OBJECT(entry), NULL, NULL);
9671 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(combo), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
9672 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
9673 widget_state_cb(LIVES_WIDGET_OBJECT(combo), NULL, NULL);
9689 LiVESBox * box,
const char *tooltip) {
9690 LiVESWidget *entry = NULL;
9691 LiVESWidget *img_tips = NULL;
9692 LiVESWidget *container = NULL;
9693 LiVESWidget *hbox = NULL;
9694 LiVESWidget *eventbox = NULL;
9732 LiVESWidget *layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(box),
9734 int packing_width = 0;
9755 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9768 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
9775 add_warn_image(entry, hbox);
9785 #if GTK_CHECK_VERSION(3, 0, 0)
9787 #if GTK_CHECK_VERSION(3, 16, 0)
9791 set_css_value_direct(LIVES_WIDGET(entry), LIVES_WIDGET_STATE_NORMAL,
"",
"border-color", colref);
9792 set_css_value_direct(LIVES_WIDGET(entry), LIVES_WIDGET_STATE_FOCUSED,
"",
"border-color", colref);
9798 set_css_value_direct(LIVES_WIDGET(entry), LIVES_WIDGET_STATE_NORMAL,
"selection",
"background-color", colref);
9804 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(entry), LIVES_WIDGET_NOTIFY_SIGNAL
"editable",
9805 LIVES_GUI_CALLBACK(edit_state_cb), NULL);
9806 #if !GTK_CHECK_VERSION(3, 16, 0)
9812 #if !GTK_CHECK_VERSION(3, 16, 0)
9813 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(entry), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
9814 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
9815 widget_state_cb(LIVES_WIDGET_OBJECT(entry), NULL, NULL);
9826 #ifdef PROGBAR_IS_ENTRY
9848 #if GTK_CHECK_VERSION(3, 0, 0)
9849 #if GTK_CHECK_VERSION(3, 16, 0)
9852 #ifdef PROGBAR_IS_ENTRY
9857 #if GTK_CHECK_VERSION(3, 16, 0)
9862 "background-image", tmp);
9864 "background-color", colref);
9868 "border-color", colref);
9870 #ifdef PROGBAR_IS_ENTRY
9874 "background-image", tmp);
9881 #ifdef PROGBAR_IS_ENTRY
9882 set_css_min_size_selected(pbar,
"progress", -1, -1);
9897 LiVESWidget *first_button;
9900 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
NWIDTH_KEY, LIVES_INT_TO_POINTER(bwidth));
9901 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
THEME_KEY,
9906 if (!(first_button =
9907 (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(dialog),
FBUTT_KEY))) {
9908 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(dialog),
FBUTT_KEY, (livespointer)button);
9913 LIVES_POINTER_TO_INT(lives_widget_object_get_data
9914 (LIVES_WIDGET_OBJECT(first_button),
NWIDTH_KEY)));
9925 #if GTK_CHECK_VERSION(2, 18, 0)
9926 LiVESWidget *entry = NULL;
9927 while (LIVES_IS_CONTAINER(widget)) {
9929 if (!fchild || fchild == widget)
break;
9933 if (LIVES_IS_COMBO(widget)) {
9935 }
else entry = widget;
9937 if (entry && LIVES_IS_ENTRY(entry)) {
9940 LiVESWidget *button;
9941 if (!LIVES_IS_WIDGET(toplevel))
return;
9942 button = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(toplevel),
DEFBUTTON_KEY);
9945 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(toplevel),
CDEF_KEY, NULL);
9956 LiVESButtonBoxStyle bstyle) {
9965 LIVES_KEY_Escape, (LiVESXModifierType)0, (LiVESAccelFlags)0);
9974 LiVESWidget *dialog = NULL;
9986 if (width <= 0) width = 8;
9987 if (height <= 0) height = 8;
9997 #if !GTK_CHECK_VERSION(3, 0, 0)
9998 if (height > 8 && width > 8) {
10001 #if !GTK_CHECK_VERSION(3, 0, 0)
10022 #if GTK_CHECK_VERSION(2, 18, 0)
10024 LIVES_WIDGET_SET_FOCUS_CHILD_SIGNAL,
10034 if (add_std_buttons) {
10040 LIVES_STOCK_CANCEL, NULL, LIVES_RESPONSE_CANCEL);
10043 LIVES_STOCK_OK, NULL, LIVES_RESPONSE_OK);
10047 lives_signal_sync_connect(LIVES_GUI_OBJECT(cancelbutton), LIVES_WIDGET_CLICKED_SIGNAL,
10051 LIVES_KEY_Escape, (LiVESXModifierType)0, (LiVESAccelFlags)0);
10054 #if !GTK_CHECK_VERSION(3, 16, 0)
10055 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(cancelbutton), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
10056 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
10057 widget_state_cb(LIVES_WIDGET_OBJECT(cancelbutton), NULL, NULL);
10059 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(okbutton), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
10060 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
10061 widget_state_cb(LIVES_WIDGET_OBJECT(okbutton), NULL, NULL);
10068 lives_signal_sync_connect(LIVES_GUI_OBJECT(dialog), LIVES_WIDGET_DELETE_EVENT,
10069 LIVES_GUI_CALLBACK(return_true), NULL);
10082 LiVESWidget *font_choo = NULL;
10085 #if GTK_CHECK_VERSION(3, 2, 0)
10087 font_choo = gtk_font_button_new();
10088 gtk_font_button_set_show_size(GTK_FONT_BUTTON(font_choo),
FALSE);
10089 gtk_font_chooser_set_show_preview_entry(GTK_FONT_CHOOSER(font_choo),
TRUE);
10090 gtk_font_chooser_set_preview_text(GTK_FONT_CHOOSER(font_choo),
"LiVES");
10092 gtk_font_button_set_title(GTK_FONT_BUTTON(font_choo), ttl);
10099 #if GTK_CHECK_VERSION(3, 16, 0)
10100 set_css_min_size(font_choo, width, height);
10110 set_css_value_direct(LIVES_WIDGET(font_choo), LIVES_WIDGET_STATE_NORMAL,
"",
"border-color", colref);
10112 set_css_value_direct(LIVES_WIDGET(font_choo), LIVES_WIDGET_STATE_PRELIGHT,
"",
"box-shadow", tmp);
10116 set_css_value_direct(LIVES_WIDGET(font_choo), LIVES_WIDGET_STATE_NORMAL,
"",
"background-color", colref);
10129 static LiVESWidget *lives_standard_dfentry_new(
const char *labeltext,
const char *txt,
const char *defdir,
int dispwidth,
10131 LiVESBox * box,
const char *tooltip,
boolean isdir) {
10132 LiVESWidget *direntry = NULL;
10133 LiVESWidget *buttond;
10134 LiVESWidget *img_tips;
10135 LiVESWidget *warn_img;
10137 if (!box)
return NULL;
10148 if ((warn_img = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(direntry),
WARN_IMAGE_KEY))) {
10151 }
else if ((img_tips = lives_widget_object_get_data(LIVES_WIDGET_OBJECT(direntry),
HAS_TTIPS_IMAGE_KEY))) {
10157 (livespointer)direntry);
10166 LiVESBox * box,
const char *tooltip) {
10167 return lives_standard_dfentry_new(labeltext, txt, txt, dispwidth, maxchars, box, tooltip,
TRUE);
10172 const char *defdir,
10173 int dispwidth,
int maxchars, LiVESBox * box,
const char *tooltip) {
10174 return lives_standard_dfentry_new(labeltext, txt, defdir, dispwidth, maxchars, box, tooltip,
FALSE);
10184 #if GTK_CHECK_VERSION(3, 0, 0)
10193 LiVESWidget *hscale = NULL;
10195 #if GTK_CHECK_VERSION(3, 0, 0)
10196 hscale = gtk_scale_new(LIVES_ORIENTATION_HORIZONTAL, adj);
10199 #if GTK_CHECK_VERSION(3, 16, 0)
10203 "background-image", tmp);
10211 "background-image", tmp);
10223 hscale = gtk_hscale_new(adj);
10225 gtk_scale_set_draw_value(LIVES_SCALE(hscale),
FALSE);
10232 LiVESWidget *hruler = NULL;
10235 #if GTK_CHECK_VERSION(3, 0, 0)
10236 hruler = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, NULL);
10237 gtk_scale_set_draw_value(GTK_SCALE(hruler),
FALSE);
10238 #if GTK_CHECK_VERSION(3, 4, 0)
10239 gtk_scale_set_has_origin(GTK_SCALE(hruler),
FALSE);
10241 gtk_scale_set_digits(GTK_SCALE(hruler), 8);
10243 hruler = gtk_hruler_new();
10255 LiVESAdjustment *adj;
10256 if (!sw)
return -1.;
10258 if (pos == LIVES_POS_TOP || pos == LIVES_POS_BOTTOM) {
10273 LiVESWidget *scrolledwindow = NULL;
10274 LiVESWidget *swchild;
10278 LIVES_POLICY_AUTOMATIC, LIVES_POLICY_AUTOMATIC);
10289 #if GTK_CHECK_VERSION(3, 0, 0)
10290 if (!LIVES_IS_SCROLLABLE(child))
10292 if (!LIVES_IS_TEXT_VIEW(child))
10298 LiVESWidget *align;
10315 if (width > -1 || height > -1)
10332 if (GTK_IS_VIEWPORT(swchild))
10333 gtk_viewport_set_shadow_type(GTK_VIEWPORT(swchild), LIVES_SHADOW_IN);
10335 if (width != 0 && height != 0) {
10336 #if !GTK_CHECK_VERSION(3, 0, 0)
10337 if (width > -1 || height > -1)
10347 return scrolledwindow;
10352 LiVESWidget *expander = NULL, *container = NULL, *label = NULL;
10360 }
else labeltext = lives_strdup(ltext);
10368 int packing_width = 0;
10370 hbox = make_inner_hbox(LIVES_BOX(box),
TRUE);
10395 #if !GTK_CHECK_VERSION(3, 16, 0)
10396 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(expander), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
10397 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
10398 widget_state_cb(LIVES_WIDGET_OBJECT(expander), NULL, NULL);
10401 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(
widget_opts.
last_label), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
10402 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
10434 LiVESWidget *textview;
10471 LiVESWidget *fbutton;
10476 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(fbutton),
ISDIR_KEY, LIVES_INT_TO_POINTER(is_dir));
10477 if (def_dir) lives_widget_object_set_data(LIVES_WIDGET_OBJECT(fbutton),
DEFDIR_KEY, (livespointer)def_dir);
10484 return (
boolean)LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
10489 static void _on_lock_button_clicked(LiVESButton * button, livespointer user_data) {
10490 LiVESWidget *image;
10491 int locked = !(LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
10493 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(button),
ISLOCKED_KEY, LIVES_INT_TO_POINTER(locked));
10507 _on_lock_button_clicked(lockbutton, NULL);
10513 _on_lock_button_clicked(button, NULL);
10521 const char *tooltip) {
10522 LiVESWidget *lockbutton;
10526 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(lockbutton),
ISLOCKED_KEY, LIVES_INT_TO_POINTER(!is_locked));
10527 lives_signal_sync_connect(lockbutton, LIVES_WIDGET_CLICKED_SIGNAL, LIVES_GUI_CALLBACK(_on_lock_button_clicked), NULL);
10533 static void on_pwcolselx(LiVESButton * button,
lives_rfx_t *rfx) {
10534 LiVESWidgetColor selected;
10535 LiVESWidget *sp_red = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
SPRED_KEY);
10536 LiVESWidget *sp_green = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
SPGREEN_KEY);
10537 LiVESWidget *sp_blue = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
SPBLUE_KEY);
10538 LiVESWidget *sp_alpha = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(button),
SPALPHA_KEY);
10546 r = (int)((
double)(selected.red + LIVES_WIDGET_COLOR_SCALE_255(0.5)) / (
double)LIVES_WIDGET_COLOR_SCALE_255(1.));
10551 g = (int)((
double)(selected.green + LIVES_WIDGET_COLOR_SCALE_255(0.5)) / (
double)LIVES_WIDGET_COLOR_SCALE_255(1.));
10556 b = (int)((
double)(selected.blue + LIVES_WIDGET_COLOR_SCALE_255(0.5)) / (
double)LIVES_WIDGET_COLOR_SCALE_255(1.));
10561 #if !LIVES_WIDGET_COLOR_HAS_ALPHA
10564 a = (int)((
double)(selected.alpha + LIVES_WIDGET_COLOR_SCALE_255(0.5)) / (
double)LIVES_WIDGET_COLOR_SCALE_255(1.));
10573 static void after_param_red_changedx(LiVESSpinButton * spinbutton, livespointer udata) {
10574 LiVESWidgetColor colr;
10576 LiVESWidget *cbutton = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(spinbutton),
CBUTTON_KEY);
10577 LiVESWidget *sp_green = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPGREEN_KEY);
10578 LiVESWidget *sp_blue = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPBLUE_KEY);
10579 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10580 LiVESWidget *sp_alpha = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPALPHA_KEY);
10587 colr.red = LIVES_WIDGET_COLOR_SCALE_255(new_red);
10588 colr.green = LIVES_WIDGET_COLOR_SCALE_255(old_green);
10589 colr.blue = LIVES_WIDGET_COLOR_SCALE_255(old_blue);
10591 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10594 colr.alpha = LIVES_WIDGET_COLOR_SCALE_255(old_alpha);
10595 }
else colr.alpha = 1.0;
10601 static void after_param_green_changedx(LiVESSpinButton * spinbutton, livespointer udata) {
10602 LiVESWidgetColor colr;
10604 LiVESWidget *cbutton = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(spinbutton),
CBUTTON_KEY);
10605 LiVESWidget *sp_red = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPRED_KEY);
10606 LiVESWidget *sp_blue = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPBLUE_KEY);
10607 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10608 LiVESWidget *sp_alpha = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPALPHA_KEY);
10615 colr.red = LIVES_WIDGET_COLOR_SCALE_255(old_red);
10616 colr.green = LIVES_WIDGET_COLOR_SCALE_255(new_green);
10617 colr.blue = LIVES_WIDGET_COLOR_SCALE_255(old_blue);
10619 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10622 colr.alpha = LIVES_WIDGET_COLOR_SCALE_255(old_alpha);
10623 }
else colr.alpha = 1.0;
10629 static void after_param_blue_changedx(LiVESSpinButton * spinbutton, livespointer udata) {
10630 LiVESWidgetColor colr;
10632 LiVESWidget *cbutton = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(spinbutton),
CBUTTON_KEY);
10633 LiVESWidget *sp_green = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPGREEN_KEY);
10634 LiVESWidget *sp_red = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPRED_KEY);
10635 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10636 LiVESWidget *sp_alpha = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPALPHA_KEY);
10643 colr.red = LIVES_WIDGET_COLOR_SCALE_255(old_red);
10644 colr.green = LIVES_WIDGET_COLOR_SCALE_255(old_green);
10645 colr.blue = LIVES_WIDGET_COLOR_SCALE_255(new_blue);
10647 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10650 colr.alpha = LIVES_WIDGET_COLOR_SCALE_255(old_alpha);
10651 }
else colr.alpha = 1.0;
10657 static void after_param_alpha_changedx(LiVESSpinButton * spinbutton, livespointer udata) {
10658 LiVESWidgetColor colr;
10660 LiVESWidget *cbutton = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(spinbutton),
CBUTTON_KEY);
10661 LiVESWidget *sp_green = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPGREEN_KEY);
10662 LiVESWidget *sp_blue = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPBLUE_KEY);
10663 LiVESWidget *sp_red = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(cbutton),
SPRED_KEY);
10670 colr.red = LIVES_WIDGET_COLOR_SCALE_255(old_red);
10671 colr.green = LIVES_WIDGET_COLOR_SCALE_255(old_green);
10672 colr.blue = LIVES_WIDGET_COLOR_SCALE_255(old_blue);
10674 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10675 colr.alpha = LIVES_WIDGET_COLOR_SCALE_255(new_alpha);
10684 LiVESWidget **sb_red, LiVESWidget **sb_green, LiVESWidget **sb_blue, LiVESWidget **sb_alpha) {
10685 LiVESWidgetColor colr;
10686 LiVESWidget *cbutton, *labelcname = NULL;
10687 LiVESWidget *hbox = NULL;
10688 LiVESWidget *layout;
10690 LiVESWidget *spinbutton_red = NULL, *spinbutton_green = NULL, *spinbutton_blue = NULL, *spinbutton_alpha = NULL;
10691 LiVESWidget *parent = NULL;
10694 int packing_width = 0;
10696 boolean parent_is_layout =
FALSE;
10697 boolean expand =
FALSE;
10705 if (parent && LIVES_IS_TABLE(parent) &&
10706 lives_widget_object_get_data(LIVES_WIDGET_OBJECT(parent),
WADDED_KEY)) {
10707 parent_is_layout =
TRUE;
10709 hbox = LIVES_WIDGET(box);
10718 colr.red = LIVES_WIDGET_COLOR_SCALE_65535(rgba->
red);
10719 colr.green = LIVES_WIDGET_COLOR_SCALE_65535(rgba->
green);
10720 colr.blue = LIVES_WIDGET_COLOR_SCALE_65535(rgba->
blue);
10721 #if LIVES_WIDGET_COLOR_HAS_ALPHA
10722 if (use_alpha) colr.alpha = LIVES_WIDGET_COLOR_SCALE_65535(rgba->
alpha);
10723 else colr.alpha = 1.;
10734 #if !LIVES_WIDGET_COLOR_HAS_ALPHA
10756 if (parent_is_layout) {
10764 layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY);
10765 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, NULL);
10767 (LiVESBox *)hbox, (tmp2 = (
_(
"The red value (0 - 255)"))));
10771 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, layout);
10772 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(spinbutton_red),
CBUTTON_KEY, cbutton);
10773 *sb_red = spinbutton_red;
10774 lives_signal_sync_connect(LIVES_GUI_OBJECT(spinbutton_red), LIVES_WIDGET_VALUE_CHANGED_SIGNAL,
10775 LIVES_GUI_CALLBACK(after_param_red_changedx), NULL);
10776 if (parent_is_layout) {
10784 layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY);
10785 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, NULL);
10787 (LiVESBox *)hbox, (tmp2 = (
_(
"The green value (0 - 255)"))));
10791 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, layout);
10792 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(spinbutton_green),
CBUTTON_KEY, cbutton);
10793 *sb_green = spinbutton_green;
10794 lives_signal_sync_connect(LIVES_GUI_OBJECT(spinbutton_green), LIVES_WIDGET_VALUE_CHANGED_SIGNAL,
10795 LIVES_GUI_CALLBACK(after_param_green_changedx), NULL);
10796 if (parent_is_layout) {
10804 layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY);
10805 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, NULL);
10807 (LiVESBox *)hbox, (tmp2 = (
_(
"The blue value (0 - 255)"))));
10811 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, layout);
10812 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(spinbutton_blue),
CBUTTON_KEY, cbutton);
10813 *sb_blue = spinbutton_blue;
10814 lives_signal_sync_connect(LIVES_GUI_OBJECT(spinbutton_blue), LIVES_WIDGET_VALUE_CHANGED_SIGNAL,
10815 LIVES_GUI_CALLBACK(after_param_blue_changedx), NULL);
10816 if (parent_is_layout) {
10823 if (use_alpha && sb_alpha) {
10824 layout = (LiVESWidget *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY);
10825 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, NULL);
10827 (LiVESBox *)hbox, (tmp2 = (
_(
"The alpha value (0 - 255)"))));
10831 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(hbox),
WH_LAYOUT_KEY, layout);
10832 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(spinbutton_alpha),
CBUTTON_KEY, cbutton);
10833 *sb_alpha = spinbutton_alpha;
10834 lives_signal_sync_connect(LIVES_GUI_OBJECT(spinbutton_alpha), LIVES_WIDGET_VALUE_CHANGED_SIGNAL,
10835 LIVES_GUI_CALLBACK(after_param_alpha_changedx), NULL);
10836 if (parent_is_layout) {
10843 if (parent_is_layout) {
10845 hbox = make_inner_hbox(LIVES_BOX(hbox),
TRUE);
10851 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(cbutton),
SPRED_KEY, spinbutton_red);
10852 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(cbutton),
SPGREEN_KEY, spinbutton_green);
10853 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(cbutton),
SPBLUE_KEY, spinbutton_blue);
10854 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(cbutton),
SPALPHA_KEY, spinbutton_alpha);
10864 if (parent_is_layout) {
10874 if (parent_is_layout) {
10878 lives_signal_sync_connect(LIVES_GUI_OBJECT(cbutton), LIVES_WIDGET_COLOR_SET_SIGNAL,
10879 LIVES_GUI_CALLBACK(on_pwcolselx), NULL);
10888 #if GTK_CHECK_VERSION(3, 10, 0)
10890 static const char *LIVES_STOCK_ALTS[N_STOCK_ALTS];
10893 return LIVES_STOCK_ALTS[alt_stock_id];
10896 static const char *lives_icon_get_stock_alt(LiVESIconTheme * icon_theme,
const char *str, ...)
GNU_SENTINEL;
10897 static const
char *lives_icon_get_stock_alt(LiVESIconTheme * icon_theme, const
char *str, ...) {
10899 va_start(xargs, str);
10900 for (; str; str++) {
10901 if (
lives_has_icon(icon_theme, str, LIVES_ICON_SIZE_BUTTON))
break;
10910 #if GTK_CHECK_VERSION(3, 10, 0)
10911 LIVES_STOCK_ALTS[STOCK_ALTS_MEDIA_PAUSE] =
10912 lives_icon_get_stock_alt(icon_theme, LIVES_STOCK_MEDIA_PAUSE_ALT_1, LIVES_STOCK_MEDIA_PAUSE_ALT_2, (
char *)NULL);
10913 LIVES_STOCK_ALTS[STOCK_ALTS_KEEP] =
10914 lives_icon_get_stock_alt(icon_theme, LIVES_STOCK_KEEP_ALT_1, LIVES_STOCK_KEEP_ALT_2, (
char *)NULL);
10921 GSList *flist, *slist;
10922 LiVESList *dlist, *xlist = NULL;
10926 #if !defined(GUI_GTK) || GTK_CHECK_VERSION(3, 10, 0)
10961 gtk_accel_map_add_entry(
"<LiVES>/save", LIVES_KEY_s, LIVES_CONTROL_MASK);
10962 gtk_accel_map_add_entry(
"<LiVES>/quit", LIVES_KEY_q, LIVES_CONTROL_MASK);
10964 slist = flist = gdk_pixbuf_get_formats();
10966 GdkPixbufFormat *form = (GdkPixbufFormat *)slist->data;
10967 char **ext = gdk_pixbuf_format_get_extensions(form);
10968 for (i = 0; ext[i]; i++) {
10971 lives_strfreev(ext);
10972 slist = slist->next;
10974 g_slist_free(flist);
10980 for (i = 0; dlist; i++) {
10982 dlist = dlist->next;
11010 if (GTK_IS_WIDGET(widget) && gtk_widget_is_drawable(widget)) {
11029 if (LIVES_POINTER_TO_INT(fwd))
11031 (tmp2 = lives_utf8_collate_key(b, -1)));
11034 (tmp2 = lives_utf8_collate_key(a, -1)));
11041 static int lives_utf8_menu_strcmpfunc(livesconstpointer a, livesconstpointer b, livespointer fwd) {
11047 return lives_list_sort_with_data(list, lives_utf8_menu_strcmpfunc, LIVES_INT_TO_POINTER(fwd));
11052 LiVESList **seclist;
11054 while (menu_list) {
11055 if (!(LIVES_POINTER_TO_INT(lives_widget_object_get_data(LIVES_WIDGET_OBJECT(menu_list->data),
HIDDEN_KEY)))) {
11058 if ((seclist = (LiVESList **)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(menu_list->data),
SECLIST_KEY)) != NULL)
11059 * seclist = lives_list_prepend(*seclist, lives_widget_object_get_data(LIVES_WIDGET_OBJECT(menu_list->data),
11061 menu_list = menu_list->next;
11067 boolean lives_has_icon(LiVESIconTheme * icon_theme,
const char *stock_id, LiVESIconSize size) {
11068 boolean has_icon =
FALSE;
11070 #if GTK_CHECK_VERSION(3, 0, 0)
11071 GtkIconInfo *iset = gtk_icon_theme_lookup_icon(icon_theme, stock_id, size, 0);
11073 GtkIconSet *iset = gtk_icon_factory_lookup_default(stock_id);
11075 has_icon = (iset != NULL);
11084 (
double)col->
green / 65535.,
11085 (
double)col->
blue / 65535.);
11093 (
double)col->
green / 65535.,
11094 (
double)col->
blue / 65535.);
11100 LiVESWidgetColor * wcol) {
11109 lives_painter_t *cr;
11110 if (!s)
return FALSE;
11123 double x,
double y,
double width,
double height) {
11124 lives_painter_t *cr;
11125 if (!s)
return FALSE;
11130 if (width <= 0.) width = rwidth;
11131 if (height <= 0.) height = rheight;
11141 #if GTK_CHECK_VERSION(3, 0, 0)
11142 g_object_unref(LIVES_GUI_OBJECT(cursor));
11144 gdk_cursor_unref(cursor);
11160 #if GTK_CHECK_VERSION(3, 0, 0)
11164 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
THEME_KEY,
11203 LiVESWidgetColor dimmed_fg;
11215 LiVESWidgetColor dimmed_fg;
11226 GtkListStore *store;
11227 LiVESEntryCompletion *completion;
11228 store = gtk_list_store_new(1, LIVES_COL_TYPE_STRING);
11231 LiVESTreeIter iter;
11232 gtk_list_store_append(store, &iter);
11233 gtk_list_store_set(store, &iter, 0, (
char *)xlist->data, -1);
11234 xlist = xlist->next;
11237 completion = gtk_entry_completion_new();
11238 gtk_entry_completion_set_model(completion, (GtkTreeModel *)store);
11239 gtk_entry_completion_set_text_column(completion, 0);
11240 gtk_entry_completion_set_inline_completion(completion,
TRUE);
11241 gtk_entry_completion_set_popup_set_width(completion,
TRUE);
11242 gtk_entry_completion_set_popup_completion(completion,
TRUE);
11243 gtk_entry_completion_set_popup_single_match(completion,
FALSE);
11244 gtk_entry_set_completion(entry, completion);
11300 static void _toggle_if_condmet(LiVESWidget * tbut, livespointer widget,
boolean cond,
const char *type) {
11306 condx = (
int *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(tbut), keyval);
11307 if (condx && *condx != 0) cond =
TRUE;
11310 condx = (
int *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(tbut), keyval);
11311 if (condx && *condx <= 0) cond =
FALSE;
11314 if (!strcmp(type,
"sens"))
11316 else if (!strcmp(type,
"visi")) {
11322 static void toggle_set_sensitive(LiVESWidget * tbut, livespointer widget) {
11323 if (LIVES_IS_TOGGLE_BUTTON(tbut))
11325 else if (LIVES_IS_TOGGLE_TOOL_BUTTON(tbut))
11328 else if (LIVES_IS_CHECK_MENU_ITEM(tbut))
11333 static void toggle_set_insensitive(LiVESWidget * tbut, livespointer widget) {
11334 if (LIVES_IS_TOGGLE_BUTTON(tbut))
11337 if (LIVES_IS_TOGGLE_TOOL_BUTTON(tbut))
11340 else if (LIVES_IS_CHECK_MENU_ITEM(tbut))
11345 static void toggle_set_visible(LiVESWidget * tbut, livespointer widget) {
11346 if (LIVES_IS_TOGGLE_BUTTON(tbut))
11348 else if (LIVES_IS_TOGGLE_TOOL_BUTTON(tbut))
11351 else if (LIVES_IS_CHECK_MENU_ITEM(tbut))
11356 static void toggle_set_invisible(LiVESWidget * tbut, livespointer widget) {
11357 if (LIVES_IS_TOGGLE_BUTTON(tbut))
11360 else if (LIVES_IS_TOGGLE_TOOL_BUTTON(tbut))
11363 else if (LIVES_IS_CHECK_MENU_ITEM(tbut))
11371 livespointer condsens, livespointer condinsens,
boolean invert) {
11375 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(tb), keyval, condsens);
11381 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(tb), keyval, condinsens);
11385 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tb), LIVES_WIDGET_TOGGLED_SIGNAL,
11386 LIVES_GUI_CALLBACK(toggle_set_sensitive),
11387 (livespointer)widget);
11388 toggle_set_sensitive(LIVES_WIDGET(tb), (livespointer)widget);
11390 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tb), LIVES_WIDGET_TOGGLED_SIGNAL,
11391 LIVES_GUI_CALLBACK(toggle_set_insensitive),
11392 (livespointer)widget);
11393 toggle_set_insensitive(tb, (livespointer)widget);
11399 livespointer condsens, livespointer condinsens,
boolean invert) {
11403 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(tb), keyval, condsens);
11409 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(tb), keyval, condinsens);
11413 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tb), LIVES_WIDGET_TOGGLED_SIGNAL,
11414 LIVES_GUI_CALLBACK(toggle_set_visible),
11415 (livespointer)widget);
11416 toggle_set_sensitive(tb, (livespointer)widget);
11418 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tb), LIVES_WIDGET_TOGGLED_SIGNAL,
11419 LIVES_GUI_CALLBACK(toggle_set_invisible),
11420 (livespointer)widget);
11421 toggle_set_insensitive(tb, (livespointer)widget);
11457 if (LIVES_IS_TOGGLE_TOOL_BUTTON(togglebutton))
11468 if (LIVES_IS_TOGGLE_TOOL_BUTTON(togglebutton))
11476 boolean label_act_toggle(LiVESWidget * widget, LiVESXEventButton * event, LiVESWidget * togglebutton) {
11478 if (LIVES_IS_TOGGLE_TOOL_BUTTON(togglebutton))
11488 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tbut), LIVES_WIDGET_TOGGLED_SIGNAL,
11489 LIVES_GUI_CALLBACK(togglevar_cb),
11490 (livespointer)var);
11505 static void _set_tooltips_state(LiVESWidget * widget, livespointer state) {
11507 #if GTK_CHECK_VERSION(2, 12, 0)
11509 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_OVERRIDE_KEY))
return;
11511 if (LIVES_POINTER_TO_INT(state)) {
11513 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_HIDE_KEY)) {
11519 ttip = (
char *)lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_KEY);
11522 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_KEY, NULL);
11525 if (lives_widget_object_get_data(LIVES_WIDGET_OBJECT(widget),
TTIPS_HIDE_KEY)) {
11529 ttip = gtk_widget_get_tooltip_text(widget);
11533 if (LIVES_IS_CONTAINER(widget)) {
11544 #if GTK_CHECK_VERSION(2, 12, 0)
11545 _set_tooltips_state(widget, LIVES_INT_TO_POINTER(state));
11554 double stepval, min, max, nval, stepfix;
11555 int digs = gtk_spin_button_get_digits(button);
11556 boolean wrap = gtk_spin_button_get_wrap(button);
11558 gtk_spin_button_get_increments(button, &stepval, NULL);
11559 gtk_spin_button_get_range(button, &min, &max);
11560 stepfix = tenpow / stepval;
11562 nval = (double)((int64_t)(val * stepfix + .5)) / stepfix;
11564 nval = (double)((int64_t)(val * stepfix - .5)) / stepfix;
11566 if (wrap)
while (nval < min) nval += (max - min);
11570 if (wrap)
while (nval > max) nval -= (max - min);
11577 static void set_child_colour_internal(LiVESWidget * widget, livespointer set_allx) {
11578 boolean set_all = LIVES_POINTER_TO_INT(set_allx);
11580 if (!set_all && LIVES_IS_BUTTON(widget))
return;
11581 if (set_all || LIVES_IS_LABEL(widget)) {
11583 if (!LIVES_IS_LABEL(widget))
11586 if (LIVES_IS_CONTAINER(widget)) {
11595 set_child_colour_internal(widget, LIVES_INT_TO_POINTER(set_all));
11599 static void set_child_dimmed_colour_internal(LiVESWidget * widget, livespointer dim) {
11600 int dimval = LIVES_POINTER_TO_INT(dim);
11605 if (LIVES_IS_CONTAINER(widget)) {
11615 set_child_dimmed_colour_internal(widget, LIVES_INT_TO_POINTER(dim));
11619 static void set_child_dimmed_colour2_internal(LiVESWidget * widget, livespointer dim) {
11620 int dimval = LIVES_POINTER_TO_INT(dim);
11624 if (LIVES_IS_CONTAINER(widget)) {
11634 set_child_dimmed_colour2_internal(widget, LIVES_INT_TO_POINTER(dim));
11638 static void set_child_alt_colour_internal(LiVESWidget * widget, livespointer set_allx) {
11639 boolean set_all = LIVES_POINTER_TO_INT(set_allx);
11641 if (!set_all && LIVES_IS_BUTTON(widget))
return;
11643 if (set_all || LIVES_IS_LABEL(widget)) {
11646 lives_widget_object_set_data(LIVES_WIDGET_OBJECT(widget),
11650 if (LIVES_IS_CONTAINER(widget)) {
11660 set_child_alt_colour_internal(widget, LIVES_INT_TO_POINTER(set_all));
11664 static void set_child_alt_colour_internal_prelight(LiVESWidget * widget, livespointer data) {
11666 if (LIVES_IS_CONTAINER(widget)) {
11675 set_child_alt_colour_internal_prelight(widget, NULL);
11679 static void set_child_colour3_internal(LiVESWidget * widget, livespointer set_allx) {
11680 boolean set_all = LIVES_POINTER_TO_INT(set_allx);
11682 if (!set_all && (LIVES_IS_BUTTON(widget))) {
11688 if (set_all || LIVES_IS_LABEL(widget)) {
11692 if (LIVES_IS_CONTAINER(widget)) {
11702 set_child_colour3_internal(widget, LIVES_INT_TO_POINTER(set_all));
11707 LiVESTextIter siter, eiter;
11724 LiVESTextIter xiter;
11735 val = lives_list_index(list, tchild);
11736 lives_list_free(list);
11743 uint32_t padding) {
11752 GValue xbool = G_VALUE_INIT;
11753 g_value_init(&xbool, G_TYPE_BOOLEAN);
11754 g_value_set_boolean(&xbool, val);
11755 gtk_container_child_set_property(c, child,
"shrink", &xbool);
11767 LiVESWidget *child = (LiVESWidget *)list->data;
11768 if (LIVES_IS_MENU_ITEM(child)) {
11778 if (children) lives_list_free(children);
11784 double upper,
double step_increment,
double page_increment) {
11788 #if GTK_CHECK_VERSION(2, 14, 0)
11789 gtk_adjustment_configure(adj, value, lower, upper, step_increment, page_increment, 0.);
11791 g_object_freeze_notify(LIVES_WIDGET_OBJECT(adj));
11792 adj->upper = upper;
11793 adj->lower = lower;
11794 adj->value = value;
11795 adj->step_increment = step_increment;
11796 adj->page_increment = page_increment;
11797 g_object_thaw_notify(LIVES_WIDGET_OBJECT(adj));
11806 LiVESTreeIter * titer2) {
11808 if (gtk_tree_model_iter_children(LIVES_TREE_MODEL(tstore), titer2, titer1)) {
11811 gtk_tree_model_get(LIVES_TREE_MODEL(tstore), titer2, col, &ret, -1);
11817 if (!gtk_tree_model_iter_next(LIVES_TREE_MODEL(tstore), titer2))
break;
11833 static boolean noswitch =
FALSE;
11834 static boolean re_add_idlefunc =
FALSE;
11836 static void do_some_things(
void) {
11869 static void do_more_stuff(
void) {
11879 volatile boolean clutch;
11880 static pthread_mutex_t ctx_mutex = PTHREAD_MUTEX_INITIALIZER;
11881 if (timer_running)
return FALSE;
11883 if (pthread_mutex_trylock(&ctx_mutex))
return FALSE;
11885 LiVESWidgetContext *ctx = lives_widget_context_get_thread_default();
11887 if (ctx && ctx != lives_widget_context_default() && gov_running) {
11899 lives_widget_context_iteration(NULL,
FALSE);
11905 pthread_mutex_unlock(&ctx_mutex);
11912 if (separatormenuitem) {
11916 return separatormenuitem;
11921 LiVESWidget *label;
11922 if (LIVES_IS_MENU_ITEM(menuitem)) {
11940 #if GTK_CHECK_VERSION(3, 10, 0)
11943 return gdk_display_get_n_screens(disp);
11952 LiVESXWindow *window;
11953 GdkCursor *cursor = NULL;
11955 GdkCursorType ctype = GDK_X_CURSOR;
11966 if (!window || !LIVES_IS_XWINDOW(window))
return;
11975 ctype = GDK_CENTER_PTR;
11981 ctype = GDK_SB_H_DOUBLE_ARROW;
11984 ctype = GDK_CROSSHAIR;
11987 ctype = GDK_TOP_LEFT_CORNER;
11990 ctype = GDK_BOTTOM_RIGHT_CORNER;
11998 #if GTK_CHECK_VERSION(2, 22, 0)
11999 cursor = gdk_window_get_cursor(window);
12000 if (cursor && gdk_cursor_get_cursor_type(cursor) == ctype)
return;
12003 disp = gdk_window_get_display(window);
12005 cursor = gdk_cursor_new_for_display(disp, ctype);
12006 gdk_window_set_cursor(window, cursor);
12007 }
else gdk_window_set_cursor(window, NULL);
12022 #if GTK_CHECK_VERSION(2, 16, 0)
12023 if (GDK_IS_WINDOW(window)) {
12024 #if GTK_CHECK_VERSION(3, 16, 0)
12025 GdkCursor *cursor = gdk_cursor_new_for_display(gdk_window_get_display(window), GDK_BLANK_CURSOR);
12027 GdkCursor *cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
12030 gdk_window_set_cursor(window, cursor);
12035 static GdkCursor *hidden_cursor = NULL;
12037 char cursor_bits[] = {0x00};
12038 char cursormask_bits[] = {0x00};
12039 GdkPixmap *source, *mask;
12040 GdkColor fg = { 0, 0, 0, 0 };
12041 GdkColor bg = { 0, 0, 0, 0 };
12043 if (!hidden_cursor) {
12044 source = gdk_bitmap_create_from_data(NULL, cursor_bits, 1, 1);
12045 mask = gdk_bitmap_create_from_data(NULL, cursormask_bits, 1, 1);
12046 hidden_cursor = gdk_cursor_new_from_pixmap(source, mask, &fg, &bg, 0, 0);
12047 g_object_unref(source);
12048 g_object_unref(mask);
12050 if (GDK_IS_WINDOW(window)) gdk_window_set_cursor(window, hidden_cursor);
12086 gtk_revealer_set_reveal_child(GTK_REVEALER(frame),
TRUE);
12095 #if GTK_CHECK_VERSION(3, 0, 0)
12098 boolean *ret = (
boolean *)user_data, active;
12100 active = ((LIVES_IS_TOGGLE_BUTTON(tbutton)
12102 (LIVES_IS_TOGGLE_TOOL_BUTTON(tbutton)
12109 if (ret) *ret = active;
12120 double rad, scalex = 1., scaley = .8;
12123 (LIVES_IS_TOGGLE_TOOL_BUTTON(widget)
12147 rheight - rwidth / 2);
12272 if (!xwin)
return FALSE;
12275 gdk_window_get_origin(xwin, &gww, &gwh);
12358 if (LIVES_IS_HBOX(box)) packing_height = 0;
12369 if (LIVES_IS_VBOX(box)) packing_width = 0;
12383 if (LIVES_IS_HBOX(box)) {
12387 LingoContext *ctx = lives_widget_create_lingo_context(LIVES_WIDGET(box));
12389 if (ctx && LINGO_IS_CONTEXT(ctx)) {
12390 LingoLayout *layout = lingo_layout_new(ctx);
12391 if (layout && LINGO_IS_LAYOUT(layout)) {
12392 lingo_layout_set_text(layout,
"X", -1);
12393 lingo_layout_get_size(layout, &w, NULL);
12422 LiVESWidget *widget;
12435 LiVESWidget *spacer = NULL;
12438 gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(spacer),
FALSE);
12439 gtk_tool_item_set_homogeneous(LIVES_TOOL_ITEM(spacer),
FALSE);
12448 LiVESWidget * actwidg) {
12449 LiVESWidget *item = NULL;
12470 #if !GTK_CHECK_VERSION(3, 0, 0)
12483 gtk_button_box_set_child_secondary(bbox, widget,
TRUE);
12484 gtk_button_box_set_child_non_homogeneous(bbox, widget,
TRUE);
12486 if (LIVES_IS_CONTAINER(widget))
12506 LIVES_BUTTONBOX_CENTER);
12521 if (LIVES_IS_TOOL_BUTTON(button)) {
12522 LiVESWidget *widget, *parent;
12538 const char *tooltips) {
12539 LiVESToolItem *tbutton;
12551 #if !GTK_CHECK_VERSION(3, 16, 0)
12552 lives_signal_sync_connect_after(LIVES_GUI_OBJECT(tbutton), LIVES_WIDGET_NOTIFY_SIGNAL
"sensitive",
12553 LIVES_GUI_CALLBACK(widget_state_cb), NULL);
12554 widget_state_cb(LIVES_WIDGET_OBJECT(tbutton), NULL, NULL);
12559 return LIVES_WIDGET(tbutton);
12566 gtk_accel_map_lookup_entry(path, &key);
12567 gtk_accel_group_disconnect_key(group, key.accel_key, key.accel_mods);
12581 lcolor->
red = LIVES_WIDGET_COLOR_STRETCH(color->red);
12582 lcolor->
green = LIVES_WIDGET_COLOR_STRETCH(color->green);
12583 lcolor->
blue = LIVES_WIDGET_COLOR_STRETCH(color->blue);
12584 #if LIVES_WIDGET_COLOR_HAS_ALPHA
12585 lcolor->
alpha = LIVES_WIDGET_COLOR_STRETCH(color->alpha);
12587 lcolor->
alpha = 65535;
12594 color->red = LIVES_WIDGET_COLOR_SCALE_65535(lcolor->
red);
12595 color->green = LIVES_WIDGET_COLOR_SCALE_65535(lcolor->
green);
12596 color->blue = LIVES_WIDGET_COLOR_SCALE_65535(lcolor->
blue);
12597 #if LIVES_WIDGET_COLOR_HAS_ALPHA
12598 color->alpha = LIVES_WIDGET_COLOR_SCALE_65535(lcolor->
alpha);
12619 LiVESList *textsize_list = NULL;
12621 textsize_list = lives_list_append(textsize_list, (
_(
"Extra extra small")));
12622 textsize_list = lives_list_append(textsize_list, (
_(
"Extra small")));
12623 textsize_list = lives_list_append(textsize_list, (
_(
"Small")));
12624 textsize_list = lives_list_append(textsize_list, (
_(
"Medium")));
12625 textsize_list = lives_list_append(textsize_list, (
_(
"Large")));
12626 textsize_list = lives_list_append(textsize_list, (
_(
"Extra large")));
12627 textsize_list = lives_list_append(textsize_list, (
_(
"Extra extra large")));
12629 return textsize_list;