/***************************************************************************
                          gins.c - main entry for gins
                             -------------------
    begin                : ven dic 31 2004
    copyright            : (C) 2004-2005 by Fabrix.xm
    email                : fabrix.xm@lombardiacom.it
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 **************************************************************************/

#include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <glade/glade.h>
#include <glib.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>



#define VERSION "0.0.2"

// globals
GladeXML *xml;

LOCK=0;

gchar ginsbuffer1[255];
gchar ginsbuffer2[255];
gchar ginsbuffer3[255];

int bufferfull = 0;

//
void removeNL(char *);

// event strings
/*
char* eventTypes[] = {
  "GDK_NOTHING",
  "GDK_DELETE",
  "GDK_DESTROY",
  "GDK_EXPOSE",
  "GDK_MOTION_NOTIFY",
  "GDK_BUTTON_PRESS",
  "GDK_2BUTTON_PRESS",
  "GDK_3BUTTON_PRESS",
  "GDK_BUTTON_RELEASE",
  "GDK_KEY_PRESS",
  "GDK_KEY_RELEASE",
  "GDK_ENTER_NOTIFY",
  "GDK_LEAVE_NOTIFY",
  "GDK_FOCUS_CHANGE",
  "GDK_CONFIGURE",
  "GDK_MAP",
  "GDK_UNMAP",
  "GDK_PROPERTY_NOTIFY",
  "GDK_SELECTION_CLEAR",
  "GDK_SELECTION_REQUEST",
  "GDK_SELECTION_NOTIFY",
  "GDK_PROXIMITY_IN",
  "GDK_PROXIMITY_OUT",
  "GDK_DRAG_ENTER",
  "GDK_DRAG_LEAVE",
  "GDK_DRAG_MOTION",
  "GDK_DRAG_STATUS",
  "GDK_DROP_START",
  "GDK_DROP_FINISHED",
  "GDK_CLIENT_EVENT",
  "GDK_VISIBILITY_NOTIFY",
  "GDK_NO_EXPOSE",
  "GDK_SCROLL",
  "GDK_WINDOW_STATE",
  "GDK_SETTING ",
  "GDK_OWNER_CHANGE"
};
*/
char* eventTypes[] = {
  "GDK_NOTHING",
  "GDK_DELETE",
  "GDK_DESTROY",
  "GDK_EXPOSE",
  "GDK_MOTION_NOTIFY",
  "GDK_BUTTON_PRESS",
  "GDK_2BUTTON_PRESS",
  "GDK_3BUTTON_PRESS",
  "GDK_BUTTON_RELEASE",
  "GDK_KEY_PRESS",
  "GDK_KEY_RELEASE",
  "GDK_ENTER_NOTIFY",
  "GDK_LEAVE_NOTIFY",
  "GDK_FOCUS_CHANGE",
  "GDK_CONFIGURE",
  "GDK_MAP",
  "GDK_UNMAP",
  "GDK_PROPERTY_NOTIFY",
  "GDK_SELECTION_CLEAR",
  "GDK_SELECTION_REQUEST",
  "GDK_SELECTION_NOTIFY",
  "GDK_PROXIMITY_IN",
  "GDK_PROXIMITY_OUT",
  "GDK_NOTHING",
  "GDK_NOTHING",
  "GDK_NOTHING",
  "GDK_NOTHING",
  "GDK_NOTHING",
  "GDK_CLIENT_EVENT",
  "GDK_VISIBILITY_NOTIFY",
  "GDK_NO_EXPOSE",
  "GDK_SCROLL",
  "GDK_WINDOW_STATE",
  "GDK_SETTING ",
  "GDK_OWNER_CHANGE"
};
//-- required by clist **text --
// 6 is number of arguments for gtk()

struct{
	gchar *text;
}returntext[6];



//-- empty textarry needed for clist_append --
gchar *textarray[1];

//-- this array stores the number of the currently selected row of a clist --
struct{
	guint selected;
}listselections[1000];

//-- needed to iterate the selections --
gint clistcounter = 0;


static int 
gignore_error (Display *d, XErrorEvent *e)
{
  	return 0;
}


void removeNL(char *text) {
	/*elimino un eventuale "acapo" in fondo alla stringa*/
	if (text[strlen(text)-1]=='\n') text[strlen(text)-1]='\0';
}


	GList* GTKwidgets=NULL;
	GList* GTKwidgetnames=NULL;
	GList* GTKwidgettypes=NULL;


        int GOcount = 0;

struct{        
  gchar name[255];
  gchar type[255];
  GtkWidget *obj;

}GO[1000];
	guint lastfoundobject = -1;


//-- required for gtk_textbuf
GtkTextIter TextIter1, TextIter2 , TextIter3;

struct{
	GtkTextIter Iter; 
}TextIters[6];


//-- gets an argument from the wxBasic stack and returns it as string --

gchar *getstringarg(){

	wVariant *variant;
	variant = (wVariant *)wMalloc( sizeof( wVariant ) );
	gchar *wstring;
	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
    	wVariantDeref( variant );
	return (wstring);
}


//-- return a string to wxBasic

void returnstring(char *thestring){

        	wVariant *myvariant;
		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );
           	//-- create a string
           	wVariantFromChar( myvariant, thestring ,4,4 );
    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );
   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);
}


//-- return a GSList as a list (table) to wxBasic

void returnlist(GSList *thelist){
	GSList* li = NULL;
	gchar *theline;

	//printf("---------------------ListStuff\n");
        gchar mystring[10000];
        wVariant *mylist;
        wVariant *myvariant;
        wVariant *mykey;
        int c=0;

	myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );
	mylist = (wVariant *)wMalloc( sizeof( wVariant ) );

        wTableNew(mylist);
	mykey = (wVariant *)wMalloc( sizeof( wVariant ) );



	for(li = thelist; li != NULL; li = li->next){

		sprintf(theline , "%s" , li->data);
		//printf("--%s\n" , theline);

           //-- create a key
           sprintf( mystring,"%d" ,  c );
           wVariantFromChar( mykey, mystring ,3,3 );
           //-- create a string
           wVariantFromChar( myvariant, theline ,4,4 );
           //-- append it to the list
           wTableInsert(mylist , mykey, myvariant );  
           c++;
	}
 	wVariantMove( wStackPushNothing(), mylist );

    //-- cleanup    
    wVariantDeref( myvariant );
    wFree(myvariant);
    wVariantDeref( mylist );
    wFree(mylist);
    wVariantDeref( mykey );
    wFree(mykey);

    return;

	//g_slist_free(thelist);
}

//-- search a widget in the internal gslist , or in the Glade objects if none was found --

GSList *findobject(gchar *arg0){

//    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
//    g_static_mutex_lock (&mutex);

//printf("----> g... %s\n" , arg0 );
	gchar tempobjectname[255];
	GList *li = NULL; /* an iterator variable */
	GtkWidget *TESTobj;
	gchar *fcobjectname;
	int i;
        GList *li1 = NULL;

	lastfoundobject = -1;

	fcobjectname = strstr(arg0 , ":");
	if(fcobjectname){
		i = 0;	

		if (g_list_length(GTKwidgetnames) > 0){
			for(li = GTKwidgetnames; li != NULL; li = li->next){
	
        			sprintf(tempobjectname , ":%s", (char *)li->data);
				if (!strcmp(  tempobjectname , fcobjectname )) {
					li1 = g_list_nth(GTKwidgets , i);
					lastfoundobject = i;
//printf("----> gtkobject %s\n" , fcobjectname );
					break;
				}
				i++;

 
				if( i == g_list_length(GTKwidgetnames)){

					for(i=0;i<strlen(fcobjectname);i++){
						fcobjectname[i] = fcobjectname[i+1];
					}

					TESTobj = glade_xml_get_widget(xml, fcobjectname);

					li1 = g_list_prepend(li1 , TESTobj);
					li1 = g_list_first(li1);

				}   
			}
		}else{
			for(i=0;i<strlen(fcobjectname);i++){
				fcobjectname[i] = fcobjectname[i+1];
			}

			TESTobj = glade_xml_get_widget(xml, fcobjectname);

			li1 = g_list_prepend(li1 , TESTobj);
			li1 = g_list_first(li1);

		}
	}
//g_static_mutex_unlock (&mutex);

	li = NULL;
	return( li1 );
}


//-- external clist support --

#include "lists.h"
#include "lists.c"


//-- some stuff to try to solve xlib-sync errors --

void wBuiltin_gdk_flush(){


    //LOCK=1;
    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
    gdk_threads_enter();
	//gdk_flush();
	gdk_flush();
//GdkDisplay *display = gdk_display_get_default ();
//XFlush (GDK_DISPLAY_XDISPLAY (display);
    gdk_threads_leave();
    g_static_mutex_unlock (&mutex);
    //LOCK=0;

}
void wBuiltin_gdk_error_trap_push(){
  gdk_error_trap_push();
}
void wBuiltin_gdk_error_trap_pop(){
  gdk_error_trap_pop();
}

void signal_handler_myobject(GtkWidget *widget, GdkEvent* event, gpointer data){
	gchar edata[255];
	snprintf(edata, 256, "null");
	if ((GdkEventButton*)event){
		snprintf(edata, 256, "%d" , ((GdkEventButton*)event)->button );
	}
	snprintf(ginsbuffer2, 256, "%s", eventTypes[(int)event->type + 1]);
	snprintf(ginsbuffer3, 256, "%s", edata);

	snprintf(ginsbuffer1, 256, "%s", widget);



}

