/* Grabs the pointer (usually a mouse) so that all events are passed to this
* application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
* the grab window becomes unviewable. This overrides any previous pointer
* grab by this client.
* Pointer grabs are used for operations which need complete control over mouse
* events, even if the mouse leaves the application. For example in GTK+ it is
* used for Drag and Drop, for dragging the handle in the GtkHPaned and GtkVPaned
* widgets, and for resizing columns in GtkCList widgets.
* Note that if the event mask of an X window has selected both button press and
* button release events, then a button press event will cause an automatic pointer
* grab until the button is released. X does this automatically since most
* applications expect to receive button press and release events in pairs.
* It is equivalent to a pointer grab on the window with owner_events set to TRUE. */
int
clip_GDK_POINTERGRAB(ClipMachine * ClipMachineMemory)
{
C_widget *cwin = _fetch_cw_arg(ClipMachineMemory);
GdkWindow *win = NULL;
gboolean owner_events = _clip_parl(ClipMachineMemory, 2);
GdkEventMask event_mask = _clip_parnl(ClipMachineMemory, 3);
C_widget *cconfine_to = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 4));
GdkWindow *confine_to = NULL;
C_object *ccursor = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 5));
GdkCursor *cursor = NULL;
CHECKCWID(cwin, GTK_IS_WIDGET);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT2(4, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cwin, GTK_IS_WIDGET);
CHECKOPT2(5, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJOPT(ccursor, GDK_IS_CURSOR(ccursor));
if (cwin && cwin->widget)
win = cwin->widget->window;
if (cconfine_to && cconfine_to->widget)
confine_to = cconfine_to->widget->window;
if (ccursor)
cursor = GDK_CURSOR(ccursor->object);
_clip_retni(ClipMachineMemory, gdk_pointer_grab(win, owner_events, event_mask, confine_to, cursor, GDK_CURRENT_TIME));
return 0;
err:
return 1;
}
/**** WINDOW constructor ****/
int
clip_GTK_WINDOWNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
char *title = _clip_parc(ClipMachineMemory, 2);
gint typ = INT_OPTION(ClipMachineMemory, 3, 0);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
//wid = gtk_window_new(GTK_WINDOW_TOPLEVEL);
wid = gtk_window_new(typ);
if (!wid)
goto err;
if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType)
{
LOCALE_TO_UTF(title);
gtk_window_set_title(GTK_WINDOW(wid), title);
FREE_TEXT(title);
}
//cwid = (C_widget*)calloc( 1, sizeof(C_widget) );
cwid = _register_widget(ClipMachineMemory, wid, cv);
cwid->accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(wid), cwid->accel_group);
// gtk_signal_connect( GTK_OBJECT( wid ), "delete-event",
// GTK_SIGNAL_FUNC( delete_window_handler ), NULL );
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
/* Sets resize policy */
int
clip_GTK_WINDOWSETPOLICY(ClipMachine * ClipMachineMemory)
{
C_widget *cwin = _fetch_cw_arg(ClipMachineMemory);
gboolean AutoShrink = FALSE, AllowShrink = TRUE, AllowGrow = TRUE;
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
CHECKOPT(3, LOGICAL_type_of_ClipVarType);
CHECKOPT(4, LOGICAL_type_of_ClipVarType);
CHECKCWID(cwin, GTK_IS_WINDOW);
if (_clip_parinfo(ClipMachineMemory, 2) == LOGICAL_type_of_ClipVarType)
AutoShrink = _clip_parl(ClipMachineMemory, 2);
if (_clip_parinfo(ClipMachineMemory, 3) == LOGICAL_type_of_ClipVarType)
AllowGrow = _clip_parl(ClipMachineMemory, 3);
if (_clip_parinfo(ClipMachineMemory, 4) == LOGICAL_type_of_ClipVarType)
AllowShrink = _clip_parl(ClipMachineMemory, 4);
gtk_window_set_policy(GTK_WINDOW(cwin->widget), AllowShrink, AllowGrow, AutoShrink);
return 0;
err:
return 1;
}
/* Set the position of the separator, as if set by the user. If position is
* negative, the remembered position is forgotten, and the division is
* recomputed from the the requisitions of the children. */
int
clip_GTK_PANEDSETPOSITION(ClipMachine * cm)
{
C_widget *cpan = _fetch_cw_arg(cm);
gint position = _clip_parni(cm,2);
CHECKCWID(cpan,GTK_IS_PANED);
CHECKOPT(2,NUMERIC_t);
if (_clip_parinfo(cm,2)==UNDEF_t) position = -1;
gtk_paned_set_position(GTK_PANED(cpan->widget), position);
return 0;
err:
return 1;
}
/* Sets whether or not the connecting lines between branches and children are drawn. */
int
clip_GTK_TREESETVIEWLINES(ClipMachine * cm)
{
C_widget *ctree = _fetch_cw_arg(cm);
gboolean flag = _clip_parl(cm,2);
CHECKCWID(ctree,GTK_IS_TREE); CHECKOPT(2,LOGICAL_t);
gtk_tree_set_view_lines(GTK_TREE(ctree->widget), flag);
return 0;
err:
return 1;
}
/* A GtkProgress can be in one of two different modes: percentage mode (the default)
* and activity mode. In activity mode, the progress is simply indicated as activity
* rather than as a percentage complete. */
int
clip_GTK_PROGRESSSETACTIVITYMODE(ClipMachine * cm)
{
C_widget *cprg = _fetch_cw_arg(cm);
guint activity_mode = _clip_parl(cm,2);
CHECKCWID(cprg,GTK_IS_PROGRESS);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) activity_mode = TRUE;
gtk_progress_set_activity_mode(GTK_PROGRESS(cprg->widget), activity_mode);
return 0;
err:
return 1;
}
/* Sets whether to show the bookmarks or not. */
int
clip_GTK_NOTEBOOKSETSHOWTABS(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gboolean show_tabs = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) show_tabs = TRUE;
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(cntb->widget), show_tabs);
return 0;
err:
return 1;
}
/* Sets whether the bookmarks area may be scrollable or not if there are
* too many bookmarks to fit in the allocated area. */
int
clip_GTK_NOTEBOOKSETSCROLLABLE(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gboolean scrollable = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) scrollable = TRUE;
gtk_notebook_set_scrollable(GTK_NOTEBOOK(cntb->widget), scrollable);
return 0;
err:
return 1;
}
int
clip_GTK_SCROLLEDWINDOWSETSHADOWTYPE (ClipMachine *cm)
{
C_widget *csw = _fetch_cw_arg(cm);
GtkShadowType type = INT_OPTION(cm, 2, 0);
CHECKCWID(csw,GTK_IS_SCROLLED_WINDOW);
CHECKOPT(2,NUMERIC_t);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(csw->widget), type);
return 0;
err:
return 1;
}
/* Sets whether the tabs should have a vertical border. */
int
clip_GTK_NOTEBOOKSETTABVBORDER(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gboolean tab_vborder = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) tab_vborder = TRUE;
gtk_notebook_set_tab_vborder(GTK_NOTEBOOK(cntb->widget), tab_vborder);
return 0;
err:
return 1;
}
/* Sets whether the tabs must have all the same size or not. */
int
clip_GTK_NOTEBOOKSETHOMOGENEOUSTABS(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
guint homogeneous = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) homogeneous = TRUE;
gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(cntb->widget), homogeneous);
return 0;
err:
return 1;
}
int
clip_GTK_TOGGLEACTIONNEW(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm,1);
gchar * name = _clip_parc(cm, 2);
gchar * label = _clip_parc(cm, 3);
gchar * tooltip = _clip_parc(cm, 4);
gchar * stock_id = _clip_parc(cm, 5);
C_object *caction;
GtkToggleAction *action;
CHECKOPT(1,MAP_t);
CHECKARG(2, CHARACTER_t);
CHECKARG(3, CHARACTER_t);
CHECKOPT(4, CHARACTER_t);
CHECKOPT(5, CHARACTER_t);
LOCALE_TO_UTF(name);
LOCALE_TO_UTF(label);
if (tooltip) LOCALE_TO_UTF(tooltip);
if (stock_id) LOCALE_TO_UTF(stock_id);
action = gtk_toggle_action_new(name, label, tooltip, stock_id);
if (action)
{
caction = _list_get_cobject(cm,action);
if (!caction) caction = _register_object(cm,action,GTK_TYPE_TOGGLE_ACTION,cv,NULL);
if (caction) _clip_mclone(cm,RETPTR(cm),&caction->obj);
}
FREE_TEXT(name);
FREE_TEXT(label);
if (tooltip) FREE_TEXT(tooltip);
if (stock_id) FREE_TEXT(stock_id);
return 0;
err:
return 1;
}
/* Returns a map with fields RED, GREEN and BLUE */
int
clip_GDK_COLORRGB(ClipMachine * cm)
{
long RGB = _clip_parnl(cm,1);
CHECKOPT(1,NUMERIC_t);
if (_clip_parinfo(cm,1) != UNDEF_t)
{
ClipVar *ret = RETPTR(cm);
memset(ret, 0, sizeof(*ret)); _clip_map(cm, ret);
_clip_mputn(cm, ret, HASH_RED, (RGB & 0xFF) << 8);
_clip_mputn(cm, ret, HASH_GREEN, ((RGB >> 8) & 0xFF) << 8);
_clip_mputn(cm, ret, HASH_BLUE, ((RGB >> 16) & 0xFF) << 8);
}
/* If window is set modal, input will be grabbed when show and released when hide */
int
clip_GTK_WINDOWSETMODAL(ClipMachine * cm)
{
C_widget *cwin = _fetch_cw_arg(cm);
gboolean modal = _clip_parl(cm,2);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2) == UNDEF_t) modal = TRUE;
CHECKCWID(cwin,GTK_IS_WINDOW);
gtk_window_set_modal(GTK_WINDOW(cwin->widget), modal);
return 0;
err:
return 1;
}
/**** ACCEL LABEL constructor ****/
int
clip_GTK_ACCELLABELNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
char * text = _clip_parc(cm, 2);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
CHECKOPT(2,CHARACTER_t);
LOCALE_TO_UTF(text);
wid = gtk_accel_label_new(text);
FREE_TEXT(text);
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/* Recomputes the entire curve using the given gamma value. A gamma value of 1
* results in a straight line. Values greater than 1 result in a curve above the
* straight line. Values less than 1 result in a curve below the straight line.
* The curve type is changed to GTK_CURVE_TYPE_FREE. */
int
clip_GTK_CURVESETGAMMA(ClipMachine * cm)
{
C_widget *ccur = _fetch_cw_arg(cm);
gfloat gamma = _clip_parnd(cm,2);
CHECKCWID(ccur,GTK_CURVE);
CHECKOPT(2,NUMERIC_t);
if (_clip_parinfo(cm,2)==UNDEF_t) gamma = 1;
gtk_curve_set_gamma(GTK_CURVE(ccur->widget),gamma);
return 0;
err:
return 1;
}
/* Switches to the page number page_num. Negative values stand for the
* last page; too large values are ignored. */
int
clip_GTK_NOTEBOOKSETPAGE(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gint page_num = _clip_parni(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,NUMERIC_t);
if (_clip_parinfo(cm,2)==UNDEF_t) page_num = 1;
gtk_notebook_set_page(GTK_NOTEBOOK(cntb->widget), (page_num>0?page_num-1:page_num));
return 0;
err:
return 1;
}
int
clip_GTK_CTREESETSHOWSTUB (ClipMachine *cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
gboolean show_stub = _clip_parl(cm,2);
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) show_stub = 1;
gtk_ctree_set_show_stub (GTK_CTREE(cctree->widget), show_stub);
return 0;
err:
return 1;
}
int
clip_GTK_COMBOSETPOPDOWNSTRINGS(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
ClipArrVar *astr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2));
GList *str_list = NULL;
gchar *text_utf;
ClipStrVar *s;
int i;
CHECKCWID(ccmb, GTK_IS_COMBO);
CHECKOPT(2, ARRAY_type_of_ClipVarType);
for (i = 0; i < astr->count; i++)
{
if (astr->items[i].t.ClipVartype_type_of_ClipType != CHARACTER_type_of_ClipVarType)
continue;
s = (ClipStrVar *) _clip_vptr(&astr->items[i]);
text_utf = _clip_locale_to_utf8(s->str.buf);
if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
{
str_list = g_list_append(str_list, gtk_list_item_new_with_label(text_utf));
g_free(text_utf);
}
else
str_list = g_list_append(str_list, text_utf);
}
if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)
{
gtk_list_clear_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), 0, -1);
gtk_list_append_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), str_list);
}
else
gtk_combo_set_popdown_strings(GTK_COMBO(ccmb->widget), str_list);
/*
while (str_list)
{
g_free(str_list->data);
str_list = g_list_next(str_list);
}
*/
return 0;
err:
return 1;
}
/* Draws a number of characters in the given font or fontset. */
int
clip_GDK_DRAWTEXT(ClipMachine * ClipMachineMemory)
{
C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);
C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
C_object *font = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));
gint x = _clip_parni(ClipMachineMemory, 4);
gint y = _clip_parni(ClipMachineMemory, 5);
gchar *text = _clip_parc(ClipMachineMemory, 6);
gint length = _clip_parni(ClipMachineMemory, 7);
GdkDrawable *drw = NULL;
CHECKCWID(cwid, GTK_IS_WIDGET);
CHECKOPT2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKCOBJ(cgc, GDK_IS_GC(cgc));
CHECKOPT2(3, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKCOBJ(cgc, GDK_IS_FONT(font));
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
CHECKOPT(5, NUMERIC_type_of_ClipVarType);
CHECKOPT(6, CHARACTER_type_of_ClipVarType);
CHECKOPT(7, NUMERIC_type_of_ClipVarType);
drw = cwid->widget->window;
if (GTK_IS_PIXMAP(cwid->widget))
drw = GTK_PIXMAP(cwid->widget)->pixmap;
LOCALE_TO_UTF(text);
gdk_draw_text(drw, GDK_FONT(font->object), GDK_GC(cgc->object), x, y, text, length);
FREE_TEXT(text);
return 0;
err:
return 1;
}
/* Determines the location of the child widget with respect to the scrollbars.
* The default is GTK_CORNER_TOP_LEFT, meaning the child is in the top left,
* with the scrollbars underneath and to the right. Other values in GtkCornerType are
* GTK_CORNER_TOP_RIGHT, GTK_CORNER_BOTTOM_LEFT, and GTK_CORNER_BOTTOM_RIGHT. */
int
clip_GTK_SCROLLEDWINDOWSETPLACEMENT(ClipMachine * ClipMachineMemory)
{
C_widget *csw = _fetch_cw_arg(ClipMachineMemory);
int placement = _clip_parni(ClipMachineMemory, 2);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKCWID(csw, GTK_IS_SCROLLED_WINDOW);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(csw->widget), placement);
return 0;
err:
return 1;
}
/* Sets whether there should be a border around the bookmarks or not. */
int
clip_GTK_NOTEBOOKSETTABBORDER(ClipMachine * ClipMachineMemory)
{
C_widget *cntb = _fetch_cw_arg(ClipMachineMemory);
guint border_width = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(cntb, GTK_IS_NOTEBOOK);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_notebook_set_tab_border(GTK_NOTEBOOK(cntb->widget), border_width);
return 0;
err:
return 1;
}
int
clip_GTK_CALENDARUNMARKDAY(ClipMachine * ClipMachineMemory)
{
C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);
guint day = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(ccal, GTK_IS_CALENDAR);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_calendar_unmark_day(GTK_CALENDAR(ccal->widget), day);
return 0;
err:
return 1;
}
/* Set where the text within the GtkLabel will align to. This can be one of four
* values: GTK_JUSTIFY_LEFT, GTK_JUSTIFY_RIGHT, GTK_JUSTIFY_CENTER, and
* GTK_JUSTIFY_FILL. GTK_JUSTIFY_CENTER is the default value when the widget is
* first created with gtk_label_new(). */
int
clip_GTK_LABELSETJUSTIFY(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
GtkJustification jtype = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(clbl, GTK_IS_LABEL);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_label_set_justify(GTK_LABEL(clbl->widget), jtype);
return 0;
err:
return 1;
}
int
clip_GTK_MENUSHELLACTIVATETITEM(ClipMachine * cm)
{
C_widget *cmns = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
gboolean force_deactivate = _clip_parl(cm,3);
CHECKCWID(cmns,GTK_IS_MENU_SHELL);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT(3,LOGICAL_t);
gtk_menu_shell_activate_item(GTK_MENU_SHELL(cmns->widget), cwid->widget, force_deactivate);
return 0;
err:
return 1;
}
int
clip_GTK_MENUSHELLINSERT(ClipMachine * cm)
{
C_widget *cmns = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
int position = _clip_parni(cm,3);
CHECKCWID(cmns,GTK_IS_MENU_SHELL);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT(3,NUMERIC_t);
gtk_menu_shell_insert(GTK_MENU_SHELL(cmns->widget), cwid->widget, position);
return 0;
err:
return 1;
}
/* The pattern of underlines you want under the existing text within the GtkLabel
* widget. For example if the current text of the label says "FooBarBaz" passing
* a pattern of "___ ___" will underline "Foo" and "Baz" but not "Bar". */
int
clip_GTK_LABELSETPATTERN(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
char *pattern = _clip_parc(ClipMachineMemory, 2);
CHECKCWID(clbl, GTK_IS_LABEL);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
gtk_label_set_pattern(GTK_LABEL(clbl->widget), pattern);
return 0;
err:
return 1;
}
/* This function is unimplemented because tooltip colors are
* instead determined by the theme. */
int
clip_GTK_TOOLTIPSSETCOLORS(ClipMachine * ClipMachineMemory)
{
C_widget *ctt = _fetch_cw_arg(ClipMachineMemory);
ClipVar *mback = _clip_spar(ClipMachineMemory, 2);
ClipVar *mfore = _clip_spar(ClipMachineMemory, 3);
GdkColor back, fore, *pback = NULL, *pfore = NULL;
CHECKCWID(ctt, GTK_IS_TOOLTIPS);
CHECKOPT(2, MAP_type_of_ClipVarType);
CHECKOPT(3, MAP_type_of_ClipVarType);
if (mback && mback->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == MAP_type_of_ClipVarType)
_map_colors_to_gdk(ClipMachineMemory, mback, pback = &back);
if (mfore && mfore->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == MAP_type_of_ClipVarType)
_map_colors_to_gdk(ClipMachineMemory, mfore, pfore = &fore);
gtk_tooltips_set_colors(GTK_TOOLTIPS(ctt->widget), pback, pfore);
return 0;
err:
return 1;
}
/* Toggles line wrapping within the GtkLabel widget. TRUE makes it break lines
* if text exceeds the widget's size. FALSE lets the text get cut off by the
* edge of the widget if it exceeds the widget size. */
int
clip_GTK_LABELSETLINEWRAP(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
gboolean wrap = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(clbl, GTK_IS_LABEL);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
gtk_label_set_line_wrap(GTK_LABEL(clbl->widget), wrap);
return 0;
err:
return 1;
}
/* Sets the time between the user moving the mouse over a widget and
* the widget's tooltip appearing. */
int
clip_GTK_TOOLTIPSSETDELAY(ClipMachine * ClipMachineMemory)
{
C_widget *ctt = _fetch_cw_arg(ClipMachineMemory);
guint delay = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(ctt, GTK_IS_TOOLTIPS);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_tooltips_set_delay(GTK_TOOLTIPS(ctt->widget), delay);
return 0;
err:
return 1;
}
