/*************************************************************
 * Some include files and defines
 *************************************************************/

%{
#include "mzgtk2-gtk-correct.h"
#include <gtk/gtk.h>
#include "mzgtk2.h"
#include <gtk/gtkgl.h>
#include "mzgtk2-table-model.h"
#include "gtkdyn.h"
%}

#define G_GNUC_CONST	const
#define G_CONST_RETURN	const
#define G_GNUC_NULL_TERMINATED
#define G_GNUC_PRINTF(a,b)
#define mzgtk2_is_not_owner const

/*************************************************************
 * Some general macros
 *************************************************************/


%define mzgtk2_catch(pred,T)
     if (!(pred)) {
       scheme_wrong_type(FUNC_NAME,T,$argnum-1,argc,argv);
     }
%enddef

%{
#define SCHEME_GOBJECTP(obj) mzgtk2_is_scheme_gobject(obj)
#define scheme_make_gobject(p) mzgtk2_make_scheme_gobject(p,(1==0),FUNC_NAME)
#define scheme_make_gobject_is_first_owner(p) mzgtk2_make_scheme_gobject(p,(1==1),FUNC_NAME)
%}

/*************************************************************
 * Macro definition for types to be wrapped as GtkWidget.
 *************************************************************/

%define mzgtk2_gobject(T)

%typemap(in) T * {
  $1=(T *) mzgtk2_gobject_convert($input,FUNC_NAME,$argnum-1,argc,argv);
}

%typemap(out) T * {
  $result=scheme_make_gobject($1);
}

%{
typedef T  mzgtk2_is_first_owner_ ## T;
%}

%typemap(out)  mzgtk2_is_first_owner_ ## T *  {
  $result=scheme_make_gobject_is_first_owner($1);
}

%enddef

/*************************************************************
 * Macro definition for types to be wrapped as mzgtk2_type.
 *************************************************************/

%define mzgtk2_mzgtk2_type(T,is_type,type_name,finalizer)

%typemap(in) T * {
  $1=(T *) mzgtk2_mzgtk2_type_convert($input,is_type,FUNC_NAME,$argnum-1,argc,argv);
}

%typemap(out) T * {
  $result=mzgtk2_make_mzgtk2_type_with_finalizer($1,type_name(),finalizer);
}

%enddef

/*************************************************************
 * mzgtk2_type related wrappers
 *************************************************************/

mzgtk2_mzgtk2_type(GdkColor,mzgtk2_is_gdkcolor,mzgtk2_gdkcolor_name,NULL);
mzgtk2_mzgtk2_type(GtkTextIter,mzgtk2_is_gtktextiter,mzgtk2_gtktextiter_name,NULL);
mzgtk2_mzgtk2_type(PangoFontDescription,mzgtk2_is_gtkfont,mzgtk2_gtkfont_name,mzgtk2_gtkfont_finalizer);

/*************************************************************
 * GtkWidget related wrappers
 *************************************************************/

mzgtk2_gobject(GObject);
mzgtk2_gobject(GtkObject);

mzgtk2_gobject(GtkWidget);

mzgtk2_gobject(GtkWindow);
mzgtk2_gobject(GtkDialog);

mzgtk2_gobject(GtkLabel);
mzgtk2_gobject(GtkImage);
mzgtk2_gobject(GtkEditable);
mzgtk2_gobject(GtkEntry);
mzgtk2_gobject(GtkCalendar);
mzgtk2_gobject(GtkProgressBar);
mzgtk2_gobject(GtkSpinButton);
mzgtk2_gobject(GtkAdjustment);
mzgtk2_gobject(GtkAlignment);
mzgtk2_gobject(GtkStatusbar);

mzgtk2_gobject(GtkContainer);
mzgtk2_gobject(GtkBox);
mzgtk2_gobject(GtkBin);
mzgtk2_gobject(GtkNotebook);
mzgtk2_gobject(GtkExpander);
mzgtk2_gobject(GtkHandleBox);
mzgtk2_gobject(GtkScrolledWindow);
mzgtk2_gobject(GtkViewport);
mzgtk2_gobject(GtkLayout);

