/**** 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;
}
/**** 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;
}
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;
}
/* 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_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;
}
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;
}
/* 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;
}
/**** 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;
}
/**** 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;
}
/* Sets the widget which initiates the query, usually a button. If
* the caller is selected while the query is running, the query is
* automatically stopped. */
int
clip_GTK_TIPSQUERYSETCALLER(ClipMachine * cm)
{
C_widget *ctq = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(ctq,GTK_IS_TIPS_QUERY);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWIDOPT(cwid,GTK_IS_WIDGET);
gtk_tips_query_set_caller(GTK_TIPS_QUERY(ctq->widget), cwid->widget);
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;
}
/* Sets the Adjustment for the vertical scrollbar. */
int
clip_GTK_SCROLLEDWINDOWSETVADJUSTMENT (ClipMachine *cm)
{
C_widget *csw = _fetch_cw_arg(cm);
C_widget *cadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
CHECKCWID(csw,GTK_IS_SCROLLED_WINDOW);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKCWIDOPT(cadj,GTK_IS_ADJUSTMENT);
gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW(csw->widget),
GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
/* Sets the widget which initiates the query, usually a button. If
* the caller is selected while the query is running, the query is
* automatically stopped. */
int
clip_GTK_TIPSQUERYSETCALLER(ClipMachine * ClipMachineMemory)
{
C_widget *ctq = _fetch_cw_arg(ClipMachineMemory);
C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(ctq, GTK_IS_TIPS_QUERY);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cwid, GTK_IS_WIDGET);
gtk_tips_query_set_caller(GTK_TIPS_QUERY(ctq->widget), cwid->widget);
return 0;
err:
return 1;
}
/* Sets the Adjustment for the horizontal scrollbar. */
int
clip_GTK_SCROLLEDWINDOWSETHADJUSTMENT(ClipMachine * ClipMachineMemory)
{
C_widget *csw = _fetch_cw_arg(ClipMachineMemory);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(csw, GTK_IS_SCROLLED_WINDOW);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(csw->widget), GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
/* Changes which GtkAdjustment is associated with a spin button. */
int
clip_GTK_SPINBUTTONSETADJUSTMENT(ClipMachine * ClipMachineMemory)
{
C_widget *cspb = _fetch_cw_arg(ClipMachineMemory);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(cspb, GTK_IS_SPIN_BUTTON);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(cspb->widget), GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
/* Alena: set horizontal adjustment for layout */
int
clip_GTK_LAYOUTSETHADJUSTMENT(ClipMachine * cm)
{
C_widget *clay = _fetch_cw_arg(cm);
C_widget * cadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
GtkAdjustment *adj;
CHECKCWID(clay,GTK_IS_LAYOUT);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCWIDOPT(cadj,GTK_IS_ADJUSTMENT);
adj = cadj ? GTK_ADJUSTMENT(cadj->widget) : NULL;
gtk_layout_set_hadjustment(GTK_LAYOUT(clay->widget), adj);
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_GDK_WINDOWSETBACKPIXMAP(ClipMachine * cm)
{
C_widget *cwin = _fetch_cw_arg(cm);
C_widget *cpix = _fetch_cwidget(cm, _clip_spar(cm, 2));
gboolean relative = _clip_parl(cm, 3);
GdkWindow *win = NULL;
GdkPixmap *pix = NULL;
GdkBitmap *mask;
CHECKCWID(cwin,GTK_IS_WIDGET); CHECKOPT(2, MAP_t);
CHECKCWIDOPT(cpix,GTK_IS_PIXMAP);
CHECKARG(3,LOGICAL_t);
if (cwin && cwin->widget) win = (GdkWindow *)cwin->widget->window;
if (cpix) gtk_pixmap_get(GTK_PIXMAP(cpix->widget), &pix, &mask);
gdk_window_set_back_pixmap(win, pix, relative);
return 0;
err:
return 1;
}
/* Set the pixmap in a node. */
int
clip_GTK_CTREENODESETPIXMAP(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);
C_widget *cpixmap = _fetch_cwidget(cm,_clip_spar(cm,4));
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);
CHECKOPT2(4,MAP_t,NUMERIC_t); CHECKCWIDOPT(cpixmap,GTK_IS_PIXMAP);
if (_clip_parinfo(cm,3)==UNDEF_t) column = 1;
if (cpixmap)
{
pixmap = GTK_PIXMAP(cpixmap->widget)->pixmap;
mask = GTK_PIXMAP(cpixmap->widget)->mask;
}
gtk_ctree_node_set_pixmap(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object), column-1,pixmap,mask);
return 0;
err:
return 1;
}
/******************* FILE CHOOSER DIALOG *************************************/
int
clip_GTK_FILECHOOSERDIALOGNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
gchar *title = _clip_parc(ClipMachineMemory, 2);
C_widget *cparent = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));
GtkFileChooserAction action = _clip_parni(ClipMachineMemory, 4);
GtkWidget *wid;
C_widget *cwid;
gchar *button[20], *response_id[20];
gint i, j, n;
CHECKOPT2(1, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
CHECKCWIDOPT(cparent, GTK_IS_WINDOW);
CHECKARG(4, NUMERIC_type_of_ClipVarType);
memset(button, 0, sizeof(button));
memset(response_id, 0, sizeof(response_id));
n = _clip_parinfo(ClipMachineMemory, 0);
for (i = 0, j = 5; j < n; j += 2, i++)
{
CHECKOPT(j, CHARACTER_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, j) == UNDEF_type_of_ClipVarType)
break;
CHECKOPT(j + 1, CHARACTER_type_of_ClipVarType);
button[i] = _clip_parc(ClipMachineMemory, j);
response_id[i] = _clip_parc(ClipMachineMemory, j + 1);
LOCALE_TO_UTF(button[i]);
LOCALE_TO_UTF(response_id[i]);
}
if (title)
LOCALE_TO_UTF(title);
wid = gtk_file_chooser_dialog_new((title) ? title : NULL,
GTK_WINDOW(cparent->widget),
action,
button[0], response_id[0], button[1],
response_id[1], button[2],
response_id[2], button[3],
response_id[3], button[4],
response_id[4], button[5],
response_id[5], button[6],
response_id[6], button[7],
response_id[7], button[8],
response_id[8], button[9],
response_id[9], button[10],
response_id[10], button[11],
response_id[11], button[12],
response_id[12], button[13],
response_id[13], button[14],
response_id[14], button[15],
response_id[15], button[16],
response_id[16], button[17],
response_id[17], button[18], response_id[18], button[19], response_id[19], NULL);
for (i = 0; i < n - 5; i++)
{
FREE_TEXT(button[i]);
FREE_TEXT(response_id[i]);
}
if (title)
FREE_TEXT(title);
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;
}
/* Change the information. Most parameters correspond to the parameters
of gtk_ctree_insert_node. */
int
clip_GTK_CTREENODESETNODEINFO(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
ClipVar *cvtext = _clip_spar(cm,3);
guint8 spacing = _clip_parni(cm,4);
C_widget *cclosed = _fetch_cwidget(cm,_clip_spar(cm,5));
C_widget *copened = _fetch_cwidget(cm,_clip_spar(cm,6));
gboolean is_leaf = _clip_parl(cm,7);
gboolean expanded = _clip_parl(cm,8);
GtkCTreeNode *node = 0;
GdkPixmap *pxm_closed=NULL, *pxm_opened=NULL;
GdkBitmap *mask_closed=NULL, *mask_opened=NULL;
int i;
gchar * * columns = NULL;
int ncolumns;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(3,ARRAY_t,CHARACTER_t); CHECKOPT(4,NUMERIC_t);
CHECKOPT2(5,MAP_t,NUMERIC_t); CHECKCWIDOPT(cclosed,GTK_IS_PIXMAP);
CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(copened,GTK_IS_PIXMAP);
CHECKOPT(7,LOGICAL_t); CHECKOPT(8,LOGICAL_t);
if (cnode) node = GTK_CTREE_NODE(cnode->object);
if (cclosed)
{
pxm_closed=GTK_PIXMAP(cclosed->widget)->pixmap;
mask_closed=GTK_PIXMAP(cclosed->widget)->mask;
}
if (copened)
{
pxm_opened=GTK_PIXMAP(copened->widget)->pixmap;
mask_opened=GTK_PIXMAP(copened->widget)->mask;
}
if (_clip_parinfo(cm,7)==UNDEF_t) is_leaf = TRUE;
if (_clip_parinfo(cm,8)==UNDEF_t) expanded = FALSE;
ncolumns = GTK_CLIST(cctree->widget)->columns;
columns = (gchar**)calloc(sizeof(columns),ncolumns);
for(i=0; i < ncolumns; i++ ) columns[i] = "";
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
{
columns[i] = acol->items[i].s.str.buf;
LOCALE_TO_UTF(columns[i]);
}
}
if (cvtext->t.type==CHARACTER_t)
{
columns[0] = _clip_parc(cm,2);
LOCALE_TO_UTF(columns[0]);
}
gtk_ctree_set_node_info(GTK_CTREE(cctree->widget),
node,columns[0],spacing,pxm_closed,mask_closed,
pxm_opened,mask_opened,is_leaf,expanded);
#ifdef OS_CYGWIN
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
FREE_TEXT(columns[i]);
}
if (cvtext->t.type==CHARACTER_t)
FREE_TEXT(columns[0]);
#endif
if (columns) free(columns);
return 0;
err:
return 1;
}
/* Insert a new node to the tree. The position is specified through the
* parent-sibling notation, as explained in the introduction above. */
int
clip_GTK_CTREEINSERTNODE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cparent = _fetch_cobject(cm,_clip_spar(cm,2));
C_object *csibling = _fetch_cobject(cm,_clip_spar(cm,3));
ClipVar *cvtext = _clip_spar(cm,4);
guint8 spacing = _clip_parni(cm,5);
C_widget *cclosed = _fetch_cwidget(cm,_clip_spar(cm,6));
C_widget *copened = _fetch_cwidget(cm,_clip_spar(cm,7));
gboolean is_leaf = _clip_parl(cm,8);
gboolean expanded = _clip_parl(cm,9);
GtkCTreeNode *new_node, *parent=NULL, *sibling=NULL;
GdkPixmap *pxm_closed=NULL, *pxm_opened=NULL;
GdkBitmap *mask_closed=NULL, *mask_opened=NULL;
C_object *cnew_node;
int i;
gchar * * columns = NULL;
int ncolumns;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cparent,cparent->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(3,MAP_t,NUMERIC_t); CHECKCOBJOPT(csibling,csibling->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(4,ARRAY_t,CHARACTER_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cclosed,GTK_IS_PIXMAP);
CHECKOPT2(7,MAP_t,NUMERIC_t); CHECKCWIDOPT(copened,GTK_IS_PIXMAP);
CHECKOPT(8,LOGICAL_t); CHECKOPT(9,LOGICAL_t);
if (cparent) parent = GTK_CTREE_NODE(cparent->object);
if (csibling) sibling = GTK_CTREE_NODE(csibling->object);
if (cclosed)
{
pxm_closed=GTK_PIXMAP(cclosed->widget)->pixmap;
mask_closed=GTK_PIXMAP(cclosed->widget)->mask;
}
if (copened)
{
pxm_opened=GTK_PIXMAP(copened->widget)->pixmap;
mask_opened=GTK_PIXMAP(copened->widget)->mask;
}
if (_clip_parinfo(cm,8)==UNDEF_t) is_leaf = TRUE;
if (_clip_parinfo(cm,9)==UNDEF_t) expanded = FALSE;
ncolumns = GTK_CLIST(cctree->widget)->columns;
columns = (gchar**)calloc(sizeof(columns),ncolumns);
for(i=0; i < ncolumns; i++ ) columns[i] = "";
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
{
columns[i] = acol->items[i].s.str.buf;
LOCALE_TO_UTF(columns[i]);
}
}
if (cvtext->t.type==CHARACTER_t)
{
columns[0] = _clip_parc(cm,2);
LOCALE_TO_UTF(columns[0]);
}
new_node = gtk_ctree_insert_node(GTK_CTREE(cctree->widget),
parent,sibling,columns,spacing,pxm_closed,mask_closed,
pxm_opened,mask_opened,is_leaf,expanded);
if (new_node)
{
cnew_node = _register_object(cm,new_node,GTK_TYPE_CTREE_NODE,NULL,NULL);
if (cnew_node) _clip_mclone(cm,RETPTR(cm),&cnew_node->obj);
gtk_ctree_node_set_row_data_full(GTK_CTREE(cctree->widget),
new_node,cnew_node,(GtkDestroyNotify)destroy_c_object);
}
#ifdef OS_CYGWIN
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
FREE_TEXT(columns[i]);
}
if (cvtext->t.type==CHARACTER_t)
FREE_TEXT(columns[0]);
#endif
if (columns) free(columns);
return 0;
err:
return 1;
}
