/**** Viewport constructor ****/
int
clip_GTK_VIEWPORTNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget * chadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
C_widget * cvadj = _fetch_cwidget(cm,_clip_spar(cm, 3));
GtkWidget *wid = NULL;
C_widget *cwid;
GtkAdjustment *hadj, *vadj;
CHECKOPT(1,MAP_t);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKCWIDOPT(chadj,GTK_IS_ADJUSTMENT);
CHECKOPT2(3,MAP_t,NUMERIC_t);
CHECKCWIDOPT(cvadj,GTK_IS_ADJUSTMENT);
hadj = chadj ? GTK_ADJUSTMENT(chadj->widget) : NULL;
vadj = cvadj ? GTK_ADJUSTMENT(cvadj->widget) : NULL;
wid = gtk_viewport_new(hadj,vadj);
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
int
clip_GTK_EXTEXTSETADJUSTMENTS(ClipMachine * cm)
{
C_widget *extext = _fetch_cw_arg(cm);
C_widget *chadj = _fetch_cwidget(cm, _clip_spar(cm, 2));
C_widget *cvadj = _fetch_cwidget(cm, _clip_spar(cm, 3));
GtkAdjustment *hadj, *vadj;
CHECKCWID(extext, GTK_IS_EXTEXT);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(chadj, GTK_IS_ADJUSTMENT);
CHECKOPT2(3, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cvadj, GTK_IS_ADJUSTMENT);
hadj = chadj ? GTK_ADJUSTMENT(chadj->widget) : NULL;
vadj = cvadj ? GTK_ADJUSTMENT(cvadj->widget) : NULL;
gtk_extext_set_adjustments(GTK_EXTEXT(extext->widget), hadj, vadj);
return 0;
err:
return 1;
}
/* Set the pixmap in a node. */
int
clip_GTK_CTREENODESETPIXTEXT(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
gint column = _clip_parni(cm,3);
gchar *text = _clip_parc(cm,4);
gint spacing = _clip_parni(cm,5);
C_widget *cpixmap = _fetch_cwidget(cm,_clip_spar(cm,6));
GdkPixmap *pixmap=NULL; GdkBitmap *mask=NULL;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,CHARACTER_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cpixmap,GTK_IS_PIXMAP);
if (_clip_parinfo(cm,3)==UNDEF_t) column = 1;
if (_clip_parinfo(cm,4)==UNDEF_t) text = "";
if (cpixmap)
{
pixmap = GTK_PIXMAP(cpixmap->widget)->pixmap;
mask = GTK_PIXMAP(cpixmap->widget)->mask;
}
LOCALE_TO_UTF(text);
gtk_ctree_node_set_pixtext(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object), column-1,
text,spacing,pixmap,mask);
FREE_TEXT(text);
return 0;
err:
return 1;
}
/**** SCROLLED WINDOW constructor ****/
int
clip_GTK_SCROLLEDWINDOWNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget * chadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
C_widget * cvadj = _fetch_cwidget(cm,_clip_spar(cm, 3));
GtkWidget *wid = NULL;
C_widget *cwid;
C_widget *chscr, *cvscr;
GtkAdjustment *hadj, *vadj;
CHECKOPT(1,MAP_t);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKCWIDOPT(chadj,GTK_IS_ADJUSTMENT);
CHECKOPT2(3,MAP_t,NUMERIC_t);
CHECKCWIDOPT(cvadj,GTK_IS_ADJUSTMENT);
hadj = chadj ? GTK_ADJUSTMENT(chadj->widget) : NULL;
vadj = cvadj ? GTK_ADJUSTMENT(cvadj->widget) : NULL;
wid = gtk_scrolled_window_new(hadj,vadj);
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
chscr = _register_widget(cm, GTK_SCROLLED_WINDOW(wid)->hscrollbar, NULL);
cvscr = _register_widget(cm, GTK_SCROLLED_WINDOW(wid)->vscrollbar, NULL);
if (chscr) _clip_madd(cm,&cwid->obj,HASH_HSCROLLBAR,&chscr->obj);
if (cvscr) _clip_madd(cm,&cwid->obj,HASH_VSCROLLBAR,&cvscr->obj);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/* Sets vertical and horizontal adjustments */
int
clip_GTK_WIDGETSETSCROLLADJUSTMENTS(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
C_widget *chadj = _fetch_cwidget(cm, _clip_spar(cm,2));
C_widget *cvadj = _fetch_cwidget(cm, _clip_spar(cm,3));
CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT2(2,NUMERIC_t,MAP_t); CHECKCWIDOPT(chadj,GTK_IS_ADJUSTMENT);
CHECKOPT2(3,NUMERIC_t,MAP_t); CHECKCWIDOPT(cvadj,GTK_IS_ADJUSTMENT);
_clip_retl(cm, gtk_widget_set_scroll_adjustments(cwid->widget,
GTK_ADJUSTMENT(chadj->widget),GTK_ADJUSTMENT(cvadj->widget)));
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONGETSELECTED(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
C_object *cmodel = _fetch_cobject(cm, _clip_par(cm, 2));
ClipVar *cviter = _clip_par(cm, 3);
C_object *citer;
GtkTreeModel *model;
gboolean ret;
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
memset(Iter, 0, sizeof(Iter));
if (cmodel)
{
model = GTK_TREE_MODEL(cmodel->object);
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
&model, Iter);
}
else
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
NULL, Iter);
if (ret && Iter)
{
citer = _list_get_cobject(cm,Iter);
if (!citer) citer = _register_object(cm,Iter,GTK_TYPE_TREE_ITER, cviter, NULL);
if (citer) _clip_mclone(cm, cviter,&citer->obj);
}
_clip_retl(cm, ret);
return 0;
err:
return 1;
}
int
clip_GTK_EXTEXTSETPOPUPMENU(ClipMachine * cm)
{
C_widget *extext = _fetch_cw_arg(cm);
C_widget *widget = _fetch_cwidget(cm, _clip_spar(cm, 2));
C_widget *marginmenu = _fetch_cwidget(cm, _clip_spar(cm, 3));
CHECKCWID(extext, GTK_IS_EXTEXT);
CHECKOPT2(2, MAP_t, NUMERIC_t); CHECKCWID(widget, GTK_IS_WIDGET);
CHECKOPT2(3, MAP_t, NUMERIC_t); CHECKCWID(marginmenu, GTK_IS_WIDGET);
gtk_extext_set_popup_menu(GTK_EXTEXT(extext->widget), GTK_WIDGET(widget->widget), GTK_WIDGET(marginmenu->widget));
return 0;
err:
return 1;
}
int
clip_GTK_IMAGEMENUITEMNEWFROMSTOCK(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm, 1);
gchar *stock_id = _clip_parc(cm, 2);
C_widget *accelgr = _fetch_cwidget(cm, _clip_spar(cm, 3));
C_widget *cimage ;
GtkWidget *image ;
CHECKOPT(1,MAP_t);
CHECKARG(2, CHARACTER_t);
CHECKOPT2(3, MAP_t, NUMERIC_t); CHECKCWIDOPT(accelgr, GTK_IS_ACCEL_GROUP);
image = gtk_image_menu_item_new_from_stock(stock_id,
(accelgr != NULL)?GTK_ACCEL_GROUP(accelgr->widget):NULL);
if (image)
{
cimage = _list_get_cwidget(cm, image);
if (!cimage) cimage = _register_widget(cm, image, cv);
if (cimage) _clip_mclone(cm, RETPTR(cm), &cimage->obj);
}
return 0;
err:
return 1;
}
/* Draws a line, using the foreground color and other attributes of the GdkGC. */
int
clip_GDK_DRAWLINE(ClipMachine * ClipMachineMemory)
{
C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);
C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gint x1 = _clip_parni(ClipMachineMemory, 3);
gint y1 = _clip_parni(ClipMachineMemory, 4);
gint x2 = _clip_parni(ClipMachineMemory, 5);
gint y2 = _clip_parni(ClipMachineMemory, 6);
GdkDrawable *drw = NULL;
CHECKCWID(cwid, GTK_IS_WIDGET);
CHECKOPT2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKCOBJ(cgc, GDK_IS_GC(cgc));
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
CHECKOPT(5, NUMERIC_type_of_ClipVarType);
CHECKOPT(6, NUMERIC_type_of_ClipVarType);
drw = cwid->widget->window;
if (GTK_IS_PIXMAP(cwid->widget))
drw = GTK_PIXMAP(cwid->widget)->pixmap;
gdk_draw_line(drw, GDK_GC(cgc->object), x1, y1, x2, y2);
return 0;
err:
return 1;
}
/* Note: A rectangle drawn filled is 1 pixel smaller in both dimensions
* than a rectangle outlined. Calling gdk_draw_rectangle (window, gc, TRUE, 0, 0, 20, 20)
* results in a filled rectangle 20 pixels wide and 20 pixels high. Calling
* gdk_draw_rectangle (window, gc, FALSE, 0, 0, 20, 20) results in an outlined
* rectangle with corners at (0, 0), (0, 20), (20, 20), and (20, 0), which makes
* it 21 pixels wide and 21 pixels high. */
int
clip_GDK_DRAWRECTANGLE(ClipMachine * ClipMachineMemory)
{
C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);
C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gint filled = BOOL_OPTION(ClipMachineMemory, 3, TRUE);
gint x = _clip_parni(ClipMachineMemory, 4);
gint y = _clip_parni(ClipMachineMemory, 5);
gint width = _clip_parni(ClipMachineMemory, 6);
gint height = _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));
CHECKOPT(3, LOGICAL_type_of_ClipVarType);
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
CHECKOPT(5, NUMERIC_type_of_ClipVarType);
CHECKOPT(6, NUMERIC_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;
gdk_draw_rectangle(drw, GDK_GC(cgc->object), filled, x, y, width, height);
return 0;
err:
return 1;
}
int
clip_GTK_ACCELGROUPCONNECT(ClipMachine * ClipMachineMemory)
{
C_widget *caccelg = _fetch_cw_arg(ClipMachineMemory);
guint accel_key = _clip_parni(ClipMachineMemory, 2);
GdkModifierType accel_mods = _clip_parni(ClipMachineMemory, 3);
GtkAccelFlags accel_flags = _clip_parni(ClipMachineMemory, 4);
C_object *cclosure = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 5));
GClosure *closure;
CHECKCWID(caccelg, GTK_IS_ACCEL_GROUP);
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_type_of_ClipVarType);
CHECKOPT(4, NUMERIC_type_of_ClipVarType);
closure = (GClosure *) (cclosure->object);
gtk_accel_group_connect(GTK_ACCEL_GROUP(caccelg->widget), accel_key, accel_mods, accel_flags, closure);
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;
}
int
clip_GTK_CTREENODEGETPIXMAP(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
gint column = _clip_parni(cm,3);
GdkPixmap *pixmap;
GdkBitmap *mask;
C_widget *cpixmap;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT(3,NUMERIC_t);
if (_clip_parinfo(cm,3)==UNDEF_t) column = 1;
if (gtk_ctree_node_get_pixmap(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object),column-1,&pixmap,&mask))
{
if (pixmap)
{
cpixmap = _list_get_cwidget_by_data(cm,pixmap);
if (!cpixmap) cpixmap = _register_widget(cm,gtk_pixmap_new(pixmap,mask),NULL);
if (cpixmap) _clip_mclone(cm,RETPTR(cm),&cpixmap->obj);
}
}
return 0;
err:
return 1;
}
int
clip_SX_CHILL(ClipMachine * ClipMachineMemory)
{
const char *__PROC__ = "SX_CHILL";
ClipVar *order = _clip_par(ClipMachineMemory, 1);
ClipVar *index = _clip_par(ClipMachineMemory, 2);
DBWorkArea *wa = cur_area(ClipMachineMemory);
int ord, er;
ClipMachineMemory->m6_error = 0;
CHECKWA(wa);
CHECKOPT2(1, CHARACTER_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKOPT1(2, CHARACTER_type_of_ClipVarType);
_clip_retl(ClipMachineMemory, 0);
ord = get_orderno(wa, order, index);
if (ord == -1)
ord = wa->rd->curord;
if (ord == -1)
return 0;
wa->rd->orders[ord]->custom = 0;
wa->rd->orders[ord]->canadd = 0;
_clip_retl(ClipMachineMemory, 1);
return 0;
err:
return er;
}
/**** Horizontal scrollbar constructor ****/
int
clip_GTK_HSCROLLBARNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
GtkAdjustment *adj;
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
adj = cadj ? GTK_ADJUSTMENT(cadj->widget) : NULL;
wid = gtk_hscrollbar_new(adj);
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_FILECHOOSERWIDGETNEWWITHBACKEND(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GtkFileChooserAction action = _clip_parni(ClipMachineMemory, 2);
gchar *backend = _clip_parc(ClipMachineMemory, 2);
GtkWidget *wid;
C_widget *cwid;
CHECKOPT2(1, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
CHECKARG(3, CHARACTER_type_of_ClipVarType);
wid = gtk_file_chooser_widget_new_with_backend(action, backend);
if (wid)
{
cwid = _list_get_cwidget(ClipMachineMemory, wid);
if (!cwid)
cwid = _register_widget(ClipMachineMemory, wid, cv);
if (cwid)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
}
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_SX_INDEXNAME(ClipMachine * ClipMachineMemory)
{
const char *__PROC__ = "SX_INDEXNAME";
DBWorkArea *wa = cur_area(ClipMachineMemory);
ClipVar *order = _clip_par(ClipMachineMemory, 1);
int ord, er;
ClipMachineMemory->m6_error = 0;
CHECKWA(wa);
CHECKOPT2(1, CHARACTER_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
_clip_retc(ClipMachineMemory, "");
ord = get_orderno(wa, order, NULL);
if (ord == -1)
ord = wa->rd->curord;
if (ord == -1)
return 0;
_clip_retc(ClipMachineMemory, wa->rd->orders[ord]->index->name);
return 0;
err:
return er;
}
/* Returns True is node is an ancestor of child. */
int
clip_GTK_CTREEISANCESTOR(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
C_object *cchild = _fetch_cobject(cm,_clip_spar(cm,3));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(3,MAP_t,NUMERIC_t); CHECKCOBJOPT(cchild,cchild->type==GTK_TYPE_CTREE_NODE);
_clip_retl(cm,gtk_ctree_is_ancestor(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object),
GTK_CTREE_NODE(cchild->object)));
return 0;
err:
return 1;
}
/* Move a node in the tree to another location. */
int
clip_GTK_CTREEMOVE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
C_object *cnew_parent = _fetch_cobject(cm,_clip_spar(cm,3));
C_object *cnew_sibling = _fetch_cobject(cm,_clip_spar(cm,4));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(3,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnew_parent,cnew_parent->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(4,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnew_sibling,cnew_sibling->type==GTK_TYPE_CTREE_NODE);
gtk_ctree_move(GTK_CTREE(cctree->widget),GTK_CTREE_NODE(cnode->object),
GTK_CTREE_NODE(cnew_parent->object),
GTK_CTREE_NODE(cnew_sibling->object));
return 0;
err:
return 1;
}
/* Remove the node and all nodes underneath it from the tree. */
int
clip_GTK_CTREEREMOVENODE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
gtk_ctree_remove_node(GTK_CTREE(cctree->widget),GTK_CTREE_NODE(cnode->object));
return 0;
err:
return 1;
}
/* Associates a GtkAdjustment with the GtkProgress. A GtkAdjustment is used
* to represent the upper and lower bounds and the step interval of the
* underlying value for which progress is shown. */
int
clip_GTK_PROGRESSSETADJUSTMENT(ClipMachine * cm)
{
C_widget *cprg = _fetch_cw_arg(cm);
C_widget *cadj = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cprg,GTK_IS_PROGRESS);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCWID(cadj,GTK_IS_ADJUSTMENT);
gtk_progress_set_adjustment(GTK_PROGRESS(cprg->widget),GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
/* 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;
}
int
clip_GTK_TREESELECTIONGETSELECTEDROWS(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
ClipVar *mod = ARGPTR(ClipMachineMemory, 2);
GtkTreeModel *model;
C_object *cmodel;
GList *list;
long l;
ClipVar *ret = RETPTR(ClipMachineMemory);
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
list = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(ctreesel->object), &model);
l = g_list_length(list);
_clip_array(ClipMachineMemory, ret, 1, &l);
for (l = 0; list; list = g_list_next(list), l++)
{
C_object *cpath;
GtkTreePath *path;
path = GTK_TREE_PATH(list->data);
cpath = _list_get_cobject(ClipMachineMemory, path);
if (!cpath)
cpath = _register_object(ClipMachineMemory, path, GTK_TYPE_TREE_PATH, NULL, NULL);
if (cpath)
_clip_aset(ClipMachineMemory, ret, &cpath->obj, 1, &l);
}
if (model)
{
cmodel = _list_get_cobject(ClipMachineMemory, model);
if (!cmodel)
cmodel = _register_object(ClipMachineMemory, model, GTK_TYPE_TREE_MODEL, NULL, NULL);
if (cmodel)
_clip_mclone(ClipMachineMemory, mod, &cmodel->obj);
}
g_list_foreach(list, (GFunc) (gtk_tree_path_free), NULL);
g_list_free(list);
return 0;
err:
return 1;
}
/* Sets the Adjustment for the vertical scrollbar. */
int
clip_GTK_VIEWPORTSETVADJUSTMENT (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
C_widget *cadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
CHECKCWID(cvp,GTK_IS_VIEWPORT);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCWIDOPT(cadj,GTK_IS_ADJUSTMENT);
gtk_viewport_set_vadjustment (GTK_VIEWPORT(cvp->widget),
GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
/* Used to add children without native scrolling capabilities.
* This is simply a convenience function; it is equivalent to adding the
* unscrollable child to a viewport, then adding the viewport to the
* scrolled window. If a child has native scrolling, use gtk_container_add()
* instead of this function. */
int
clip_GTK_SCROLLEDWINDOWADDWITHVIEWPORT (ClipMachine *cm)
{
C_widget *csw = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm, 2));
CHECKCWID(csw,GTK_IS_SCROLLED_WINDOW);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKCWIDOPT(cwid,GTK_IS_WIDGET);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(csw->widget), cwid->widget);
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONCOUNTSELECTEDROWS(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
_clip_retni(cm, gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(ctreesel->object)));
return 0;
err:
return 1;
}
/* Returns : Whether this node can be selected by the user. */
int
clip_GTK_CTREENODEGETSELECTABLE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
_clip_retl(cm,gtk_ctree_node_get_selectable(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object)));
return 0;
err:
return 1;
}
/* Toggle the expansion of a node and all its children. */
int
clip_GTK_CTREETOGGLEEXPANSIONRECURSIVE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
gtk_ctree_toggle_expansion_recursive(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object));
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;
}