mzgtk2_gobject(GtkTable);

mzgtk2_gobject(GtkTooltips);

mzgtk2_gobject(GtkButton);
mzgtk2_gobject(GtkRadioButton);
mzgtk2_gobject(GtkCheckButton);
mzgtk2_gobject(GtkToggleButton);
mzgtk2_gobject(GtkColorButton);
mzgtk2_gobject(GtkFontButton);

mzgtk2_gobject(GtkMenu);
mzgtk2_gobject(GtkMenuBar);
mzgtk2_gobject(GtkMenuShell);
mzgtk2_gobject(GtkMenuItem);
mzgtk2_gobject(GtkCheckMenuItem);

mzgtk2_gobject(GtkMisc);
mzgtk2_gobject(GtkFrame);
mzgtk2_gobject(GtkComboBox);
mzgtk2_gobject(GtkComboBoxEntry);
mzgtk2_gobject(GtkCellLayout);

mzgtk2_gobject(GtkTreeModel);
mzgtk2_gobject(mzgtk2_table_t); 
mzgtk2_gobject(GtkTreeView);
mzgtk2_gobject(GtkTreeViewColumn);

mzgtk2_gobject(GtkCellRenderer);

mzgtk2_gobject(GdkPixbuf);
mzgtk2_gobject(GdkPixbufAnimation);
mzgtk2_gobject(GdkDrawable);
mzgtk2_gobject(GdkGC);
mzgtk2_gobject(GdkWindow);

mzgtk2_gobject(GdkDragContext);
mzgtk2_gobject(GdkDisplay);
mzgtk2_gobject(GdkScreen);

mzgtk2_gobject(GtkColorSelection);
mzgtk2_gobject(GtkFontSelection);
mzgtk2_gobject(GtkFileChooser);
mzgtk2_gobject(GtkFileFilter);
mzgtk2_gobject(GtkAboutDialog);
mzgtk2_gobject(GtkMessageDialog);

mzgtk2_gobject(GtkRange);
mzgtk2_gobject(GtkScale);
mzgtk2_gobject(GtkHScale);
mzgtk2_gobject(GtkVScale);

mzgtk2_gobject(GtkPaned);
mzgtk2_gobject(GtkHPaned);
mzgtk2_gobject(GtkVPaned);

mzgtk2_gobject(GtkHSeparator);
mzgtk2_gobject(GtkVSeparator);

mzgtk2_gobject(GtkTextBuffer);
mzgtk2_gobject(GtkTextTagTable);
mzgtk2_gobject(GtkTextView);
mzgtk2_gobject(GtkTextTag);
mzgtk2_gobject(GtkTextMark);

/* gtkglext */

mzgtk2_gobject(GdkGLConfig);
mzgtk2_gobject(GdkGLContext);
mzgtk2_gobject(GdkGLWindow);
mzgtk2_gobject(GdkGLDrawable);
mzgtk2_gobject(GdkGLPixmap);

mzgtk2_gobject(GtkClipboard);

mzgtk2_gobject(GtkAccelGroup);

mzgtk2_gobject(GtkSizeGroup);

/* pango/cairo */

mzgtk2_gobject(PangoLayout);
mzgtk2_gobject(PangoContext);

/* toolbar */

mzgtk2_gobject(GtkToolbar);
mzgtk2_gobject(GtkToolItem);
mzgtk2_gobject(GtkSeparatorToolItem);
mzgtk2_gobject(GtkToolButton);
mzgtk2_gobject(GtkMenuToolButton);
mzgtk2_gobject(GtkToggleToolButton);
mzgtk2_gobject(GtkRadioToolButton);

/*************************************************************
 * Other types
 *************************************************************/

/***!!! gchar * needs special attention ***/

