/**** 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; }