//-- Main Event-handler --
gboolean signal_handler(GtkWidget *widget, GdkEvent* event, gpointer data) {



if (LOCK == 1){
  return;
}

	//char buffer[255];
	if (event==NULL) {
		return FALSE;
	}


    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
//gdk_threads_enter();
	if(bufferfull == 0){
	
		gchar edata[255];

		if (eventTypes[(int)event->type + 1]!="DROP"){

//if( eventTypes[(int)event->type + 1] == "(null)"){
//return TRUE;
//}
snprintf(ginsbuffer2, 256, "%s", eventTypes[(int)event->type + 1]);


			// added by //MU
			snprintf(edata, 256, "null");
			if ((GdkEventButton*)event){
				snprintf(edata, 256, "%d" , ((GdkEventButton*)event)->button );
			}




			snprintf(ginsbuffer1, 256, "%s", glade_get_widget_name(widget));

			if (!strcmp(ginsbuffer1 , "(null)") ){

				snprintf(ginsbuffer1, 256, ":%s", data);
				//  snprintf(ginsbuffer1, 256, "%s", Gtk_widgetname());
			}


			bufferfull = 1;
			snprintf(ginsbuffer3, 256, "%s", edata);

			
	
			//if (!strcmp(ginsbuffer2 , "GDK_3BUTTON_PRESS") ){
			//	return TRUE;
			//}
			if (!strcmp(ginsbuffer2 , "GDK_BUTTON_RELEASE") ){
			//      snprintf(ginsbuffer2, 256, "%s", "BUTTON_PRESS");
				gtk_widget_activate(GTK_WIDGET(widget) ); 
				gdk_flush();
			//	usleep(40000);
			//	return TRUE;
			}

LOCK=0;

		}
	}
	
	if (!strcmp(ginsbuffer2 , "GDK_DELETE") ){
		// must hide here, not in Basic, due to bugs in JWM
		//gdk_flush();
		gtk_widget_hide(GTK_WIDGET(widget) );
		gdk_flush();

		g_static_mutex_unlock (&mutex);
		return TRUE;
	}

	g_static_mutex_unlock (&mutex);
	return FALSE;
}




void wBuiltin_gtk_createobject(){


    static int current_number = 0;
    int ret_val;
    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
    gdk_threads_enter ();
	gchar objecttype[255];
	gchar objectname[255];
	gchar arg0[255];
	gchar arg1[255];

	sprintf(arg1 , "%s" , getstringarg());
	sprintf(arg0 , "%s" , getstringarg());
	sprintf(objectname , "%s" , getstringarg());
	sprintf(objecttype , "%s" , getstringarg());

	gboolean ok = 0;
	gint doconnect = 1;
	 if (!strcmp( objecttype , "GtkButton")) {
        	GO[GOcount].obj = gtk_button_new();
		ok = 1;
	}
	 if (!strcmp( objecttype , "GtkButtonWithLabel")) {
        	GO[GOcount].obj = gtk_button_new_with_label(arg0);
		ok = 1;
		//gtk_drag_dest_add_text_targets(GO[GOcount].obj);  
	}

	 if (!strcmp( objecttype , "GtkLabel")) {
        	GO[GOcount].obj = gtk_label_new(arg0);
		ok = 1;
	}
	 if (!strcmp( objecttype , "GtkTextView")) {
        	GO[GOcount].obj = gtk_text_view_new();
		ok = 1;
 		doconnect = 0;
	}
 	 if (!strcmp( objecttype , "GtkWindow")) {
		if (!strcmp( arg0 , "GTK_WINDOW_POPUP")) {
	        	GO[GOcount].obj = gtk_window_new(GTK_WINDOW_POPUP);
		}else{
	        	GO[GOcount].obj = gtk_window_new(GTK_WINDOW_TOPLEVEL);
		}
		ok = 1;
	}
	 if (!strcmp( objecttype , "GtkHBox")) {
        	GO[GOcount].obj = gtk_hbox_new(atoi(arg0) , atoi(arg1));
		ok = 1;
 		doconnect = 0;
	}
	 if (!strcmp( objecttype , "GtkVBox")) {
        	GO[GOcount].obj = gtk_vbox_new(atoi(arg0) , atoi(arg1));
		ok = 1;
 		doconnect = 0;
	}
	 if (!strcmp( objecttype , "GtkFileFilter")) {
        	GO[GOcount].obj = gtk_file_filter_new ();
		ok = 1;
 		doconnect = 0;
	}
	 if (!strcmp( objecttype , "GtkBasicList")) {

        	GO[GOcount].obj = do_create_lists (arg0, arg1);
		ok = 1;
 		//doconnect = 0;
	}

	 if (!strcmp( objecttype , "FileChooserDialog")) {

		GList *li1 = NULL;
		li1 = findobject(arg0);
	 	if (!strcmp( arg1 , "1")) {

        		GO[GOcount].obj = gtk_file_chooser_dialog_new  ("open file",
 					li1->data,
				        GTK_FILE_CHOOSER_ACTION_OPEN,
				        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				        GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				        NULL);
			ok = 1;
 			doconnect = 0;
		}
	}
	if ( ok == 0){
		gdk_threads_leave ();
		g_static_mutex_unlock (&mutex);
		return;
	}




	sprintf(GO[GOcount].name , "%s" , objectname);
	sprintf(GO[GOcount].type , "%s" , objecttype);

	GTKwidgets = g_list_append(GTKwidgets , GO[GOcount].obj);
	GTKwidgetnames = g_list_append(GTKwidgetnames , GO[GOcount].name);
	GTKwidgettypes = g_list_append(GTKwidgettypes , GO[GOcount].type);


	//g_signal_connect (GO[GOcount].obj, "event", G_CALLBACK (signal_handler), NULL);

if(doconnect == 1){
	g_signal_connect (GO[GOcount].obj, "event", G_CALLBACK (signal_handler), GO[GOcount].name);
}
	GOcount++;

	//printf("created new object: %s of type: %s\n" , objectname, objecttype);

	gdk_threads_leave ();
	g_static_mutex_unlock (&mutex);
	return;
}

void createnewreturnobject(char *objectname , char *objecttype){

	sprintf(GO[GOcount].name , "%s" , objectname);
	sprintf(GO[GOcount].type , "%s" , objecttype);

	GTKwidgets = g_list_append(GTKwidgets , GO[GOcount].obj);
	GTKwidgetnames = g_list_append(GTKwidgetnames , GO[GOcount].name);
	GTKwidgettypes = g_list_append(GTKwidgettypes , GO[GOcount].type);

	g_signal_connect (GO[GOcount].obj, "event", G_CALLBACK (signal_handler), GO[GOcount].name);

	GOcount++;
}
void createnewreturnobjectnosignal(char *objectname , char *objecttype){

	sprintf(GO[GOcount].name , "%s" , objectname);
	sprintf(GO[GOcount].type , "%s" , objecttype);

	GTKwidgets = g_list_append(GTKwidgets , GO[GOcount].obj);
	GTKwidgetnames = g_list_append(GTKwidgetnames , GO[GOcount].name);
	GTKwidgettypes = g_list_append(GTKwidgettypes , GO[GOcount].type);

	GOcount++;
}
void wBuiltin_gtk_setobjectname(){

	gchar objectname[255];
	sprintf(objectname , "%s" , getstringarg());
	sprintf(GO[GOcount-1].name , "%s" , objectname);

}


wBuiltin_g_locale_to_utf8(){

	const gchar *arg0;
	gchar *result;
	wVariant *variant;


	variant = wStackPopString();
    	arg0 = wVariantToChar( variant, W_FALSE, 0 );

    	wVariantDeref( variant );


	//	gsize bytes_written;

	//	result = g_locale_to_utf8(arg0,strlen(arg0),NULL,&bytes_written,NULL);

	result = g_locale_to_utf8(arg0,strlen(arg0),NULL,NULL,NULL);

	//printf("...%d\n" , bytes_written);

	free(arg0);
	returnstring(result);
	//printf("-------%s\n" , result);

}

void wBuiltin_gtk_returntext(){
	// this returns text stored in a gchar pointer by a gtk_function
	gchar arg0[2];

	sprintf(arg0 , "%s" , getstringarg());

	int myindex = atoi(arg0);
        gchar result[255];
        sprintf (result , "%s" , returntext[myindex].text);
        returnstring ( result );
}


void wBuiltin_gtk(){

     int (*gmyold_handler) (Display *, XErrorEvent *);
     gmyold_handler= XSetErrorHandler (gignore_error);

//gdk_flush();
//usleep(100);
    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
//LOCK=1;

gdk_threads_enter();


		//	GList *lix; /* an iterator variable */
		//	int ix=1;
		//	for(lix = GTKwidgetnames; lix != NULL; lix = lix->next){
		//		printf("NAME %d: %s\n", ix , (char *)lix->data);
		//		ix++;
		//	}

	gchar *resultbuffer = "Nothing";
	gchar arg0[1024];
	gchar thefunction[1024];
	gchar result[1024];
	gchar arg1[1024];
	gchar arg2[1024];
	gchar arg3[1024];
	gchar arg4[1024];
	gchar arg5[1024];

	sprintf(arg5 , "%s" , getstringarg());
	sprintf(arg4 , "%s" , getstringarg());
	sprintf(arg3 , "%s" , getstringarg());
	sprintf(arg2 , "%s" , getstringarg());
	sprintf(arg1 , "%s" , getstringarg());
	sprintf(arg0 , "%s" , getstringarg());
	sprintf(thefunction , "%s" , getstringarg());

	GtkWidget *obj;

	int i;
	int n;
	gchar tempobjectname[255];

	GList *li = NULL; /* an iterator variable */
	GtkWidget *TESTobj;

	gchar *objectname;

        GList *li1 = NULL;
        GList *li2 = NULL;
        GList *li3 = NULL;
        GList *li4 = NULL;
        GList *li5 = NULL;

	li1 = findobject(arg1);
	li2 = findobject(arg2);
	li3 = findobject(arg3);
	li4 = findobject(arg4);
	li5 = findobject(arg5);

//--------

objectname = strstr(arg0 , ":");
if(! objectname){
	obj = glade_xml_get_widget(xml, arg0);
//printf("glade: %s\n" , arg0);
}else{

	i = 0;
	for(li = GTKwidgetnames; li != NULL; li = li->next){

        	sprintf(tempobjectname , ":%s", (char *)li->data);
		if (!strcmp(  tempobjectname , objectname )) {
			li = g_list_nth(GTKwidgets , i);
			obj = li->data;
//printf("gtk: %s\n" , objectname);
			break;
		}
		i++;
	}

}


	gdouble arg1double;
	gboolean resultgboolean;
	guint resultguint;
	gdouble resultgdouble;
	gint resultgint;
//-- testfunctions

// for clist
gchar emptytextarray0[0] = "";
gchar emptytextarray1[0] = "";
gchar emptytextarray2[0] = "";
gchar emptytextarray3[0] = "";
gchar emptytextarray4[0] = "";
gchar emptytextarray5[0] = "";







  if (!strcmp( thefunction , "gtk_container_add")) {
	gtk_container_add (GTK_CONTAINER (obj), li1->data);
        returnstring("Nothing");
        gdk_threads_leave();
	g_static_mutex_unlock (&mutex);
	LOCK=0;
	return;
  }

  if (!strcmp( thefunction , "gtk_file_chooser_get_filenames")) {
	GSList* thefilenames = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (obj));
        returnlist(thefilenames);
        gdk_threads_leave();
	g_static_mutex_unlock (&mutex);
	LOCK=0;
	return;
  }


