/**** TOGGLE COMBO constructors ****/
int
clip_GTK_TOGGLECOMBONEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
gint nrows = INT_OPTION(ClipMachineMemory, 2, 1);
gint ncols = INT_OPTION(ClipMachineMemory, 3, 1);
GtkWidget *wid = NULL;
C_widget *cwid, *cbutton, *ctable;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
wid = gtk_toggle_combo_new(nrows, ncols);
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
cbutton = _register_widget(ClipMachineMemory, GTK_COMBO_BOX(wid)->button, NULL);
ctable = _register_widget(ClipMachineMemory, GTK_TOGGLE_COMBO(wid)->table, NULL);
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_BUTTON, &cbutton->obj);
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_TABLE, &ctable->obj);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
/* Removes the items at positions between start and end from the GtkTree tree.
* Removing an item from a GtkTree dereferences the item, and thus usually
* destroys the item and any subtrees it may contain. If the item is not
* to be destroyed, use gtk_object_ref() before removing it. */
int
clip_GTK_TREECLEARITEMS(ClipMachine * cm)
{
C_widget *ctree = _fetch_cw_arg(cm);
gint start = INT_OPTION(cm,2,1)-1;
gint end = INT_OPTION(cm,3,1)-1;
CHECKCWID(ctree,GTK_IS_TREE);
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
gtk_tree_clear_items(GTK_TREE(ctree->widget), start, end);
return 0;
err:
return 1;
}
/* This function would immediately render the region area of a widget,
* by invoking the virtual draw method of a widget. */
int
clip_GTK_WIDGETDRAW(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
GdkRectangle area;
CHECKCWID(cwid,GTK_IS_WIDGET);
area.x = INT_OPTION(cm,2,cwid->widget->allocation.x);
area.y = INT_OPTION(cm,3,cwid->widget->allocation.y);
area.width = INT_OPTION(cm,4,cwid->widget->allocation.width);
area.height = INT_OPTION(cm,5,cwid->widget->allocation.height);
gtk_widget_draw(cwid->widget, &area);
return 0;
err:
return 1;
}
/**** WINDOW constructor ****/
int
clip_GTK_WINDOWNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
char * title = _clip_parc(cm, 2);
gint typ = INT_OPTION(cm, 3, 0);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
CHECKOPT(2,CHARACTER_t);
CHECKOPT(3,NUMERIC_t);
//wid = gtk_window_new(GTK_WINDOW_TOPLEVEL);
wid = gtk_window_new(typ);
if (!wid) goto err;
if (_clip_parinfo(cm,2)==CHARACTER_t)
{
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(cm, 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(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
int
clip_GTK_COLORSELECTIONPALETTETOSTRING(ClipMachine * ClipMachineMemory)
{
ClipVar *cvcolor = _clip_spar(ClipMachineMemory, 1);
gint len = INT_OPTION(ClipMachineMemory, 2, 0);
gchar *palette = 0;
CHECKARG(1, ARRAY_type_of_ClipVarType);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
if (len > 0)
{
GdkColor color[len];
gint i;
for (i = 0; i < len; i++)
{
_map_to_gdk_color(ClipMachineMemory, &color[i], &cvcolor->ClipArrVar_a_of_ClipVar.ClipVar_items_of_ClipArrVar[i]);
}
palette = gtk_color_selection_palette_to_string(color, len);
}
_clip_retc(ClipMachineMemory, palette);
return 0;
err:
return 1;
}
/**** SPIN BUTTON constructor ****/
int
clip_GTK_SPINBUTTONNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gfloat climb_rate = DBL_OPTION(ClipMachineMemory, 3, 1);
guint digits = INT_OPTION(ClipMachineMemory, 4, 1);
GtkWidget *wid = NULL;
GtkAdjustment *adj;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
adj = cadj ? GTK_ADJUSTMENT(cadj->widget) : NULL;
wid = gtk_spin_button_new(adj, climb_rate, digits);
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
int
clip_GTK_SPINBUTTONCONFIGURE(ClipMachine * ClipMachineMemory)
{
C_widget *cspb = _fetch_cw_arg(ClipMachineMemory);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gfloat climb_rate = DBL_OPTION(ClipMachineMemory, 3, 1);
guint digits = INT_OPTION(ClipMachineMemory, 4, 1);
GtkAdjustment *adj;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(cspb, GTK_IS_SPIN_BUTTON);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
adj = cadj ? GTK_ADJUSTMENT(cadj->widget) : NULL;
gtk_spin_button_configure(GTK_SPIN_BUTTON(cspb->widget), adj, climb_rate, digits);
return 0;
err:
return 1;
}
/******************************************************************************
* gtk_ItemFactoryNew( container_type, spath, accel_group ) --> ItemFactoryNewObject
* container_type is one of :GTK_TYPE_MENU_BAR, GTK_TYPE_MENU or GTK_TYPE_OPTION_MENU
******************************************************************************/
int
clip_GTK_ITEMFACTORYNEW(ClipMachine * cm)
{
gint itype = INT_OPTION(cm, 1, CLIP_GTK_TYPE_MENU_BAR);
const gchar *path = _clip_parc(cm, 2);
C_object *caccel = _fetch_cobject(cm, _clip_spar(cm, 3));
C_object *citem ;
GtkItemFactory *item ;
GtkType type = 0;
CHECKARG(1, NUMERIC_t);
CHECKARG(2, CHARACTER_t);
CHECKOPT(3, MAP_t); CHECKCOBJOPT(caccel, GTK_IS_ACCEL_GROUP(caccel->object));
switch (itype)
{
case CLIP_GTK_TYPE_MENU_BAR: type = GTK_TYPE_MENU_BAR; break;
case CLIP_GTK_TYPE_MENU: type = GTK_TYPE_MENU; break;
case CLIP_GTK_TYPE_OPTION_MENU: type = GTK_TYPE_OPTION_MENU; break;
}
item = gtk_item_factory_new(type, path, GTK_ACCEL_GROUP(caccel->object));
if (item)
{
citem = _list_get_cobject(cm,item);
if (!citem) citem = _register_object(cm,item,GTK_TYPE_ITEM_FACTORY,NULL,NULL);
if (citem) _clip_mclone(cm,RETPTR(cm),&citem->obj);
}
return 0;
err:
return 1;
}
/* Returns TRUE if the given key value is in upper case. */
int
clip_GDK_KEYVALISUPPER(ClipMachine * ClipMachineMemory)
{
guint keyval = INT_OPTION(ClipMachineMemory, 1, 0);
_clip_retl(ClipMachineMemory, gdk_keyval_is_upper(keyval));
return 0;
}
/* Converts a key value to lower case, if applicable. */
int
clip_GDK_KEYVALTOLOWER(ClipMachine * ClipMachineMemory)
{
guint keyval = INT_OPTION(ClipMachineMemory, 1, 0);
_clip_retl(ClipMachineMemory, gdk_keyval_to_lower(keyval));
return 0;
}
/* Converts a key value into a symbolic name. The names are the same as those
in the <clip-gdk.ch> header file but without the leading "GDK_". */
int
clip_GDK_KEYVALNAME(ClipMachine * ClipMachineMemory)
{
guint keyval = INT_OPTION(ClipMachineMemory, 1, 0);
_clip_retc(ClipMachineMemory, gdk_keyval_name(keyval));
return 0;
}
int
clip_GTK_TOGGLECOMBOSELECT(ClipMachine * ClipMachineMemory)
{
C_widget *ctgc = _fetch_cw_arg(ClipMachineMemory);
gint row = INT_OPTION(ClipMachineMemory, 2, 1);
gint col = INT_OPTION(ClipMachineMemory, 3, 1);
CHECKCWID(ctgc, GTK_IS_TOGGLE_COMBO);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
gtk_toggle_combo_select(GTK_TOGGLE_COMBO(ctgc->widget), row - 1, col - 1);
return 0;
err:
return 1;
}
/* Removes the items between index start (included) and end (excluded)
* from the list. If end is negative, or greater than the number of
* children of list, it's assumed to be exactly the number of elements.
* If start is greater than or equal to end, nothing is done. */
int
clip_GTK_LISTCLEARITEMS(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
gint start = INT_OPTION(ClipMachineMemory, 2, 1);
gint end = INT_OPTION(ClipMachineMemory, 3, 1);
CHECKCWID(clst, GTK_IS_LIST);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
gtk_list_clear_items(GTK_LIST(clst->widget), start - 1, end - 1);
return 0;
err:
return 1;
}
int
clip_GDK_WINDOWSETHINTS(ClipMachine * cm)
{
C_widget *cwin = _fetch_cw_arg(cm);
gint x = INT_OPTION(cm,2,-1);
gint y = INT_OPTION(cm,3,-1);
gint min_width = INT_OPTION(cm,4,-1);
gint min_height = INT_OPTION(cm,5,-1);
gint max_width = INT_OPTION(cm,6,-1);
gint max_height = INT_OPTION(cm,7,-1);
gint flags = INT_OPTION(cm,8,0);
GdkWindow *win = NULL;
CHECKCWID(cwin,GTK_IS_WIDGET); CHECKOPT(2,NUMERIC_t);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,NUMERIC_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT(6,NUMERIC_t); CHECKOPT(7,NUMERIC_t); CHECKOPT(8,NUMERIC_t);
CHECKCWID(cwin,GTK_IS_WIDGET);
if (cwin && cwin->widget) win = cwin->widget->window;
gdk_window_set_hints(win,x,y,min_width,min_height,max_width,max_height,flags);
return 0;
err:
return 1;
}
/* As there are many options associated with gtk_table_attach(), this
* convenience function provides the programmer with a means to add
* children to a table with identical padding and expansion options. */
int
clip_GTK_TABLEATTACHDEFAULTS(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
guint left_attach = INT_OPTION(cm,3,1);
guint right_attach = INT_OPTION(cm,4,1);
guint top_attach = INT_OPTION(cm,5,1);
guint bottom_attach = INT_OPTION(cm,6,1);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,NUMERIC_t);
CHECKOPT(5,NUMERIC_t); CHECKOPT(6,NUMERIC_t);
gtk_table_attach_defaults(GTK_TABLE(ctbl->widget), cwid->widget,
left_attach-1, right_attach-1, top_attach-1, bottom_attach-1);
return 0;
err:
return 1;
}
int
clip_GTK_ITEMENTRYSETJUSTIFICATION(ClipMachine * cm)
{
C_widget *cite = _fetch_cw_arg(cm);
GtkJustification justification = INT_OPTION(cm,2,GTK_JUSTIFY_LEFT);
CHECKCWID(cite,GTK_IS_ITEM_ENTRY);
CHECKOPT(2,NUMERIC_t);
gtk_item_entry_set_justification(GTK_ITEM_ENTRY(cite->widget),justification);
return 0;
err:
return 1;
}
/* alters the amount of space between a given table column and the adjacent columns. */
int
clip_GTK_TABLESETCOLSPACING(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
guint col = INT_OPTION(cm,2,1);
guint spacing = _clip_parni(cm,3);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
gtk_table_set_col_spacing(GTK_TABLE(ctbl->widget), col-1, spacing);
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;
}
int
clip_GTK_ITEMENTRYSETTEXT(ClipMachine * cm)
{
C_widget *cite = _fetch_cw_arg(cm);
const gchar *text = CHAR_OPTION(cm,2,"");
GtkJustification justification = INT_OPTION(cm,3,GTK_JUSTIFY_LEFT);
CHECKCWID(cite,GTK_IS_ITEM_ENTRY);
CHECKOPT(2,CHARACTER_t); CHECKOPT(3,NUMERIC_t);
gtk_item_entry_set_text(GTK_ITEM_ENTRY(cite->widget),text,justification);
return 0;
err:
return 1;
}
/* Emits the unselect_item for the child at position item, and thus unselects it. */
int
clip_GTK_TREEUNSELECTITEM(ClipMachine * cm)
{
C_widget *ctree = _fetch_cw_arg(cm);
gint item = INT_OPTION(cm,2,1)-1;
CHECKCWID(ctree,GTK_IS_TREE);
CHECKOPT(2,NUMERIC_t);
gtk_tree_unselect_item(GTK_TREE(ctree->widget), item);
return 0;
err:
return 1;
}
/* Unselects the child number item of the list. Nothing happens if item
* is out of bounds. The signal GtkList::unselect-child will be emitted. */
int
clip_GTK_LISTUNSELECTITEM(ClipMachine * ClipMachineMemory)
{
C_widget *clst = _fetch_cw_arg(ClipMachineMemory);
gint item = INT_OPTION(ClipMachineMemory, 2, 1);
CHECKCWID(clst, GTK_IS_LIST);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_list_unselect_item(GTK_LIST(clst->widget), item - 1);
return 0;
err:
return 1;
}
/* Emits the select_item signal for the child at position item, and thus
* selects it (unless it is unselected in a signal handler). */
int
clip_GTK_TREESELECTITEM(ClipMachine * ClipMachineMemory)
{
C_widget *ctree = _fetch_cw_arg(ClipMachineMemory);
gint item = INT_OPTION(ClipMachineMemory, 2, 1) - 1;
CHECKCWID(ctree, GTK_IS_TREE);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_tree_select_item(GTK_TREE(ctree->widget), item);
return 0;
err:
return 1;
}
/* Adds a widget to a table. The number of 'cells' that a widget
* will occupy is specified by left_attach, right_attach, top_attach
* and bottom_attach. These each represent the leftmost, rightmost,
* uppermost and lowest column and row numbers of the table.
* (Columns and rows are indexed from 1). */
int
clip_GTK_TABLEATTACH(ClipMachine *cm)
{
C_widget *ctbl = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
guint left_attach = INT_OPTION(cm,3,1);
guint right_attach = INT_OPTION(cm,4,1);
guint top_attach = INT_OPTION(cm,5,1);
guint bottom_attach = INT_OPTION(cm,6,1);
GtkAttachOptions xoptions = _clip_parni(cm,7);
GtkAttachOptions yoptions = _clip_parni(cm,8);
guint xpadding = _clip_parni(cm,9);
guint ypadding = _clip_parni(cm,10);
CHECKCWID(ctbl,GTK_IS_TABLE);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,NUMERIC_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT(6,NUMERIC_t); CHECKOPT(7,NUMERIC_t); CHECKOPT(8,NUMERIC_t);
CHECKOPT(9,NUMERIC_t); CHECKOPT(10,NUMERIC_t);
gtk_table_attach(GTK_TABLE(ctbl->widget), cwid->widget, left_attach-1, right_attach-1,
top_attach-1, bottom_attach-1, xoptions,yoptions, xpadding,ypadding);
return 0;
err:
return 1;
}
/* Adds the GtkTreeItem in tree_item to the list of items in tree
* at the position indicated by position. */
int
clip_GTK_TREEINSERT(ClipMachine * cm)
{
C_widget *ctree = _fetch_cw_arg(cm);
C_widget *citem = _fetch_cwidget(cm,_clip_spar(cm,2));
gint position = INT_OPTION(cm,3,1)-1;
CHECKCWID(ctree,GTK_IS_TREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCWID(citem,GTK_TREE_ITEM);
CHECKOPT(3,NUMERIC_t);
gtk_tree_insert(GTK_TREE(ctree->widget), citem->widget, position);
return 0;
err:
return 1;
}
int
clip_GTK_FONTCOMBOSELECTNTH(ClipMachine * cm)
{
C_widget *cfnc = _fetch_cw_arg(cm);
gint n = INT_OPTION(cm,2,1);
gboolean bold = BOOL_OPTION(cm,3,FALSE);
gboolean italic = BOOL_OPTION(cm,4,FALSE);
gint height = _clip_parni(cm,5);
CHECKCWID(cfnc,GTK_IS_FONT_COMBO);
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,LOGICAL_t); CHECKOPT(4,LOGICAL_t);
CHECKOPT(5,NUMERIC_t);
gtk_font_combo_select_nth(GTK_FONT_COMBO(cfnc->widget),n,bold,italic,height);
return 0;
err:
return 1;
}
/* Registers a function to be called when an instance of the mainloop is left. */
int
clip_GTK_QUITADD(ClipMachine * cm)
{
guint main_level = INT_OPTION(cm,1,gtk_main_level());
C_var *c;
CHECKOPT(1,NUMERIC_t); CHECKARG2(2,PCODE_t,CCODE_t);
c = NEW(C_var);
c->cm = cm; //c->cfunc = NEW(ClipVar);
_clip_mclone(cm,&c->cfunc, _clip_spar(cm,2));
_clip_retni(cm,gtk_quit_add_full(main_level,(GtkFunction)__func,NULL,c,
_destroy__func));
return 0;
err:
return 1;
}
/* Sets various attributes of how lines are drawn. See the corresponding
* members of GdkGCValues for full explanations of the arguments. */
int
clip_GDK_GCSETLINEATTRIBUTES(ClipMachine * cm)
{
C_object *cgc = _fetch_co_arg(cm);
gint line_width = INT_OPTION (cm, 2, 0);
GdkLineStyle line_style = _clip_parni (cm, 3);
GdkCapStyle cap_style = _clip_parni (cm, 4);
GdkJoinStyle join_style = _clip_parni (cm, 5);
CHECKCOBJ(cgc,GDK_IS_GC(cgc));
CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
CHECKOPT(4,NUMERIC_t); CHECKOPT(5,NUMERIC_t);
gdk_gc_set_line_attributes(GDK_GC(cgc->object),
line_width, line_style, cap_style, join_style);
return 0;
err:
return 1;
}
/* Adds the GtkTreeItem in tree_item to the list of items in tree
* at the position indicated by position. */
int
clip_GTK_TREEINSERT(ClipMachine * ClipMachineMemory)
{
C_widget *ctree = _fetch_cw_arg(ClipMachineMemory);
C_widget *citem = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gint position = INT_OPTION(ClipMachineMemory, 3, 1) - 1;
CHECKCWID(ctree, GTK_IS_TREE);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWID(citem, GTK_TREE_ITEM);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
gtk_tree_insert(GTK_TREE(ctree->widget), citem->widget, position);
return 0;
err:
return 1;
}
/* Causes the mainloop to call the given function whenever no events
* with higher priority are to be processed. The default priority is
* GTK_PRIORITY_DEFAULT, which is rather low. */
int
clip_GTK_IDLEADD(ClipMachine * cm)
{
gint priority = INT_OPTION(cm,1,G_PRIORITY_DEFAULT_IDLE);
C_var *c;
CHECKOPT(1,NUMERIC_t); CHECKARG2(2,PCODE_t,CCODE_t);
if (priority > G_PRIORITY_HIGH) priority = G_PRIORITY_HIGH;
c = NEW(C_var);
c->cm = cm; //c->cfunc = NEW(ClipVar);
_clip_mclone(cm,&c->cfunc, _clip_spar(cm,2));
_clip_retni(cm,gtk_idle_add_full(priority,(GtkFunction)__func,NULL,
c,_destroy__func));
return 0;
err:
return 1;
}
/******************************************************************************
* gtk_ItemFactoryConstruct( itemFactory, container_type, spath, accel_group ) --> NIL
* container_type is one of :GTK_TYPE_MENU_BAR, GTK_TYPE_MENU or GTK_TYPE_OPTION_MENU
******************************************************************************/
int
clip_GTK_ITEMFACTORYCONSTRUCT(ClipMachine * cm)
{
C_object *citem = _fetch_co_arg(cm);
GtkType type = INT_OPTION(cm, 2, GTK_TYPE_MENU_BAR);
const gchar *path = _clip_parc(cm, 3);
C_object *caccel = _fetch_cobject(cm, _clip_spar(cm, 4));
CHECKARG(1, MAP_t); CHECKCOBJ(citem, GTK_IS_ITEM_FACTORY(citem->object));
CHECKARG(2, NUMERIC_t);
CHECKARG(3, CHARACTER_t);
CHECKOPT(4, MAP_t); CHECKCOBJOPT(caccel, GTK_IS_ACCEL_GROUP(caccel->object));
gtk_item_factory_construct(GTK_ITEM_FACTORY(citem->object), type,
path, GTK_ACCEL_GROUP(caccel->object));
return 0;
err:
return 1;
}