/* Strategy: 
 *
 * C<const gchar *>
 *
 * We assume we can safely copy all C<const gchar *> 
 * types, because as parameter C<const gchar *> can
 * only be assumed valid within the context of the called
 * C function. So we don't copy the scheme string, because
 * we expect the C function to copy <const gchar *> arguments
 * to it's own address space, or only use the provided
 * string as long as the C function endures. As a result, 
 * C<const gchar *> must always be copied to the Scheme 
 * address space. Because it will point to the address space
 * of the calle.
 *
 * C<gchar *>
 *
 * Needs special attention. Each function taking a C<gchar *>
 * or returning a C<gchar *> needs to be examined.
*/

%typemap(in) const gchar * {
  $1=mzgtk2_const_gchar_convert($input,FUNC_NAME,$argnum-1,argc,argv);
}

%typemap(out) const gchar * {
  // typemap const char *
  if ($1==NULL) {
    $result=scheme_make_utf8_string("");
  }
  else {
    $result=scheme_make_utf8_string($1);
  }
}

%typemap(in) const gchar ** {
  $1=mzgtk2_const_gchar_array_convert($input,FUNC_NAME,$argnum-1,argc,argv);
}

%typemap(out) const gchar ** {
  $result=mzgtk2_const_gchar_make_array($1,FUNC_NAME);
}

%typemap(out) gchar * const * {
  $result=mzgtk2_const_gchar_make_array($1,FUNC_NAME);
}

%typemap(out) G_CONST_RETURN gchar* G_CONST_RETURN * {
  $result=mzgtk2_const_gchar_make_array($1,FUNC_NAME);
}

%typemap(out) gchar * {
  if ($1==NULL) {
    $result=scheme_make_utf8_string("");
    /*$result=scheme_false;*/
  }
  else {
    $result=scheme_make_utf8_string($1);
    GTKCALL(g_free,($1));
  }
}

/* typemap(out) const gchar **? */

%typemap(in) gboolean {
  mzgtk2_catch(SCHEME_BOOLP($input),"boolean");
  if (SCHEME_FALSEP($input)) {
    $1=(gboolean) 0;
  }
  else {
    $1=(gboolean) 1;
  }
}

%typemap(out) gboolean {
  if ($1) {
    $result=scheme_true;
  }
  else {
    $result=scheme_false;
  }
}

%define gtk2simple(PRED,CONV,CONVB,T,ST)
  %typemap(in) T {
    mzgtk2_catch(PRED($input),ST);
    $1=CONV($input);
  }
  %typemap(out) T {
    $result=CONVB($1);
  }
%enddef
    
gtk2simple(SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,gint,"integer");
gtk2simple(SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,int,"integer");
gtk2simple(SCHEME_GDBLP,SCHEME_GDBL_VAL,scheme_make_double,gfloat,"double");
gtk2simple(SCHEME_GDBLP,SCHEME_GDBL_VAL,scheme_make_double,gdouble,"double");
gtk2simple(SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,gint16,"gint16");
gtk2simple(SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,gint32,"gint32");
gtk2simple(SCHEME_GUINTP,SCHEME_GUINT_VAL,scheme_make_integer_value_from_unsigned,guint,"unsigned integer");
gtk2simple(SCHEME_GUINTP,SCHEME_GUINT_VAL,scheme_make_integer_value_from_unsigned,guint16,"unsigned integer");

%typemap(out) GtkTreeIter * {
  if ($1) {
    $result=mzgtk2_make_iter($1);
  }
}

%typemap(in) GtkTreeIter * {
  mzgtk2_catch(mzgtk2_is_iter($input),"GtkTreeIter*");
  $1=mzgtk2_get_iter($input);
}

/********* GtkTreePath *************************/

%typemap(in) GtkTreePath * {
  $1=mzgtk2_scm2tree_path($input,FUNC_NAME);
}

%typemap(argout) GtkTreePath * {
  values[0]=mzgtk2_make_tree_path($1);
}

%typemap(out) GtkTreePath * {
  if ($1) {
    $result=mzgtk2_make_tree_path($1);
    GTKCALL(gtk_tree_path_free,($1));
  }
  else {
    $result=scheme_false;
  }
}