//////////////////////

// here a LOT of GTK functions can be added...

//GiNsTaBlE1StArT
  if (!strcmp( thefunction , "gtk_window_set_title")) {
    gtk_window_set_title(  GTK_WINDOW(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_wmclass")) {
    gtk_window_set_wmclass(  GTK_WINDOW(obj) , arg1  , arg2  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_policy")) {
    gtk_window_set_policy(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_resizable")) {
    gtk_window_set_resizable(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_resizable")) {
    resultgboolean = gtk_window_get_resizable(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_activate_focus")) {
    resultgboolean = gtk_window_activate_focus(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_activate_default")) {
    resultgboolean = gtk_window_activate_default(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_modal")) {
    gtk_window_set_modal(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_default_size")) {
    gtk_window_set_default_size(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_transient_for")) {
    gtk_window_set_transient_for(  GTK_WINDOW(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_destroy_with_parent")) {
    gtk_window_set_destroy_with_parent(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_is_active")) {
    resultgboolean = gtk_window_is_active(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_has_toplevel_focus")) {
    resultgboolean = gtk_window_has_toplevel_focus(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_add_mnemonic")) {
    gtk_window_add_mnemonic(  GTK_WINDOW(obj) , atoi(arg1)  , li2->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_remove_mnemonic")) {
    gtk_window_remove_mnemonic(  GTK_WINDOW(obj) , atoi(arg1)  , li2->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_focus")) {
    GO[GOcount].obj = gtk_window_get_focus(  GTK_WINDOW(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_focus")) {
    gtk_window_set_focus(  GTK_WINDOW(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_default")) {
    gtk_window_set_default(  GTK_WINDOW(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_present")) {
    gtk_window_present(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_present_with_time")) {
    gtk_window_present_with_time(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_iconify")) {
    gtk_window_iconify(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_deiconify")) {
    gtk_window_deiconify(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_stick")) {
    gtk_window_stick(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_unstick")) {
    gtk_window_unstick(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_maximize")) {
    gtk_window_maximize(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_unmaximize")) {
    gtk_window_unmaximize(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_fullscreen")) {
    gtk_window_fullscreen(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_unfullscreen")) {
    gtk_window_unfullscreen(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_keep_above")) {
    gtk_window_set_keep_above(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_keep_below")) {
    gtk_window_set_keep_below(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_begin_move_drag")) {
    gtk_window_begin_move_drag(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_decorated")) {
    gtk_window_set_decorated(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_frame_dimensions")) {
    gtk_window_set_frame_dimensions(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_has_frame")) {
    gtk_window_set_has_frame(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_role")) {
    gtk_window_set_role(  GTK_WINDOW(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_skip_taskbar_hint")) {
    gtk_window_set_skip_taskbar_hint(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_skip_pager_hint")) {
    gtk_window_set_skip_pager_hint(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_urgency_hint")) {
    gtk_window_set_urgency_hint(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_accept_focus")) {
    gtk_window_set_accept_focus(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_focus_on_map")) {
    gtk_window_set_focus_on_map(  GTK_WINDOW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_decorated")) {
    resultgboolean = gtk_window_get_decorated(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_default_size")) {
    gtk_window_get_default_size(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_destroy_with_parent")) {
    resultgboolean = gtk_window_get_destroy_with_parent(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_frame_dimensions")) {
    gtk_window_get_frame_dimensions(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_has_frame")) {
    resultgboolean = gtk_window_get_has_frame(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_icon_name")) {
    resultbuffer = gtk_window_get_icon_name(  GTK_WINDOW(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_modal")) {
    resultgboolean = gtk_window_get_modal(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_position")) {
    gtk_window_get_position(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_role")) {
    resultbuffer = gtk_window_get_role(  GTK_WINDOW(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_size")) {
    gtk_window_get_size(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_title")) {
    resultbuffer = gtk_window_get_title(  GTK_WINDOW(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_transient_for")) {
    GO[GOcount].obj = gtk_window_get_transient_for(  GTK_WINDOW(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWindow");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_skip_taskbar_hint")) {
    resultgboolean = gtk_window_get_skip_taskbar_hint(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_skip_pager_hint")) {
    resultgboolean = gtk_window_get_skip_pager_hint(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_urgency_hint")) {
    resultgboolean = gtk_window_get_urgency_hint(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_accept_focus")) {
    resultgboolean = gtk_window_get_accept_focus(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_get_focus_on_map")) {
    resultgboolean = gtk_window_get_focus_on_map(  GTK_WINDOW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_move")) {
    gtk_window_move(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_parse_geometry")) {
    resultgboolean = gtk_window_parse_geometry(  GTK_WINDOW(obj) , arg1  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_reshow_with_initial_size")) {
    gtk_window_reshow_with_initial_size(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_resize")) {
    gtk_window_resize(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_default_icon")) {
    gtk_window_set_default_icon(  GDK_PIXBUF(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_default_icon_name")) {
    gtk_window_set_default_icon_name(  arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_icon_name")) {
    gtk_window_set_icon_name(  GTK_WINDOW(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_window_set_auto_startup_notification")) {
    gtk_window_set_auto_startup_notification(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_decorated_window_init")) {
    gtk_decorated_window_init(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_decorated_window_calculate_frame_size")) {
    gtk_decorated_window_calculate_frame_size(  GTK_WINDOW(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_decorated_window_set_title")) {
    gtk_decorated_window_set_title(  GTK_WINDOW(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_decorated_window_move_resize_window")) {
    gtk_decorated_window_move_resize_window(  GTK_WINDOW(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_set_locale")) {
    resultbuffer = gtk_set_locale(  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_disable_setlocale")) {
    gtk_disable_setlocale(  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_events_pending")) {
    resultgboolean = gtk_events_pending(  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_main_quit")) {
    gtk_main_quit(  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_main_iteration")) {
    resultgboolean = gtk_main_iteration(  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_main_iteration_do")) {
    resultgboolean = gtk_main_iteration_do(  atoi(arg0)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_grab_add")) {
    gtk_grab_add(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_grab_get_current")) {
    GO[GOcount].obj = gtk_grab_get_current(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_grab_remove")) {
    gtk_grab_remove(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_quit_remove")) {
    gtk_quit_remove(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_quit_remove_by_data")) {
    gtk_quit_remove_by_data(   arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_timeout_remove")) {
    gtk_timeout_remove(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_idle_remove")) {
    gtk_idle_remove(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_idle_remove_by_data")) {
    gtk_idle_remove_by_data(   arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_input_remove")) {
    gtk_input_remove(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_key_snooper_remove")) {
    gtk_key_snooper_remove(  atoi(arg0)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_accel_group_lock")) {
    gtk_accel_group_lock(  GTK_ACCEL_GROUP(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_accel_group_unlock")) {
    gtk_accel_group_unlock(  GTK_ACCEL_GROUP(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_set_search_path")) {
    gtk_icon_theme_set_search_path(  GTK_ICON_THEME(obj) , arg1  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_get_search_path")) {
    gtk_icon_theme_get_search_path(  GTK_ICON_THEME(obj) ,  &returntext[1].text  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_append_search_path")) {
    gtk_icon_theme_append_search_path(  GTK_ICON_THEME(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_prepend_search_path")) {
    gtk_icon_theme_prepend_search_path(  GTK_ICON_THEME(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_set_custom_theme")) {
    gtk_icon_theme_set_custom_theme(  GTK_ICON_THEME(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_has_icon")) {
    resultgboolean = gtk_icon_theme_has_icon(  GTK_ICON_THEME(obj) , arg1  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_icon_theme_rescan_if_needed")) {
    resultgboolean = gtk_icon_theme_rescan_if_needed(  GTK_ICON_THEME(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_clear")) {
    gtk_clipboard_clear(  GTK_CLIPBOARD(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_set_text")) {
    gtk_clipboard_set_text(  GTK_CLIPBOARD(obj) , arg1  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_wait_for_text")) {
    resultbuffer = gtk_clipboard_wait_for_text(  GTK_CLIPBOARD(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_wait_is_text_available")) {
    resultgboolean = gtk_clipboard_wait_is_text_available(  GTK_CLIPBOARD(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_wait_is_image_available")) {
    resultgboolean = gtk_clipboard_wait_is_image_available(  GTK_CLIPBOARD(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clipboard_store")) {
    gtk_clipboard_store(  GTK_CLIPBOARD(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_add_widget_name_style")) {
    gtk_rc_add_widget_name_style(  GTK_RC_STYLE(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_add_widget_class_style")) {
    gtk_rc_add_widget_class_style(  GTK_RC_STYLE(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_add_class_style")) {
    gtk_rc_add_class_style(  GTK_RC_STYLE(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_parse")) {
    gtk_rc_parse(  arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_parse_string")) {
    gtk_rc_parse_string(  arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_reparse_all")) {
    resultgboolean = gtk_rc_reparse_all(  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_reparse_all_for_settings")) {
    resultgboolean = gtk_rc_reparse_all_for_settings(  GTK_SETTINGS(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_reset_styles")) {
    gtk_rc_reset_styles(  GTK_SETTINGS(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_add_default_file")) {
    gtk_rc_add_default_file(  arg0  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_set_default_files")) {
    gtk_rc_set_default_files(   &returntext[0].text  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_find_module_in_path")) {
    resultbuffer = gtk_rc_find_module_in_path(  arg0  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_find_pixmap_in_path")) {
    resultbuffer = gtk_rc_find_pixmap_in_path(  GTK_SETTINGS(obj) , arg1  , arg2  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_get_module_dir")) {
    resultbuffer = gtk_rc_get_module_dir(  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_get_im_module_path")) {
    resultbuffer = gtk_rc_get_im_module_path(  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_get_im_module_file")) {
    resultbuffer = gtk_rc_get_im_module_file(  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_get_theme_dir")) {
    resultbuffer = gtk_rc_get_theme_dir(  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_style_ref")) {
    gtk_rc_style_ref(  GTK_RC_STYLE(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_rc_style_unref")) {
    gtk_rc_style_unref(  GTK_RC_STYLE(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_check_version")) {
    resultbuffer = gtk_check_version(  atoi(arg0)  , atoi(arg1)  , atoi(arg2)  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_new")) {
    GO[GOcount].obj = gtk_label_new(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_text")) {
    gtk_label_set_text(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_markup")) {
    gtk_label_set_markup(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_markup_with_mnemonic")) {
    gtk_label_set_markup_with_mnemonic(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_pattern")) {
    gtk_label_set_pattern(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_width_chars")) {
    gtk_label_set_width_chars(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_max_width_chars")) {
    gtk_label_set_max_width_chars(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get")) {
    gtk_label_get(  GTK_LABEL(obj) ,  &returntext[1].text  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_line_wrap")) {
    gtk_label_set_line_wrap(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_layout_offsets")) {
    gtk_label_get_layout_offsets(  GTK_LABEL(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_selectable")) {
    resultgboolean = gtk_label_get_selectable(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_text")) {
    resultbuffer = gtk_label_get_text(  GTK_LABEL(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_new_with_mnemonic")) {
    GO[GOcount].obj = gtk_label_new_with_mnemonic(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_select_region")) {
    gtk_label_select_region(  GTK_LABEL(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_mnemonic_widget")) {
    gtk_label_set_mnemonic_widget(  GTK_LABEL(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_selectable")) {
    gtk_label_set_selectable(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_text_with_mnemonic")) {
    gtk_label_set_text_with_mnemonic(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_width_chars")) {
    resultgint = gtk_label_get_width_chars(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_max_width_chars")) {
    resultgint = gtk_label_get_max_width_chars(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_label")) {
    resultbuffer = gtk_label_get_label(  GTK_LABEL(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_line_wrap")) {
    resultgboolean = gtk_label_get_line_wrap(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_mnemonic_widget")) {
    GO[GOcount].obj = gtk_label_get_mnemonic_widget(  GTK_LABEL(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_selection_bounds")) {
    resultgboolean = gtk_label_get_selection_bounds(  GTK_LABEL(obj) , atoi(arg1)  , atoi(arg2)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_use_markup")) {
    resultgboolean = gtk_label_get_use_markup(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_use_underline")) {
    resultgboolean = gtk_label_get_use_underline(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_single_line_mode")) {
    resultgboolean = gtk_label_get_single_line_mode(  GTK_LABEL(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_get_angle")) {
    resultgdouble = gtk_label_get_angle(  GTK_LABEL(obj) );
    sprintf(result , "%f" , resultgdouble);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_label")) {
    gtk_label_set_label(  GTK_LABEL(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_use_markup")) {
    gtk_label_set_use_markup(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_use_underline")) {
    gtk_label_set_use_underline(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_single_line_mode")) {
    gtk_label_set_single_line_mode(  GTK_LABEL(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_label_set_angle")) {
    gtk_label_set_angle(  GTK_LABEL(obj) , atof(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_new")) {
    GO[GOcount].obj = gtk_button_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_new_with_label")) {
    GO[GOcount].obj = gtk_button_new_with_label(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_new_with_mnemonic")) {
    GO[GOcount].obj = gtk_button_new_with_mnemonic(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_new_from_stock")) {
    GO[GOcount].obj = gtk_button_new_from_stock(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_pressed")) {
    gtk_button_pressed(  GTK_BUTTON(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_released")) {
    gtk_button_released(  GTK_BUTTON(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_clicked")) {
    gtk_button_clicked(  GTK_BUTTON(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_enter")) {
    gtk_button_enter(  GTK_BUTTON(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_leave")) {
    gtk_button_leave(  GTK_BUTTON(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_label")) {
    resultbuffer = gtk_button_get_label(  GTK_BUTTON(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_label")) {
    gtk_button_set_label(  GTK_BUTTON(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_use_stock")) {
    resultgboolean = gtk_button_get_use_stock(  GTK_BUTTON(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_use_stock")) {
    gtk_button_set_use_stock(  GTK_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_use_underline")) {
    resultgboolean = gtk_button_get_use_underline(  GTK_BUTTON(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_use_underline")) {
    gtk_button_set_use_underline(  GTK_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_focus_on_click")) {
    gtk_button_set_focus_on_click(  GTK_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_focus_on_click")) {
    resultgboolean = gtk_button_get_focus_on_click(  GTK_BUTTON(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_alignment")) {
    gtk_button_set_alignment(  GTK_BUTTON(obj) , atof(arg1)  , atof(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_alignment")) {
    gtk_button_get_alignment(  GTK_BUTTON(obj) , arg1  , arg2  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_set_image")) {
    gtk_button_set_image(  GTK_BUTTON(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_button_get_image")) {
    GO[GOcount].obj = gtk_button_get_image(  GTK_BUTTON(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_local_only")) {
    gtk_file_chooser_set_local_only(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_local_only")) {
    resultgboolean = gtk_file_chooser_get_local_only(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_select_multiple")) {
    gtk_file_chooser_set_select_multiple(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_select_multiple")) {
    resultgboolean = gtk_file_chooser_get_select_multiple(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_show_hidden")) {
    gtk_file_chooser_set_show_hidden(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_show_hidden")) {
    resultgboolean = gtk_file_chooser_get_show_hidden(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_do_overwrite_confirmation")) {
    gtk_file_chooser_set_do_overwrite_confirmation(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_do_overwrite_confirmation")) {
    resultgboolean = gtk_file_chooser_get_do_overwrite_confirmation(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_current_name")) {
    gtk_file_chooser_set_current_name(  GTK_FILE_CHOOSER(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_filename")) {
    resultbuffer = gtk_file_chooser_get_filename(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_select_all")) {
    gtk_file_chooser_select_all(  GTK_FILE_CHOOSER(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_unselect_all")) {
    gtk_file_chooser_unselect_all(  GTK_FILE_CHOOSER(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_current_folder")) {
    resultgboolean = gtk_file_chooser_set_current_folder(  GTK_FILE_CHOOSER(obj) , arg1  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_current_folder")) {
    resultbuffer = gtk_file_chooser_get_current_folder(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_uri")) {
    resultbuffer = gtk_file_chooser_get_uri(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_current_folder_uri")) {
    resultgboolean = gtk_file_chooser_set_current_folder_uri(  GTK_FILE_CHOOSER(obj) , arg1  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_current_folder_uri")) {
    resultbuffer = gtk_file_chooser_get_current_folder_uri(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_preview_widget")) {
    gtk_file_chooser_set_preview_widget(  GTK_FILE_CHOOSER(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_preview_widget")) {
    GO[GOcount].obj = gtk_file_chooser_get_preview_widget(  GTK_FILE_CHOOSER(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_preview_widget_active")) {
    gtk_file_chooser_set_preview_widget_active(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_preview_widget_active")) {
    resultgboolean = gtk_file_chooser_get_preview_widget_active(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_use_preview_label")) {
    gtk_file_chooser_set_use_preview_label(  GTK_FILE_CHOOSER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_use_preview_label")) {
    resultgboolean = gtk_file_chooser_get_use_preview_label(  GTK_FILE_CHOOSER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_extra_widget")) {
    gtk_file_chooser_set_extra_widget(  GTK_FILE_CHOOSER(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_extra_widget")) {
    GO[GOcount].obj = gtk_file_chooser_get_extra_widget(  GTK_FILE_CHOOSER(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_add_filter")) {
    gtk_file_chooser_add_filter(  GTK_FILE_CHOOSER(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_remove_filter")) {
    gtk_file_chooser_remove_filter(  GTK_FILE_CHOOSER(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_set_filter")) {
    gtk_file_chooser_set_filter(  GTK_FILE_CHOOSER(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_get_filter")) {
    GO[GOcount].obj = gtk_file_chooser_get_filter(  GTK_FILE_CHOOSER(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkFileFilter");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_button_new_with_dialog")) {
    GO[GOcount].obj = gtk_file_chooser_button_new_with_dialog(  GTK_WIDGET(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_button_get_title")) {
    resultbuffer = gtk_file_chooser_button_get_title(  GTK_FILE_CHOOSER_BUTTON(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_button_set_title")) {
    gtk_file_chooser_button_set_title(  GTK_FILE_CHOOSER_BUTTON(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_button_get_width_chars")) {
    resultgint = gtk_file_chooser_button_get_width_chars(  GTK_FILE_CHOOSER_BUTTON(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_chooser_button_set_width_chars")) {
    gtk_file_chooser_button_set_width_chars(  GTK_FILE_CHOOSER_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_new")) {
    GO[GOcount].obj = gtk_file_selection_new(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_set_filename")) {
    gtk_file_selection_set_filename(  GTK_FILE_SELECTION(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_get_filename")) {
    resultbuffer = gtk_file_selection_get_filename(  GTK_FILE_SELECTION(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_complete")) {
    gtk_file_selection_complete(  GTK_FILE_SELECTION(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_show_fileop_buttons")) {
    gtk_file_selection_show_fileop_buttons(  GTK_FILE_SELECTION(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_hide_fileop_buttons")) {
    gtk_file_selection_hide_fileop_buttons(  GTK_FILE_SELECTION(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_set_select_multiple")) {
    gtk_file_selection_set_select_multiple(  GTK_FILE_SELECTION(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_selection_get_select_multiple")) {
    resultgboolean = gtk_file_selection_get_select_multiple(  GTK_FILE_SELECTION(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_new")) {
    GO[GOcount].obj = gtk_color_button_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_set_alpha")) {
    gtk_color_button_set_alpha(  GTK_COLOR_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_set_use_alpha")) {
    gtk_color_button_set_use_alpha(  GTK_COLOR_BUTTON(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_get_use_alpha")) {
    resultgboolean = gtk_color_button_get_use_alpha(  GTK_COLOR_BUTTON(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_set_title")) {
    gtk_color_button_set_title(  GTK_COLOR_BUTTON(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_color_button_get_title")) {
    resultbuffer = gtk_color_button_get_title(  GTK_COLOR_BUTTON(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_new")) {
    GO[GOcount].obj = gtk_text_buffer_new(  GTK_TEXT_TAG_TABLE(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkTextBuffer");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_line_count")) {
    resultgint = gtk_text_buffer_get_line_count(  GTK_TEXT_BUFFER(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_char_count")) {
    resultgint = gtk_text_buffer_get_char_count(  GTK_TEXT_BUFFER(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert")) {
    gtk_text_buffer_insert(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , arg2  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert_at_cursor")) {
    gtk_text_buffer_insert_at_cursor(  GTK_TEXT_BUFFER(obj) , arg1  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert_interactive")) {
    resultgboolean = gtk_text_buffer_insert_interactive(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , arg2  , atoi(arg3)  , atoi(arg4)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert_interactive_at_cursor")) {
    resultgboolean = gtk_text_buffer_insert_interactive_at_cursor(  GTK_TEXT_BUFFER(obj) , arg1  , atoi(arg2)  , atoi(arg3)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert_range")) {
    gtk_text_buffer_insert_range(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  ,  &TextIters[ atoi(arg3) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_insert_range_interactive")) {
    resultgboolean = gtk_text_buffer_insert_range_interactive(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  ,  &TextIters[ atoi(arg3) ].Iter  , atoi(arg4)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_delete")) {
    gtk_text_buffer_delete(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_delete_interactive")) {
    resultgboolean = gtk_text_buffer_delete_interactive(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  , atoi(arg3)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_backspace")) {
    resultgboolean = gtk_text_buffer_backspace(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_set_text")) {
    gtk_text_buffer_set_text(  GTK_TEXT_BUFFER(obj) , arg1  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_text")) {
    resultbuffer = gtk_text_buffer_get_text(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  , atoi(arg3)  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_slice")) {
    resultbuffer = gtk_text_buffer_get_slice(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  , atoi(arg3)  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_move_mark_by_name")) {
    gtk_text_buffer_move_mark_by_name(  GTK_TEXT_BUFFER(obj) , arg1  ,  &TextIters[ atoi(arg2) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_delete_mark_by_name")) {
    gtk_text_buffer_delete_mark_by_name(  GTK_TEXT_BUFFER(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_place_cursor")) {
    gtk_text_buffer_place_cursor(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_select_range")) {
    gtk_text_buffer_select_range(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_apply_tag_by_name")) {
    gtk_text_buffer_apply_tag_by_name(  GTK_TEXT_BUFFER(obj) , arg1  ,  &TextIters[ atoi(arg2) ].Iter  ,  &TextIters[ atoi(arg3) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_remove_tag_by_name")) {
    gtk_text_buffer_remove_tag_by_name(  GTK_TEXT_BUFFER(obj) , arg1  ,  &TextIters[ atoi(arg2) ].Iter  ,  &TextIters[ atoi(arg3) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_remove_all_tags")) {
    gtk_text_buffer_remove_all_tags(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_iter_at_line_offset")) {
    gtk_text_buffer_get_iter_at_line_offset(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_iter_at_offset")) {
    gtk_text_buffer_get_iter_at_offset(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_iter_at_line")) {
    gtk_text_buffer_get_iter_at_line(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_iter_at_line_index")) {
    gtk_text_buffer_get_iter_at_line_index(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_start_iter")) {
    gtk_text_buffer_get_start_iter(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_end_iter")) {
    gtk_text_buffer_get_end_iter(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_bounds")) {
    gtk_text_buffer_get_bounds(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_modified")) {
    resultgboolean = gtk_text_buffer_get_modified(  GTK_TEXT_BUFFER(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_set_modified")) {
    gtk_text_buffer_set_modified(  GTK_TEXT_BUFFER(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_delete_selection")) {
    resultgboolean = gtk_text_buffer_delete_selection(  GTK_TEXT_BUFFER(obj) , atoi(arg1)  , atoi(arg2)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_get_selection_bounds")) {
    resultgboolean = gtk_text_buffer_get_selection_bounds(  GTK_TEXT_BUFFER(obj) ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_begin_user_action")) {
    gtk_text_buffer_begin_user_action(  GTK_TEXT_BUFFER(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_buffer_end_user_action")) {
    gtk_text_buffer_end_user_action(  GTK_TEXT_BUFFER(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_buffer")) {
    GO[GOcount].obj = gtk_text_iter_get_buffer(   &TextIters[ atoi(arg0) ].Iter  );
  createnewreturnobject("NEWOBJECT" , "GtkTextBuffer");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_free")) {
    gtk_text_iter_free(   &TextIters[ atoi(arg0) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_offset")) {
    resultgint = gtk_text_iter_get_offset(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_line")) {
    resultgint = gtk_text_iter_get_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_line_offset")) {
    resultgint = gtk_text_iter_get_line_offset(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_line_index")) {
    resultgint = gtk_text_iter_get_line_index(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_visible_line_index")) {
    resultgint = gtk_text_iter_get_visible_line_index(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_visible_line_offset")) {
    resultgint = gtk_text_iter_get_visible_line_offset(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_slice")) {
    resultbuffer = gtk_text_iter_get_slice(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_text")) {
    resultbuffer = gtk_text_iter_get_text(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_visible_slice")) {
    resultbuffer = gtk_text_iter_get_visible_slice(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_visible_text")) {
    resultbuffer = gtk_text_iter_get_visible_text(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_editable")) {
    resultgboolean = gtk_text_iter_editable(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_can_insert")) {
    resultgboolean = gtk_text_iter_can_insert(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_starts_word")) {
    resultgboolean = gtk_text_iter_starts_word(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_ends_word")) {
    resultgboolean = gtk_text_iter_ends_word(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_inside_word")) {
    resultgboolean = gtk_text_iter_inside_word(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_starts_line")) {
    resultgboolean = gtk_text_iter_starts_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_ends_line")) {
    resultgboolean = gtk_text_iter_ends_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_starts_sentence")) {
    resultgboolean = gtk_text_iter_starts_sentence(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_ends_sentence")) {
    resultgboolean = gtk_text_iter_ends_sentence(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_inside_sentence")) {
    resultgboolean = gtk_text_iter_inside_sentence(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_is_cursor_position")) {
    resultgboolean = gtk_text_iter_is_cursor_position(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_chars_in_line")) {
    resultgint = gtk_text_iter_get_chars_in_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_get_bytes_in_line")) {
    resultgint = gtk_text_iter_get_bytes_in_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_is_end")) {
    resultgboolean = gtk_text_iter_is_end(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_is_start")) {
    resultgboolean = gtk_text_iter_is_start(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_char")) {
    resultgboolean = gtk_text_iter_forward_char(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_char")) {
    resultgboolean = gtk_text_iter_backward_char(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_chars")) {
    resultgboolean = gtk_text_iter_forward_chars(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_chars")) {
    resultgboolean = gtk_text_iter_backward_chars(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_line")) {
    resultgboolean = gtk_text_iter_forward_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_line")) {
    resultgboolean = gtk_text_iter_backward_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_lines")) {
    resultgboolean = gtk_text_iter_forward_lines(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_lines")) {
    resultgboolean = gtk_text_iter_backward_lines(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_word_ends")) {
    resultgboolean = gtk_text_iter_forward_word_ends(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_word_starts")) {
    resultgboolean = gtk_text_iter_backward_word_starts(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_word_end")) {
    resultgboolean = gtk_text_iter_forward_word_end(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_word_start")) {
    resultgboolean = gtk_text_iter_backward_word_start(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_cursor_position")) {
    resultgboolean = gtk_text_iter_forward_cursor_position(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_cursor_position")) {
    resultgboolean = gtk_text_iter_backward_cursor_position(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_cursor_positions")) {
    resultgboolean = gtk_text_iter_forward_cursor_positions(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_cursor_positions")) {
    resultgboolean = gtk_text_iter_backward_cursor_positions(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_sentence_start")) {
    resultgboolean = gtk_text_iter_backward_sentence_start(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_sentence_starts")) {
    resultgboolean = gtk_text_iter_backward_sentence_starts(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_sentence_end")) {
    resultgboolean = gtk_text_iter_forward_sentence_end(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_sentence_ends")) {
    resultgboolean = gtk_text_iter_forward_sentence_ends(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_word_ends")) {
    resultgboolean = gtk_text_iter_forward_visible_word_ends(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_word_starts")) {
    resultgboolean = gtk_text_iter_backward_visible_word_starts(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_word_end")) {
    resultgboolean = gtk_text_iter_forward_visible_word_end(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_word_start")) {
    resultgboolean = gtk_text_iter_backward_visible_word_start(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_cursor_position")) {
    resultgboolean = gtk_text_iter_forward_visible_cursor_position(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_cursor_position")) {
    resultgboolean = gtk_text_iter_backward_visible_cursor_position(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_cursor_positions")) {
    resultgboolean = gtk_text_iter_forward_visible_cursor_positions(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_cursor_positions")) {
    resultgboolean = gtk_text_iter_backward_visible_cursor_positions(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_line")) {
    resultgboolean = gtk_text_iter_forward_visible_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_line")) {
    resultgboolean = gtk_text_iter_backward_visible_line(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_visible_lines")) {
    resultgboolean = gtk_text_iter_forward_visible_lines(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_backward_visible_lines")) {
    resultgboolean = gtk_text_iter_backward_visible_lines(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_offset")) {
    gtk_text_iter_set_offset(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_line")) {
    gtk_text_iter_set_line(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_line_offset")) {
    gtk_text_iter_set_line_offset(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_line_index")) {
    gtk_text_iter_set_line_index(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_visible_line_index")) {
    gtk_text_iter_set_visible_line_index(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_set_visible_line_offset")) {
    gtk_text_iter_set_visible_line_offset(   &TextIters[ atoi(arg0) ].Iter  , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_to_end")) {
    gtk_text_iter_forward_to_end(   &TextIters[ atoi(arg0) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_forward_to_line_end")) {
    resultgboolean = gtk_text_iter_forward_to_line_end(   &TextIters[ atoi(arg0) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_equal")) {
    resultgboolean = gtk_text_iter_equal(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_compare")) {
    resultgint = gtk_text_iter_compare(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_in_range")) {
    resultgboolean = gtk_text_iter_in_range(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  ,  &TextIters[ atoi(arg2) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_iter_order")) {
    gtk_text_iter_order(   &TextIters[ atoi(arg0) ].Iter  ,  &TextIters[ atoi(arg1) ].Iter  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_new")) {
    GO[GOcount].obj = gtk_text_view_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_new_with_buffer")) {
    GO[GOcount].obj = gtk_text_view_new_with_buffer(  GTK_TEXT_BUFFER(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_buffer")) {
    gtk_text_view_set_buffer(  GTK_TEXT_VIEW(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_buffer")) {
    GO[GOcount].obj = gtk_text_view_get_buffer(  GTK_TEXT_VIEW(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkTextBuffer");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_scroll_to_iter")) {
    resultgboolean = gtk_text_view_scroll_to_iter(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atof(arg2)  , atoi(arg3)  , atof(arg4)  , atof(arg5)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_place_cursor_onscreen")) {
    resultgboolean = gtk_text_view_place_cursor_onscreen(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_line_at_y")) {
    gtk_text_view_get_line_at_y(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_line_yrange")) {
    gtk_text_view_get_line_yrange(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_iter_at_location")) {
    gtk_text_view_get_iter_at_location(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_iter_at_position")) {
    gtk_text_view_get_iter_at_position(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_forward_display_line")) {
    resultgboolean = gtk_text_view_forward_display_line(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_backward_display_line")) {
    resultgboolean = gtk_text_view_backward_display_line(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_forward_display_line_end")) {
    resultgboolean = gtk_text_view_forward_display_line_end(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_backward_display_line_start")) {
    resultgboolean = gtk_text_view_backward_display_line_start(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_starts_display_line")) {
    resultgboolean = gtk_text_view_starts_display_line(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_move_visually")) {
    resultgboolean = gtk_text_view_move_visually(  GTK_TEXT_VIEW(obj) ,  &TextIters[ atoi(arg1) ].Iter  , atoi(arg2)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_child_anchor_get_deleted")) {
    resultgboolean = gtk_text_child_anchor_get_deleted(  GTK_TEXT_CHILD_ANCHOR(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_move_child")) {
    gtk_text_view_move_child(  GTK_TEXT_VIEW(obj) , li1->data  , atoi(arg2)  , atoi(arg3)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_editable")) {
    gtk_text_view_set_editable(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_editable")) {
    resultgboolean = gtk_text_view_get_editable(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_cursor_visible")) {
    gtk_text_view_set_cursor_visible(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_cursor_visible")) {
    resultgboolean = gtk_text_view_get_cursor_visible(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_overwrite")) {
    gtk_text_view_set_overwrite(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_overwrite")) {
    resultgboolean = gtk_text_view_get_overwrite(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_pixels_above_lines")) {
    gtk_text_view_set_pixels_above_lines(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_pixels_above_lines")) {
    resultgint = gtk_text_view_get_pixels_above_lines(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_pixels_below_lines")) {
    gtk_text_view_set_pixels_below_lines(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_pixels_below_lines")) {
    resultgint = gtk_text_view_get_pixels_below_lines(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_pixels_inside_wrap")) {
    gtk_text_view_set_pixels_inside_wrap(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_pixels_inside_wrap")) {
    resultgint = gtk_text_view_get_pixels_inside_wrap(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_left_margin")) {
    gtk_text_view_set_left_margin(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_left_margin")) {
    resultgint = gtk_text_view_get_left_margin(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_right_margin")) {
    gtk_text_view_set_right_margin(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_right_margin")) {
    resultgint = gtk_text_view_get_right_margin(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_indent")) {
    gtk_text_view_set_indent(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_indent")) {
    resultgint = gtk_text_view_get_indent(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_set_accepts_tab")) {
    gtk_text_view_set_accepts_tab(  GTK_TEXT_VIEW(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_text_view_get_accepts_tab")) {
    resultgboolean = gtk_text_view_get_accepts_tab(  GTK_TEXT_VIEW(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_new")) {
    GO[GOcount].obj = gtk_entry_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_new_with_max_length")) {
    GO[GOcount].obj = gtk_entry_new_with_max_length(  atoi(arg0)  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_text")) {
    gtk_entry_set_text(  GTK_ENTRY(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_append_text")) {
    gtk_entry_append_text(  GTK_ENTRY(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_prepend_text")) {
    gtk_entry_prepend_text(  GTK_ENTRY(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_position")) {
    gtk_entry_set_position(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_text")) {
    resultbuffer = gtk_entry_get_text(  GTK_ENTRY(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_select_region")) {
    gtk_entry_select_region(  GTK_ENTRY(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_visibility")) {
    gtk_entry_set_visibility(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_invisible_char")) {
    gtk_entry_set_invisible_char(  GTK_ENTRY(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_editable")) {
    gtk_entry_set_editable(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_max_length")) {
    gtk_entry_set_max_length(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_activates_default")) {
    resultgboolean = gtk_entry_get_activates_default(  GTK_ENTRY(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_has_frame")) {
    resultgboolean = gtk_entry_get_has_frame(  GTK_ENTRY(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_width_chars")) {
    resultgint = gtk_entry_get_width_chars(  GTK_ENTRY(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_activates_default")) {
    gtk_entry_set_activates_default(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_has_frame")) {
    gtk_entry_set_has_frame(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_width_chars")) {
    gtk_entry_set_width_chars(  GTK_ENTRY(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_alignment")) {
    gtk_entry_set_alignment(  GTK_ENTRY(obj) , atof(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_layout_offsets")) {
    gtk_entry_get_layout_offsets(  GTK_ENTRY(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_layout_index_to_text_index")) {
    resultgint = gtk_entry_layout_index_to_text_index(  GTK_ENTRY(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_text_index_to_layout_index")) {
    resultgint = gtk_entry_text_index_to_layout_index(  GTK_ENTRY(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_max_length")) {
    resultgint = gtk_entry_get_max_length(  GTK_ENTRY(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_get_visibility")) {
    resultgboolean = gtk_entry_get_visibility(  GTK_ENTRY(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_entry_set_completion")) {
    gtk_entry_set_completion(  GTK_ENTRY(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_pack_start")) {
    gtk_box_pack_start(  GTK_BOX(obj) , li1->data  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_pack_end")) {
    gtk_box_pack_end(  GTK_BOX(obj) , li1->data  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_pack_start_defaults")) {
    gtk_box_pack_start_defaults(  GTK_BOX(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_pack_end_defaults")) {
    gtk_box_pack_end_defaults(  GTK_BOX(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_get_homogeneous")) {
    resultgboolean = gtk_box_get_homogeneous(  GTK_BOX(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_set_homogeneous")) {
    gtk_box_set_homogeneous(  GTK_BOX(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_get_spacing")) {
    resultgint = gtk_box_get_spacing(  GTK_BOX(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_set_spacing")) {
    gtk_box_set_spacing(  GTK_BOX(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_box_reorder_child")) {
    gtk_box_reorder_child(  GTK_BOX(obj) , li1->data  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_ref")) {
    GO[GOcount].obj = gtk_widget_ref(  GTK_WIDGET(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_unref")) {
    gtk_widget_unref(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_destroy")) {
    gtk_widget_destroy(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_destroyed")) {
    gtk_widget_destroyed(  GTK_WIDGET(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_unparent")) {
    gtk_widget_unparent(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_show")) {
    gtk_widget_show(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_show_now")) {
    gtk_widget_show_now(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_hide")) {
    gtk_widget_hide(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_show_all")) {
    gtk_widget_show_all(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_hide_all")) {
    gtk_widget_hide_all(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_map")) {
    gtk_widget_map(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_unmap")) {
    gtk_widget_unmap(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_realize")) {
    gtk_widget_realize(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_unrealize")) {
    gtk_widget_unrealize(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_draw")) {
    gtk_widget_queue_draw(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_resize")) {
    gtk_widget_queue_resize(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_resize_no_redraw")) {
    gtk_widget_queue_resize_no_redraw(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_can_activate_accel")) {
    resultgboolean = gtk_widget_can_activate_accel(  GTK_WIDGET(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_activate")) {
    resultgboolean = gtk_widget_activate(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_reparent")) {
    gtk_widget_reparent(  GTK_WIDGET(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_is_focus")) {
    resultgboolean = gtk_widget_is_focus(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_grab_focus")) {
    gtk_widget_grab_focus(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_grab_default")) {
    gtk_widget_grab_default(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_name")) {
    gtk_widget_set_name(  GTK_WIDGET(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_name")) {
    resultbuffer = gtk_widget_get_name(  GTK_WIDGET(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_sensitive")) {
    gtk_widget_set_sensitive(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_parent")) {
    gtk_widget_set_parent(  GTK_WIDGET(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_uposition")) {
    gtk_widget_set_uposition(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_usize")) {
    gtk_widget_set_usize(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_events")) {
    gtk_widget_set_events(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_add_events")) {
    gtk_widget_add_events(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_toplevel")) {
    GO[GOcount].obj = gtk_widget_get_toplevel(  GTK_WIDGET(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_events")) {
    resultgint = gtk_widget_get_events(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_pointer")) {
    gtk_widget_get_pointer(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_is_ancestor")) {
    resultgboolean = gtk_widget_is_ancestor(  GTK_WIDGET(obj) , li1->data  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_translate_coordinates")) {
    resultgboolean = gtk_widget_translate_coordinates(  GTK_WIDGET(obj) , li1->data  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  , atoi(arg5)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_hide_on_delete")) {
    resultgboolean = gtk_widget_hide_on_delete(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_ensure_style")) {
    gtk_widget_ensure_style(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_reset_rc_styles")) {
    gtk_widget_reset_rc_styles(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_push_colormap")) {
    gtk_widget_push_colormap(  GDK_COLORMAP(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_pop_colormap")) {
    gtk_widget_pop_colormap(  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_default_colormap")) {
    gtk_widget_set_default_colormap(  GDK_COLORMAP(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_path")) {
    gtk_widget_path(  GTK_WIDGET(obj) , atoi(arg1)  ,  &returntext[2].text  ,  &returntext[3].text  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_class_path")) {
    gtk_widget_class_path(  GTK_WIDGET(obj) , atoi(arg1)  ,  &returntext[2].text  ,  &returntext[3].text  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_composite_name")) {
    resultbuffer = gtk_widget_get_composite_name(  GTK_WIDGET(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_pop_composite_child")) {
    gtk_widget_pop_composite_child(  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_push_composite_child")) {
    gtk_widget_push_composite_child(  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_clear")) {
    gtk_widget_queue_clear(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_clear_area")) {
    gtk_widget_queue_clear_area(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_queue_draw_area")) {
    gtk_widget_queue_draw_area(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_reset_shapes")) {
    gtk_widget_reset_shapes(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_app_paintable")) {
    gtk_widget_set_app_paintable(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_double_buffered")) {
    gtk_widget_set_double_buffered(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_redraw_on_allocate")) {
    gtk_widget_set_redraw_on_allocate(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_composite_name")) {
    gtk_widget_set_composite_name(  GTK_WIDGET(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_mnemonic_activate")) {
    resultgboolean = gtk_widget_mnemonic_activate(  GTK_WIDGET(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_child_notify")) {
    gtk_widget_child_notify(  GTK_WIDGET(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_freeze_child_notify")) {
    gtk_widget_freeze_child_notify(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_child_visible")) {
    resultgboolean = gtk_widget_get_child_visible(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_parent")) {
    GO[GOcount].obj = gtk_widget_get_parent(  GTK_WIDGET(obj) );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_has_screen")) {
    resultgboolean = gtk_widget_has_screen(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_size_request")) {
    gtk_widget_get_size_request(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_child_visible")) {
    gtk_widget_set_child_visible(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_size_request")) {
    gtk_widget_set_size_request(  GTK_WIDGET(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_thaw_child_notify")) {
    gtk_widget_thaw_child_notify(  GTK_WIDGET(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_set_no_show_all")) {
    gtk_widget_set_no_show_all(  GTK_WIDGET(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_get_no_show_all")) {
    resultgboolean = gtk_widget_get_no_show_all(  GTK_WIDGET(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_add_mnemonic_label")) {
    gtk_widget_add_mnemonic_label(  GTK_WIDGET(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_widget_remove_mnemonic_label")) {
    gtk_widget_remove_mnemonic_label(  GTK_WIDGET(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_new")) {
    GO[GOcount].obj = gtk_dialog_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_run")) {
    resultgint = gtk_dialog_run(  GTK_DIALOG(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_response")) {
    gtk_dialog_response(  GTK_DIALOG(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_add_button")) {
    GO[GOcount].obj = gtk_dialog_add_button(  GTK_DIALOG(obj) , arg1  , atoi(arg2)  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_add_action_widget")) {
    gtk_dialog_add_action_widget(  GTK_DIALOG(obj) , li1->data  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_get_has_separator")) {
    resultgboolean = gtk_dialog_get_has_separator(  GTK_DIALOG(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_set_default_response")) {
    gtk_dialog_set_default_response(  GTK_DIALOG(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_set_has_separator")) {
    gtk_dialog_set_has_separator(  GTK_DIALOG(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_set_response_sensitive")) {
    gtk_dialog_set_response_sensitive(  GTK_DIALOG(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_get_response_for_widget")) {
    resultgint = gtk_dialog_get_response_for_widget(  GTK_DIALOG(obj) , li1->data  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_alternative_dialog_button_order")) {
    resultgboolean = gtk_alternative_dialog_button_order(  GDK_SCREEN(obj) );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_dialog_set_alternative_button_order_from_array")) {
    gtk_dialog_set_alternative_button_order_from_array(  GTK_DIALOG(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_check_button_new")) {
    GO[GOcount].obj = gtk_check_button_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_check_button_new_with_label")) {
    GO[GOcount].obj = gtk_check_button_new_with_label(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_check_button_new_with_mnemonic")) {
    GO[GOcount].obj = gtk_check_button_new_with_mnemonic(  arg0  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_new")) {
    GO[GOcount].obj = gtk_file_filter_new(  );
  createnewreturnobject("NEWOBJECT" , "GtkFileFilter");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_set_name")) {
    gtk_file_filter_set_name(  GTK_FILE_FILTER(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_get_name")) {
    resultbuffer = gtk_file_filter_get_name(  GTK_FILE_FILTER(obj) );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_add_mime_type")) {
    gtk_file_filter_add_mime_type(  GTK_FILE_FILTER(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_add_pattern")) {
    gtk_file_filter_add_pattern(  GTK_FILE_FILTER(obj) , arg1  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_add_pixbuf_formats")) {
    gtk_file_filter_add_pixbuf_formats(  GTK_FILE_FILTER(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_file_filter_filter")) {
    resultgboolean = gtk_file_filter_filter(  GTK_FILE_FILTER(obj) , li1->data  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_new")) {
    GO[GOcount].obj = gtk_clist_new(  atoi(arg0)  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_new_with_titles")) {
    GO[GOcount].obj = gtk_clist_new_with_titles(  atoi(arg0)  , arg1  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_freeze")) {
    gtk_clist_freeze(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_thaw")) {
    gtk_clist_thaw(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_titles_show")) {
    gtk_clist_column_titles_show(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_titles_hide")) {
    gtk_clist_column_titles_hide(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_title_active")) {
    gtk_clist_column_title_active(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_title_passive")) {
    gtk_clist_column_title_passive(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_titles_active")) {
    gtk_clist_column_titles_active(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_column_titles_passive")) {
    gtk_clist_column_titles_passive(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_title")) {
    gtk_clist_set_column_title(  GTK_CLIST(obj) , atoi(arg1)  , arg2  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_widget")) {
    gtk_clist_set_column_widget(  GTK_CLIST(obj) , atoi(arg1)  , li2->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_visibility")) {
    gtk_clist_set_column_visibility(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_resizeable")) {
    gtk_clist_set_column_resizeable(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_auto_resize")) {
    gtk_clist_set_column_auto_resize(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_optimal_column_width")) {
    resultgint = gtk_clist_optimal_column_width(  GTK_CLIST(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_width")) {
    gtk_clist_set_column_width(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_min_width")) {
    gtk_clist_set_column_min_width(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_column_max_width")) {
    gtk_clist_set_column_max_width(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_row_height")) {
    gtk_clist_set_row_height(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_moveto")) {
    gtk_clist_moveto(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  , atof(arg3)  , atof(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_text")) {
    gtk_clist_set_text(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  , arg3  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_get_text")) {
    resultgint = gtk_clist_get_text(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  ,  &returntext[3].text  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_shift")) {
    gtk_clist_set_shift(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_selectable")) {
    gtk_clist_set_selectable(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_get_selectable")) {
    resultgboolean = gtk_clist_get_selectable(  GTK_CLIST(obj) , atoi(arg1)  );
    sprintf(result , "%d" , resultgboolean);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_prepend")) {
    resultgint = gtk_clist_prepend(  GTK_CLIST(obj) ,  emptytextarray1  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_append")) {
    resultgint = gtk_clist_append(  GTK_CLIST(obj) ,  emptytextarray1  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_insert")) {
    resultgint = gtk_clist_insert(  GTK_CLIST(obj) , atoi(arg1)  ,  emptytextarray2  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_remove")) {
    gtk_clist_remove(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_row_data")) {
    gtk_clist_set_row_data(  GTK_CLIST(obj) , atoi(arg1)  ,  arg2  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_find_row_from_data")) {
    resultgint = gtk_clist_find_row_from_data(  GTK_CLIST(obj) ,  arg1  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_select_row")) {
    gtk_clist_select_row(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_unselect_row")) {
    gtk_clist_unselect_row(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_undo_selection")) {
    gtk_clist_undo_selection(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_clear")) {
    gtk_clist_clear(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_get_selection_info")) {
    resultgint = gtk_clist_get_selection_info(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  , atoi(arg3)  , atoi(arg4)  );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_select_all")) {
    gtk_clist_select_all(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_unselect_all")) {
    gtk_clist_unselect_all(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_swap_rows")) {
    gtk_clist_swap_rows(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_compare_func")) {
    gtk_clist_set_compare_func(  GTK_CLIST(obj) , li1->data  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_sort_column")) {
    gtk_clist_set_sort_column(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_sort")) {
    gtk_clist_sort(  GTK_CLIST(obj) );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_auto_sort")) {
    gtk_clist_set_auto_sort(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_columns_autosize")) {
    resultgint = gtk_clist_columns_autosize(  GTK_CLIST(obj) );
    sprintf(result , "%d" , resultgint);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_get_column_title")) {
    resultbuffer = gtk_clist_get_column_title(  GTK_CLIST(obj) , atoi(arg1)  );
    sprintf(result , "%s" , resultbuffer);
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_get_column_widget")) {
    GO[GOcount].obj = gtk_clist_get_column_widget(  GTK_CLIST(obj) , atoi(arg1)  );
  createnewreturnobject("NEWOBJECT" , "GtkWidget");
    sprintf( result , "Nothing");
    returnstring(result);
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_row_move")) {
    gtk_clist_row_move(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_button_actions")) {
    gtk_clist_set_button_actions(  GTK_CLIST(obj) , atoi(arg1)  , atoi(arg2)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_reorderable")) {
    gtk_clist_set_reorderable(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
  if (!strcmp( thefunction , "gtk_clist_set_use_drag_icons")) {
    gtk_clist_set_use_drag_icons(  GTK_CLIST(obj) , atoi(arg1)  );
    returnstring("Nothing");
    gdk_threads_leave();LOCK=0;
    g_static_mutex_unlock (&mutex);
    return;
  }
gdk_threads_leave();
//GiNsTaBlE1EnD

gdk_flush();LOCK=0;

g_static_mutex_unlock (&mutex);
	returnstring("Nothing");
	free(resultbuffer);
	return;
}


void wBuiltin_gins_glade(){

gdk_threads_enter();

	char *thefile;
	wVariant *variant;
	variant = wStackPopString();
    	thefile = wVariantToChar( variant, W_FALSE, 0 );
	loadXMLFile(thefile);
	wVariantDeref( variant );
gdk_threads_leave();
}
void wBuiltin_gins_set(){

 //   LOCK = 1;
    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
gdk_threads_enter ();
	gint intval;
	gboolean bvalue = TRUE;
	gdouble doubleValue;
	GtkWidget *obj;

	char *wstring;

	char objid[255];
	char name[255];
	char value[255];
	char type[255];

	wVariant *variant;

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(type , "%s" , wstring);

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(value , "%s" , wstring);

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(name , "%s" , wstring);

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(objid , "%s" , wstring);

	wVariantDeref( variant );
	free(wstring);

	obj = glade_xml_get_widget(xml, objid);

//  g_thread_init (NULL);
//  gdk_threads_init ();
//gdk_flush();
//gdk_threads_enter ();
//  gdk_error_trap_push();



	if (strncmp(type,"<uposition>", 5)==0) {
		intval = atoi(value); 
		gint intval2 = atoi(name);
	       	gtk_widget_set_uposition(obj, intval2,intval );
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}

	if (strncmp(type,"<int>", 5)==0) {
		intval = atoi(value); 
		
		g_object_set (obj,name, intval, NULL);
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	if (strncmp(type,"<str>", 5)==0) {
		g_object_set (obj,name, &value, NULL);
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	if (strncmp(type,"<boolean>", 5)==0) {
		if (strncmp(value,"FALSE",5)==0) {
			bvalue = FALSE;
		}
		g_object_set (obj,name, bvalue, NULL);
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	if (strncmp(type,"<bool>", 5)==0) {
		if (strncmp(value,"FALSE",5)==0) {
			bvalue = FALSE;
		}
		g_object_set (obj,name, bvalue, NULL);
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	if (strncmp(type,"<double>", 5)==0) {
		doubleValue = strtod(value, NULL); 
		g_object_set (obj,name, doubleValue , NULL);
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
}

void wBuiltin_gins_get(){
//LOCK=1;

    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
//gdk_threads_enter ();
	gint intval;
	gboolean bvalue = TRUE;
	gdouble doubleValue;
	GtkWidget *obj;

	gdouble dval;
	gboolean bval;
	char bvalstr[255] = "TRUE";
	char *wstring;

	char objid[255];
	char name[255];
	char type[255];
	gchar *value;
	char buffer[300];
	wVariant *variant;

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(type , "%s" , wstring);

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(name , "%s" , wstring);

	variant = wStackPopString();
    	wstring = wVariantToChar( variant, W_FALSE, 0 );
	sprintf(objid , "%s" , wstring);

	wVariantDeref( variant );
	free(wstring);

	obj = glade_xml_get_widget(xml, objid);

	if (obj == NULL) {
		printf("[gins] ERROR INVALID_OBJID\n");
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}

	if (strncmp(type,"<str>", 5)==0) {
		g_object_get (obj,name, &value, NULL);
		snprintf(buffer, 299, "%s", value);

		g_free(value);

        	wVariant *myvariant;

		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );

           	//-- create a string
           	wVariantFromChar( myvariant, buffer ,4,4 );

    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}

	if (strncmp(type,"<double>", 5)==0) {
		g_object_get (obj,name, &dval, NULL);
		
		snprintf(buffer, 299, "%f", dval);

        	wVariant *myvariant;

		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );

           	//-- create a string
           	wVariantFromChar( myvariant, buffer ,4,4 );

    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	
	if (strncmp(type,"<boolean>", 5)==0) {
		g_object_get (obj,name, &bval, NULL);
		if (! bval) { 
			bvalstr[0] = 'F';
			bvalstr[1] = 'A';
			bvalstr[2] = 'L';
			bvalstr[3] = 'S';
			bvalstr[4] = 'E';
			
		}
		snprintf(buffer, 299, "%s", &bvalstr);

        	wVariant *myvariant;

		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );

           	//-- create a string
           	wVariantFromChar( myvariant, buffer ,4,4 );

    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
	
	
	if (strncmp(type,"<int>", 5)==0) {
		g_object_get (obj,name, &intval, NULL);
		
		snprintf(buffer, 299, "%i", intval);

        	wVariant *myvariant;

		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );

           	//-- create a string
           	wVariantFromChar( myvariant, buffer ,4,4 );

    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
		return;
	}
//gdk_threads_leave ();
LOCK=0;
g_static_mutex_unlock (&mutex);
}
  

void wBuiltin_gins_event(){
//LOCK=1;
	if(bufferfull==1){

        	wVariant *myvariant;

		myvariant = (wVariant *)wMalloc( sizeof( wVariant ) );

           	//-- create a string
           	wVariantFromChar( myvariant, ginsbuffer1 ,4,4 );
    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

           	//-- create a string
           	wVariantFromChar( myvariant, ginsbuffer2 ,4,4 );
    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );

           	//-- create a string
           	wVariantFromChar( myvariant, ginsbuffer3 ,4,4 );
    		//-- return it to wxBasic
    		wVariantMove( wStackPushNothing(), myvariant );
   		//-- cleanup
    		wVariantDeref( myvariant );
    		wFree(myvariant);

		bufferfull = 0;
	}
//LOCK=0;
}


void connections(GladeXML *xml){
	/*connect all widgets event*/
	GList* allwidgets=NULL;
	GtkWidget *widget;
	
	allwidgets = glade_xml_get_widget_prefix(xml, "");
	
	while (allwidgets != NULL) {
		g_signal_connect (G_OBJECT (allwidgets->data), "event", G_CALLBACK (signal_handler), NULL);
		allwidgets = allwidgets->next;
	}
	
	g_list_free(allwidgets);

}


int loadXMLFile(char *file){
	//printf("---%s\n" , file);
	removeNL(file);
//gdk_threads_enter();
	/* load the interface */
	xml = glade_xml_new(file, NULL, NULL);
//gdk_threads_leave();
	if (xml==NULL) return -1;
	connections(xml);
	return 0;
}


void wBuiltin_gins_exit(){
//LOCK == 1;
    static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    g_static_mutex_lock (&mutex);
gdk_threads_enter ();
        gdk_flush();
	gtk_main_quit();
gdk_threads_leave ();
//LOCK=0;
g_static_mutex_unlock (&mutex);
}





void wBuiltin_gins_usleep()
{
    int microseconds;
   // sscanf(argv[1], "%d", &microseconds);
microseconds = wStackPopNumber();
//    printf("%d\n" , microseconds);

#ifdef _WIN32
    sleep(microseconds/1000);
#else

    usleep(microseconds);
#endif
}


#ifdef _WIN32
void *mywinthread(){

printf("\n--starting new thread--\n");

	gtk_main();
}

#include <windows.h>
#include <winbase.h>
#include <process.h>
typedef unsigned (__stdcall *PTHREAD_START) (void *);

void wBuiltin_gins_main(){

unsigned long threadId;
//HANDLE hThread = CreateThread(NULL, 2000, (LPTHREAD_START_ROUTINE)mywinthread, 0, CREATE_SUSPENDED, &threadId);


unsigned threadID;
HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, (PTHREAD_START) mywinthread, 0, 0, &threadID);

}
#else



void *mythread(void *ch){
     // avoid badwindow-errors
     int (*gmyold_handler) (Display *, XErrorEvent *);
     gmyold_handler= XSetErrorHandler (gignore_error);

gdk_threads_enter();
	gtk_main();
gdk_threads_leave();

//wBuiltin_gins_exit();
}

void wBuiltin_gins_main(){
//gdk_threads_enter();
//  while (gtk_events_pending ()){

//	  gtk_main_iteration();

//}
//gdk_threads_leave();

//usleep(5000000);
//return;

     // avoid badwindow-errors
     int (*gmyold_handler) (Display *, XErrorEvent *);
     gmyold_handler= XSetErrorHandler (gignore_error);


  //gdk_threads_enter ();
	char ch1='-';
	pthread_t p1;
	pthread_create (&p1, NULL, mythread, &ch1);

//gdk_threads_leave ();

}


#endif