/**** Adjustment constructor ****/
int
clip_GTK_ADJUSTMENTNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
gfloat value = _clip_parnd(ClipMachineMemory, 2);
gfloat lower = _clip_parnd(ClipMachineMemory, 3);
gfloat upper = _clip_parnd(ClipMachineMemory, 4);
gfloat step_inc = _clip_parnd(ClipMachineMemory, 5);
gfloat page_inc = _clip_parnd(ClipMachineMemory, 6);
gfloat page_size = _clip_parnd(ClipMachineMemory, 7);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
CHECKOPT(3, NUMERIC_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);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
value = 0;
if (_clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType)
lower = 0;
if (_clip_parinfo(ClipMachineMemory, 4) == UNDEF_type_of_ClipVarType)
upper = 100;
if (_clip_parinfo(ClipMachineMemory, 5) == UNDEF_type_of_ClipVarType)
step_inc = 1;
if (_clip_parinfo(ClipMachineMemory, 6) == UNDEF_type_of_ClipVarType)
page_inc = 10;
if (_clip_parinfo(ClipMachineMemory, 7) == UNDEF_type_of_ClipVarType)
page_size = 10;
wid = (GtkWidget *) gtk_adjustment_new(value, lower, upper, step_inc, page_inc, page_size);
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_GETOBJBYHANDLE(ClipMachine *cm)
{
long handle = _clip_parnl(cm,1);
C_widget *cwid;
C_object *cobj;
CHECKARG(1,NUMERIC_t);
cwid = _fetch_cwidgetn(cm,handle);
if (cwid)
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
else
{
cobj = _fetch_cobjectn(cm,handle);
if (cobj)
{
_clip_mclone(cm,RETPTR(cm),&cobj->obj);
return 0;
}
}
return 0;
err:
return 1;
}
/**** Color selection dialog constructor ****/
int
clip_GTK_COLORSELECTIONDIALOGNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
char *title = _clip_parc(ClipMachineMemory, 2);
GtkWidget *wid = NULL;
C_widget *cwid, *ccolorsel, *cokbtn, *ccancelbtn, *chlpbtn;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
title = "\0";
LOCALE_TO_UTF(title);
wid = gtk_color_selection_dialog_new(title);
FREE_TEXT(title);
cwid = _register_widget(ClipMachineMemory, wid, cv);
ccolorsel = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->colorsel, NULL);
cokbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->ok_button, NULL);
ccancelbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->cancel_button, NULL);
chlpbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->help_button, NULL);
if (ccolorsel)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_COLORSEL, &ccolorsel->obj);
if (cokbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_OKBUTTON, &cokbtn->obj);
if (ccancelbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_CANCELBUTTON, &ccancelbtn->obj);
if (chlpbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_HELPBUTTON, &chlpbtn->obj);
if (ccolorsel)
_clip_destroy(ClipMachineMemory, &ccolorsel->obj);
if (cokbtn)
_clip_destroy(ClipMachineMemory, &cokbtn->obj);
if (ccancelbtn)
_clip_destroy(ClipMachineMemory, &ccancelbtn->obj);
if (chlpbtn)
_clip_destroy(ClipMachineMemory, &chlpbtn->obj);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
int
clip_GTK_TREEROOTTREE(ClipMachine * ClipMachineMemory)
{
C_widget *ctree = _fetch_cw_arg(ClipMachineMemory);
C_widget *croot;
CHECKCWID(ctree, GTK_IS_TREE);
croot = _get_cwidget(ClipMachineMemory, GTK_WIDGET(GTK_TREE_ROOT_TREE(ctree->widget)));
if (croot)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &croot->obj);
return 0;
err:
return 1;
}
int
clip_GTK_TREEITEMGETSUBTREE(ClipMachine * cm)
{
C_widget *citm = _fetch_cw_arg(cm);
C_widget *csubtree = NULL;
GtkWidget *subtree;
CHECKCWID(citm,GTK_IS_TREE_ITEM);
subtree = GTK_TREE_ITEM_SUBTREE(citm->widget);
csubtree = _list_get_cwidget(cm, subtree);
if (!csubtree) csubtree = _register_widget(cm, subtree, NULL);
if (csubtree) _clip_mclone(cm,RETPTR(cm),&csubtree->obj);
return 0;
err:
return 1;
}
int
clip_GTK_PROGRESSGETADJUSTMENT(ClipMachine * ClipMachineMemory)
{
C_widget *cprg = _fetch_cw_arg(ClipMachineMemory);
C_widget *cadj;
CHECKCWID(cprg, GTK_IS_PROGRESS);
cadj = _get_cwidget(ClipMachineMemory, GTK_WIDGET(GTK_PROGRESS(cprg->widget)->adjustment));
if (cadj)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cadj->obj);
return 0;
err:
return 1;
}
/**** Radio group constructor ****/
int
clip_GTK_RADIOGROUPNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget *cwid;
CHECKOPT(1,MAP_t);
cwid = _register_widget(cm, NULL, cv);
cwid->type = _clip_type_radio_group();
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/* Register a function to be called when the mainloop is started. */
int
clip_GTK_INITADD(ClipMachine * cm)
{
C_var *c;
CHECKARG2(1,PCODE_t,CCODE_t);
c = NEW(C_var);
c->cm = cm; //c->cfunc = NEW(ClipVar);
_clip_mclone(cm,&c->cfunc, _clip_spar(cm,1));
gtk_init_add((GtkFunction)__func,c);
return 0;
err:
return 1;
}
/**** TIPS QUERY constructor ****/
int
clip_GTK_TIPSQUERYNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
wid = gtk_tips_query_new();
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_TIPSQUERYGETCALLER(ClipMachine * cm)
{
C_widget *ctq = _fetch_cw_arg(cm);
C_widget *cwid = NULL;
CHECKCWID(ctq,GTK_IS_TIPS_QUERY);
if (GTK_TIPS_QUERY(ctq->widget)->caller)
{
cwid = _list_get_cwidget(cm,GTK_TIPS_QUERY(ctq->widget)->caller);
if (!cwid) cwid = _register_widget(cm,GTK_TIPS_QUERY(ctq->widget)->caller,NULL);
if (cwid) _clip_mclone(cm,RETPTR(cm),&cwid->obj);
}
return 0;
err:
return 1;
}
int
clip_GTK_FILEFILTERNEW(ClipMachine * cm)
{
GtkFileFilter *filter;
C_object *cfilter;
filter = gtk_file_filter_new();
if (filter)
{
cfilter = _register_object(cm, filter, GTK_TYPE_FILE_FILTER, NULL,NULL);
if (cfilter) _clip_mclone(cm,RETPTR(cm),&cfilter->obj);
}
return 0;
}
int
clip_GTK_BUTTONGETLABEL(ClipMachine * ClipMachineMemory)
{
C_widget *cbtn = _fetch_cw_arg(ClipMachineMemory);
C_widget *cwid;
CHECKCWID(cbtn, GTK_IS_BUTTON);
cwid = _get_cwidget(ClipMachineMemory, GTK_BIN(&(GTK_BUTTON(cbtn->widget)->bin))->child);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
/* Returns the vertical scrollbar's adjustment, used to
* connect the vertical scrollbar to the child widget's
* vertical scroll functionality. */
int
clip_GTK_VIEWPORTGETVADJUSTMENT (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
ClipVar * cv = RETPTR(cm);
GtkAdjustment* adj;
C_widget *cadj;
CHECKCWID(cvp,GTK_IS_VIEWPORT);
adj = gtk_viewport_get_vadjustment (GTK_VIEWPORT(cvp->widget));
cadj = _list_get_cwidget(cm, adj);
if (!cadj) cadj = _register_widget(cm, (GtkWidget*)adj, NULL);
if (cadj) _clip_mclone(cm, cv, &cadj->obj);
return 0;
err:
return 1;
}
/* Returns the vertical scrollbar's adjustment, used to
* connect the vertical scrollbar to the child widget's
* vertical scroll functionality. */
int
clip_GTK_SCROLLEDWINDOWGETVADJUSTMENT (ClipMachine *cm)
{
C_widget *csw = _fetch_cw_arg(cm);
ClipVar * cv = RETPTR(cm);
GtkAdjustment* adj;
C_widget *cadj;
CHECKCWID(csw,GTK_IS_SCROLLED_WINDOW);
adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(csw->widget));
cadj = _list_get_cwidget(cm, adj);
if (!cadj) cadj = _register_widget(cm, (GtkWidget*)adj, NULL);
if (cadj) _clip_mclone(cm, cv, &cadj->obj);
return 0;
err:
return 1;
}
int
clip_GTK_ICONTHEMEGETDEFAULT(ClipMachine * cm)
{
C_object *cicon;
GtkIconTheme *icon;
icon = gtk_icon_theme_get_default();
if (icon)
{
cicon = _list_get_cobject(cm,icon);
if (!cicon) cicon = _register_object(cm,icon,GTK_TYPE_ICON_THEME,NULL,NULL);
if (cicon) _clip_mclone(cm,RETPTR(cm),&cicon->obj);
}
return 0;
}
/* Returns the menu tab of the page child. NULL is returned if child is
* not in notebook or NULL if it has the default tab label. */
int
clip_GTK_NOTEBOOKGETTABLABEL(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
C_widget *cchild = _fetch_cwidget(cm,_clip_spar(cm,2));
C_widget *cwid;
GtkWidget *wid;
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cchild,GTK_IS_WIDGET);
wid = gtk_notebook_get_tab_label(GTK_NOTEBOOK(cntb->widget), cchild->widget);
cwid = _list_get_cwidget(cm,wid);
if (!cwid) cwid = _register_widget(cm,wid,NULL);
if (cwid) _clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/**** Menu item constructor ****/
int
clip_GTK_MENUITEMNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
char *label = _clip_parc(ClipMachineMemory, 2);
char *pchar = _clip_parc(ClipMachineMemory, 3);
GtkWidget *wid = NULL;
C_widget *cwid;
guint accel_key = 0;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
CHECKOPT(3, CHARACTER_type_of_ClipVarType);
if (pchar)
{
char *pc;
for (pc = label; pc && *pc; pc++)
if (*pc == *pchar)
*pc = '_';
}
if (_clip_parinfo(ClipMachineMemory, 2) != CHARACTER_type_of_ClipVarType)
wid = gtk_menu_item_new();
else
{
LOCALE_TO_UTF(label);
wid = gtk_menu_item_new_with_label(label);
if (pchar)
accel_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(&(GTK_ITEM(wid)->bin))->child), label);
FREE_TEXT(label);
}
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
_clip_mputn(ClipMachineMemory, &cwid->obj, HASH_ACCELKEY, accel_key);
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;
}
int
clip_GTK_ACCELMAPGET(ClipMachine * ClipMachineMemory)
{
C_object *cmap;
GtkAccelMap *map;
map = gtk_accel_map_get();
if (map)
{
cmap = _list_get_cobject(ClipMachineMemory, map);
if (!cmap)
cmap = _register_object(ClipMachineMemory, map, GTK_TYPE_ACCEL_MAP, NULL, NULL);
if (cmap)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cmap->obj);
}
return 0;
}
int
clip_GTK_FILECHOOSERERRORQUARK(ClipMachine * ClipMachineMemory)
{
GQuark error_quark;
C_object *cerr;
error_quark = gtk_file_chooser_error_quark();
if (error_quark)
{
cerr = _register_object(ClipMachineMemory, &error_quark, GTK_TYPE_OBJECT, NULL, NULL);
if (cerr)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cerr->obj);
}
return 0;
}
int
clip_GTK_FONTCOMBOGETFONT(ClipMachine * ClipMachineMemory)
{
C_widget *cfnc = _fetch_cw_arg(ClipMachineMemory);
C_object *cfont;
CHECKCWID(cfnc, GTK_IS_FONT_COMBO);
cfont = _list_get_cobject(ClipMachineMemory, GTK_FONT_COMBO(cfnc->widget)->font);
if (!cfont)
cfont = _register_object(ClipMachineMemory, GTK_FONT_COMBO(cfnc->widget)->font,
GDK_OBJECT_FONT, NULL, (coDestructor) gdk_object_font_destructor);
if (cfont)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cfont->obj);
return 0;
err:
return 1;
}
/* Returns the content of the page number page_num, or
* NULL if page_num is out of bounds. */
int
clip_GTK_NOTEBOOKGETNTHPAGE(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gint page_num = _clip_parni(cm,2);
C_widget *cwid;
GtkWidget *wid;
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,NUMERIC_t);
if (_clip_parinfo(cm,2)==UNDEF_t) page_num = 1;
wid = gtk_notebook_get_nth_page(GTK_NOTEBOOK(cntb->widget), page_num-1);
cwid = _list_get_cwidget(cm,wid);
if (!cwid) cwid = _register_widget(cm,wid,NULL);
if (cwid) _clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
static void
destroy_notify(gpointer data)
{
C_var *c = (C_var *) data;
ClipVar stack[1];
ClipVar res;
memset(&stack, 0, sizeof(stack));
memset(&res, 0, sizeof(ClipVar));
_clip_mclone(c->ClipMachineMemory, &stack[0], &c->co->obj);
_clip_eval(c->ClipMachineMemory, &c->cfunc, 1, stack, &res);
_clip_destroy(c->ClipMachineMemory, &res);
_clip_destroy(c->ClipMachineMemory, &stack[0]);
}
int
clip_GDK_DRAGCONTEXTNEW(ClipMachine * cm)
{
GdkDragContext *context;
C_object *ccontext ;
context = gdk_drag_context_new();
if (context)
{
ccontext = _list_get_cobject(cm, context);
if (!ccontext) ccontext = _register_object(cm, context, GDK_TYPE_DRAG_CONTEXT, NULL, NULL);
if (ccontext) _clip_mclone(cm, RETPTR(cm), &ccontext->obj);
}
return 0;
}
/* Calls the CLIP function for each children */
int
clip_GTK_CONTAINERFOREACH (ClipMachine *cm)
{
C_widget *ccon = _fetch_cw_arg(cm);
ClipVar *cfunc = _clip_spar(cm,2);
C_var *c = 0;
CHECKCWID(ccon,GTK_IS_CONTAINER);
CHECKARG2(2,CCODE_t,PCODE_t);
c->cm = cm; c->cw = ccon;
_clip_mclone(cm, &c->cfunc, cfunc);
gtk_container_foreach(GTK_CONTAINER(ccon->widget),
(GtkCallback)_container_for_each_func,c);
return 0;
err:
return 1;
}
int
clip_GTK_COMBOBOXNEWTEXT(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
wid = gtk_combo_box_new_text();
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/*
static gint
__timeout__func(void* data)
{
ClipVar res;
C_var *c = (C_var*)data;
int ret = TRUE;
memset( &res, 0, sizeof(ClipVar) );
_clip_eval( c->cm, &(c->cfunc), 0, NULL, &res );
if (res.t.type == LOGICAL_t)
ret = res.l.val;
_clip_destroy(c->cm, &res);
if (!ret)
_destroy__func(c);
return ret;
}
*/
static gint
__timeout__func(void* data)
{
ClipVar res;
C_var *c = (C_var*)data;
ClipVar stack[1];
int ret = TRUE;
memset( &stack, 0, sizeof(stack) );memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->cm, &stack[0], c->cv);
_clip_eval( c->cm, &c->cfunc, 1, stack, &res );
if (res.t.type == LOGICAL_t)
ret = res.l.val;
_clip_destroy(c->cm, &res);
_clip_destroy(c->cm, &stack[0]);
// if (!ret)
// _destroy__func(c);
return ret;
}
static void
_item_factory_callback2(GtkWidget *wid, gpointer data, guint callback_action)
{
C_var *c = (C_var*)data;
C_widget *c_wid = _list_get_cwidget(c->cm, wid);
ClipVar stack[2];
ClipVar res;
if (!c_wid)
c_wid = _register_widget(c->cm,wid, NULL);
if (c_wid)
{
memset(&stack,0,sizeof(stack)); memset( &res, 0, sizeof(ClipVar) );
_clip_mclone(c->co->cmachine, &stack[0], &c->co->obj);
stack[1] = c_wid->obj;
_clip_eval( c->cm, &(c->cfunc), 2, stack, &res );
_clip_destroy(c->cm, &res);
}
}
int
clip_GTK_WIDGETGETTOPLEVEL (ClipMachine *cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
GtkWidget *toplevel; C_widget *ctoplevel;
CHECKOPT(2,NUMERIC_t);
CHECKCWID(cwid,GTK_IS_WIDGET);
toplevel = gtk_widget_get_toplevel(cwid->widget);
if (toplevel)
{
ctoplevel = _list_get_cwidget(cm,toplevel);
if (!ctoplevel) ctoplevel = _register_widget(cm,toplevel,NULL);
if (ctoplevel) _clip_mclone(cm,RETPTR(cm),&ctoplevel->obj);
}
return 0;
err:
return 1;
}
/**** Gamma Curve constructor ****/
int
clip_GTK_GAMMACURVENEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
wid = gtk_gamma_curve_new();
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