%typemap(freearg) GtkTreePath * {
  GTKCALL(gtk_tree_path_free,($1));
}

/*************************************************************
 * Pointer types (possible output types)
 *************************************************************/

%define mzgtk2_inout(T,PREP,MZ_C,C_MZ,TYPENAME)

%typemap(in) T * {
  if (SCHEME_BOXP($input)) {
    mzgtk2_catch(PREP(SCHEME_BOX_VAL($input)),TYPENAME);
    *$1=MZ_C(SCHEME_BOX_VAL($input));
  }
  else if (SCHEME_LISTP($input)) {
    int N=scheme_list_length($input);
    if (N==0) {
      $1=NULL;
    }
    else {
      $1=(T *) scheme_malloc(sizeof(T)*N);
      {
	int i;
	Scheme_Object *L;
	for(i=0,L=$input;i<N;i++,L=scheme_cdr(L)) {
	  Scheme_Object *obj=scheme_car(L);
	  $1[i]=MZ_C(obj);
	}
      }
    }
  }
  else if (SCHEME_VECTORP($input)) {
    int N=SCHEME_VEC_SIZE($input);
    $1=(T *) scheme_malloc(sizeof(T)*N);
    {
      int i;
      Scheme_Object **V=SCHEME_VEC_ELS($input);
      for(i=0;i<N;i++) {
	$1[i]=MZ_C(V[i]);
      }
    }
  }
  else {
    mzgtk2_catch(PREP($input),TYPENAME);
    *$1=MZ_C($input);
  }
}

%typemap(argout) T * {
  if ($argnum==(argc+1)) {
    values[0]=C_MZ(*$1);
  }
  else if ($argnum>argc) {
    if ($argnum==(argc+2)) {
      Scheme_Object *obj=values[0],*nobj=C_MZ(*$1);
      values[0]=scheme_build_list(1,&obj);
    }
    { 
      Scheme_Object *obj=C_MZ(*$1);
      values[0]=scheme_append(values[0],scheme_build_list(1,&obj));
    }
  }
  else if (SCHEME_BOXP(argv[$argnum-1])) {
    Scheme_Object *obj=C_MZ(*$1);
    scheme_set_box(argv[$argnum-1],obj);
  }
}

%typemap(arginit) T * {
  $1=(T *) scheme_malloc(sizeof(T));
}

%typemap(out) T * {
  $result=C_MZ(*$1);
}

%enddef

/*** Primitive types */

mzgtk2_inout(gint,SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,"integer|double|bignum|(box integer)");
mzgtk2_inout(int,SCHEME_GINTP,SCHEME_GINT_VAL,scheme_make_integer,"integer|double|bignum|(box integer)");
mzgtk2_inout(guint,SCHEME_GUINTP,SCHEME_GUINT_VAL,scheme_make_integer_value_from_unsigned,"integer|double|bignum|(box unsigned integer)");
mzgtk2_inout(gfloat,SCHEME_GDBLP,SCHEME_GDBL_VAL,scheme_make_double,"inexact number|integer|bignum|(box inexact number)");
mzgtk2_inout(gdouble,SCHEME_GDBLP,SCHEME_GDBL_VAL,scheme_make_double,"inexact number|integer|bignum|(box inexact number)");
mzgtk2_inout(gboolean,SCHEME_BOOLP,mzgtk2_bool_val,mzgtk2_make_bool,"gboolean |(box gboolean)");

/*** Gdk Types */

mzgtk2_inout(GdkRectangle,mzgtk2_is_gdkrectangle,mzgtk2_gdkrectangle_val,mzgtk2_make_gdkrectangle,"(list x y width height)");
mzgtk2_inout(GtkAllocation,mzgtk2_is_gtkallocation,mzgtk2_gtkallocation_val,mzgtk2_make_gtkallocation,"(list x y width height)");
mzgtk2_inout(GdkPoint,mzgtk2_is_gdkpoint,mzgtk2_gdkpoint_val,mzgtk2_make_gdkpoint,"(list x y)");
mzgtk2_inout(GdkSegment,mzgtk2_is_gdksegment,mzgtk2_gdksegment_val,mzgtk2_make_gdksegment,"(list x1 y1 x2 y2)");
mzgtk2_inout(GtkTargetEntry,mzgtk2_is_gtktargetentry,mzgtk2_gtktargetentry_val,mzgtk2_make_gtktargetentry,"GtkTargetEntry");

/*************************************************************
 * PangoFontDescription wrapping
 *************************************************************/

/*
%typemap(in) PangoFontDescription * {
  $1=mzgtk2_pangofontdescription_convert($input,FUNC_NAME,$argnum-1,argc,argv);
}

%typemap(freearg) PangoFontDescription * {
  
  pango_font_description_free($1);
}

%typemap(out) PangoFontDescription * {
  $result=mzgtk2_make_gtkfont($1);
}
*/

/*************************************************************
 * GList wrapping
 *************************************************************/

%define mzgtk2_glist_with_free_of_glist_only(T,PREP,MZ_C,C_MZ,TYPENAME)

%{
#define T GList
%}
     
%typemap(in) T * {
  mzgtk2_catch(SCHEME_LISTP($input),TYPENAME);
  $1=NULL;
  {
    int i,N=scheme_list_length($input);
    Scheme_Object *obj,*list=$input;
    for(i=0;i<N;i++) {
      obj=scheme_car(list);
      list=scheme_cdr(list);
      mzgtk2_catch(PREP(obj),TYPENAME);
      $1=GTKCALL(g_list_append,($1,MZ_C(obj)));
    }
  }
}

%typemap(out) T * {
  {
    int i,N=GTKCALL(g_list_length,($1));
    Scheme_Object **objs=scheme_malloc(sizeof(Scheme_Object *)*N);
    GList *L=$1;
    for(i=0;i<N;i++) {
      objs[i]=C_MZ(GTKCALL(g_list_nth_data,(L,0)));
      L=GTKCALL(g_list_next,(L));
    }
    GTKCALL(g_list_free,(L));
    $result=scheme_build_list(N,objs);
  }
}
     
%enddef

mzgtk2_glist_with_free_of_glist_only(GListGtkWidget,SCHEME_GOBJECTP,SCHEME_CPTR_VAL,scheme_make_gobject,"(list GObject*)");

/*************************************************************
 * GSList wrapping  (Single Linked List)
 *************************************************************/

%define mzgtk2_gslist_with_free_of_glist_only(T,PREP,MZ_C,C_MZ,TYPENAME)

%{
#define T GSList
%}
     
%typemap(in) T * {
  mzgtk2_catch(SCHEME_LISTP($input),TYPENAME);
  $1=NULL;
  {
    int i,N=scheme_list_length($input);
    Scheme_Object *obj,*list=$input;
    for(i=0;i<N;i++) {
      obj=scheme_car(list);
      list=scheme_cdr(list);
      mzgtk2_catch(PREP(obj),TYPENAME);
      $1=GTKCALL(g_slist_append,($1,MZ_C(obj)));
    }
  }
}

%typemap(out) T * {
  {
    int i,N=GTKCALL(g_slist_length,($1));
    Scheme_Object **objs=scheme_malloc(sizeof(Scheme_Object *)*N);
    GSList *L=$1;
    for(i=0;i<N;i++) {
      objs[i]=C_MZ(GTKCALL(g_slist_nth_data,(L,0)));
      /*L=GTKCALL(g_slist_next,(L));*/
      L=g_slist_next(L);
    }
    GTKCALL(g_slist_free,(L));
    $result=scheme_build_list(N,objs);
  }
}
     
%enddef

mzgtk2_gslist_with_free_of_glist_only(GSListGtkTextTag,SCHEME_GOBJECTP,SCHEME_CPTR_VAL,scheme_make_gobject,"(list GtkTextTag*)");
mzgtk2_gslist_with_free_of_glist_only(GSListGtkTextMark,SCHEME_GOBJECTP,SCHEME_CPTR_VAL,scheme_make_gobject,"(list GtkTextMark*)");

/*************************************************************
 * CAIRO BINDING
 *************************************************************/

%define cairo_ref_typemap(T,TString,DEREF_FUNC)

%{
  static Scheme_Object *T##Type=NULL;

  GTKCAIRO_TM_DYN(DEREF_FUNC,T);

  static void init_##T##Type(void) {
    if (T##Type==NULL) {
      T##Type=scheme_make_byte_string(TString);
      scheme_dont_gc_ptr(T##Type);
    }
  }

  static void check_##T##Type(Scheme_Object *obj,
			      const char *FUNCNAME,
			      int arg,
			      int argc,
			      Scheme_Object **argv) {
    
    init_##T##Type();

    if (!SCHEME_CPTRP(obj)) {
      scheme_wrong_type(FUNCNAME,TString,arg,argc,argv);
    }
    else if (SCHEME_CPTR_TYPE(obj)!=T##Type) {
      scheme_wrong_type(FUNCNAME,TString,arg,argc,argv);
    }
  }

  static void finalize_##T##Type(void *scheme_object,void *cairo_data) {
    printf("dereference %s\n",TString);lseek(stdout,0,SEEK_END);
    DEREF_FUNC((T *) cairo_data);
  }
      
%}

%typemap(in) T * {
  check_##T##Type($input,FUNC_NAME,$argnum-1,argc,argv);
  $1=(T *) SCHEME_CPTR_VAL($input);
}

%typemap(out) T * {

  init_##T##Type();

  if ($1) {
    $result=scheme_make_cptr($1,T##Type);
    scheme_register_finalizer($result,finalize_##T##Type,$1,NULL,NULL);
  }
  else {
    $result=scheme_false;
  }
}

%enddef

%define cairo_simple_typemap(T,TString)

%{
  static void T##deref_stub(T *o) { }
%}

cairo_ref_typemap(T,TString,mzgtk2_deref_stub);

%enddef

cairo_ref_typemap(cairo_t,"cairo_t",cairo_destroy);
cairo_ref_typemap(cairo_path_t,"cairo_path_t",cairo_path_destroy);
cairo_ref_typemap(cairo_scaled_font_t,"cairo_scaled_font_t",cairo_scaled_font_destroy);
cairo_ref_typemap(cairo_pattern_t,"cairo_pattern_t",cairo_pattern_destroy);
cairo_ref_typemap(cairo_surface_t,"cairo_surface_t",cairo_surface_destroy);
cairo_simple_typemap(cairo_font_face_t,"cairo_font_face_t");

/*************************************************************
 * Coercion to NULL
 *************************************************************/

%define any_pointer_to_null(T)

%typemap(in) T {
  if ($input!=scheme_false) {
    scheme_wrong_type(FUNC_NAME,"Only #f can be used here",$argnum-1,argc,argv);
  }
  $1=NULL;
}

%enddef

any_pointer_to_null(GtkMenuPositionFunc);
any_pointer_to_null(gpointer);

/*************************************************************
 * Coercion to enumerations
 *************************************************************/

%define convert_enums(T,fromto...)

%typemap(in) T {
  mzgtk2_catch(SCHEME_FALSEP($input) || SCHEME_SYMBOLP($input) || SCHEME_INTP($input),
	       mzgtk2_get_enum_symbols(0,fromto)
	       );
  if (SCHEME_INTP($input)) {
    $1=(T) SCHEME_INT_VAL($input);
  }
  else if (SCHEME_FALSEP($input)) {
    $1=(T) mzgtk2_convert_scheme_to_enum(NULL,FUNC_NAME,fromto);
  }
  else {
    $1=(T) mzgtk2_convert_scheme_to_enum($input,FUNC_NAME,fromto);
  }
}

%typemap(out) T {
  $result=mzgtk2_convert_enum_to_scheme((int) $1,FUNC_NAME,fromto);
}

%enddef

%include convert_enums.i.h