#include "pygtk.h"

#include "pygdkpixbuf.h"

//#include <gtk/gtk.h>

#include <gdk-pixbuf/gdk-pixbuf-loader.h>

//#include "pygdkpixbuf-loader.h"

#ifdef DEBUG__PYGDKPIXBUF

static int debugging = FALSE;

#define dbg() \

if (debugging) { \

g_print ("%s():\n", __FUNCTION__); \

}

#define dprint(format, varargs...) \

if (debugging) { \

g_print ("%s(): ", __FUNCTION__); \

g_print (format, ## varargs); \

}

#else

#define dbg()

#define dprint(format, varargs...)

#endif /* DEBUG__PYGDKPIXBUF_LOADER */

#define PFUNC(x) \

static PyObject *x (PyObject *self, PyObject *args)

#define GET_ARGS(format, xxx...) \

dbg(); \

if (!PyArg_ParseTuple (args, format ":" __FUNCTION__, ## xxx)) \

return NULL

#ifdef DEBUG__PYGDKPIXBUF

PFUNC (_set_debugging)

{

GET_ARGS ("i", &debugging);

Py_INCREF (Py_None);

return Py_None;

}

#endif

#if 0

static gboolean wrap_frame_done_cb (GdkPixbufLoader *loader,

GdkPixbufFrame *frame,

gpointer data)

{

PyObject *result, *func, *func_data, *frame_python, *loader_python;

PyObject *func_data_orig;

PyObject *crap;

int check;

long ret;

int func_data_length;

//PyGTK_BLOCK_THREADS

dbg();

func = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader),

"py_frame_done_cb_func");

func_data_orig = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader),

"py_frame_done_cb_data");

Py_XINCREF (func_data_orig);

/*FIXME check if frame_python == NULL ? */

frame_python = PyGdkPixbuf_FrameNew (frame);

if (!PyTuple_Check (func_data_orig))

{ dprint ("fuck, func_data_orig isn't a tuple.\n");

PyErr_SetString (PyExc_TypeError,

"func_data_orig isn't a tuple");

goto error;

}

func_data_length = PyTuple_Size (func_data_orig);

dprint ("func_data_length == %d\n", func_data_length);

func_data = PyTuple_New (func_data_length + 2);

if (func_data == NULL)

goto error;

//if (!PyList_Check (func_data))

// dprint ("fuck, func_data isn't a list.\n");

//Py_XINCREF (func_data);

loader_python = PyGtk_New ((GtkObject *) loader);

//Py_XINCREF (loader_python);

// crap = PyTuple_GetItem (func_data, 0); //, loader_python);

// PyObject_Print (crap, stderr, Py_PRINT_RAW);

// Py_XDECREF (crap);

check = PyTuple_SetItem (func_data, 0, loader_python);

//check = PyList_SetItem (func_data, 0, loader_python);

dprint ("tried to set item\n");

if (check != 0)

{ //dprint ("error appending Loader to arg tuple %d\n", check);

//Py_XDECREF (func_data);

//Py_XDECREF (frame_python);

//return TRUE;

//PyErr_SetString (PyExc_RuntimeError,

// "error appending frame to arg tuple\n");

goto error;

}

check = PyTuple_SetItem (func_data, 1, frame_python);

//check = PyList_SetItem (func_data, 1, frame_python);

if (check != 0)

{ //dprint ("error appending frame to arg tuple %d\n", check);

goto error;

}

result = PyObject_CallObject (func, func_data);

if (result == NULL)

{

//PyErr_Print ();

//PyErr_Clear ();

//PyObject_Print (func, stderr, Py_PRINT_RAW);

//dprint ("error calling function\n");

goto error;

}

if (PyInt_Check (result))

ret = PyInt_AsLong (result);

else

{

dprint ("return value of cb isn't an int??\n");

Py_XDECREF (result);

PyErr_SetString (PyExc_RuntimeError,

"return value of cb isn't an int??\n");

goto error;

}

Py_XDECREF (result);

return (gboolean) ret;

error:

Py_XDECREF (func_data);

Py_XDECREF (frame_python);

//dprint ("error calling frame_done_cb\n");

//if (0) //(PyGtk_FatalExceptions)

if (PyGtk_FatalExceptions)

{ //PyErr_Print ();

//PyErr_Clear ();

gtk_main_quit ();

}

else

{ PyErr_Print ();

PyErr_Clear ();

}

//PyGTK_UNBLOCK_THREADS

return TRUE;

}

#endif

#if 0

static gboolean decref_python_cb (GdkPixbufLoader *loader, gpointer data)

{

PyObject *func, *func_data;

dbg();

func = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader),

"py_frame_done_cb_func");

func_data = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader),

"py_frame_done_cb_data");

Py_XDECREF (func);

Py_XDECREF (func_data);

return FALSE;

}

#endif

#if 0

//FIXME

PFUNC (_wrap_connect_frame_done)

{

PyObject *loader_python, *function, *extra_args = NULL;

GdkPixbufLoader *loader;

GET_ARGS ("O!OO!", &PyGtk_Type, &loader_python, &function,

&PyTuple_Type, &extra_args);

Py_XINCREF (loader_python);

Py_XINCREF (function);

Py_XINCREF (extra_args);

loader = (GdkPixbufLoader *) PyGtk_Get (loader_python);

if (!PyCallable_Check (function))

{ PyErr_SetString (PyExc_TypeError, "arg 2 not callable");

goto error;

}

#if 0

/*

if (!PyTuple_Check (extra_args))

{ PyErr_SetString (PyExc_TypeError, "arg 3 not a tuple");

goto error;

}

*/

/*FIXME create a new tuple with space for 2 args */

/* make sure args has the first 2 elements free in order to

add the func and func_data

*/

gtk_object_set_data (GTK_OBJECT (loader), "py_frame_done_cb_func",

(gpointer) function);

gtk_object_set_data (GTK_OBJECT (loader), "py_frame_done_cb_data",

(gpointer) extra_args);

/*FIXME will this really work??? What if another call-back is added

to "destroy" and that one returns TRUE, will this even get called?

*/

/*FIXME just make Loader a new PyGtk type? */

gtk_signal_connect (GTK_OBJECT (loader), "destroy",

GTK_SIGNAL_FUNC (decref_python_cb), NULL);

gtk_signal_connect (GTK_OBJECT (loader), "frame_done",

GTK_SIGNAL_FUNC (wrap_frame_done_cb), NULL);

#endif

Py_XDECREF (loader_python);

Py_INCREF (Py_None);

return Py_None;

error:

Py_XDECREF (loader_python);

Py_XDECREF (function);

Py_XDECREF (extra_args);

return NULL;

}

#endif

/* Can't simply connect "frame_done" signal like the others. The handler

is of type: gint func (GdkPixbufLoader *loader,

GdkPixbufFrame *frame,

gpointer data)

If you simply connect it from python it will pass in 'frame' as a

CObject, and since it wasn't created with a 'destroy' handler you can't

manipulate 'frame' within python code (program will silently exit).

We need to get a hold of 'frame' first, convert it to a GtkObject and

then pass it on to the user function in python.

*/

static void marshal_frame_done_cb (GtkObject *loader_ptr,

gpointer func_args_tuple_ptr,

guint nargs, GtkArg *args)

{

/*FIXME I'm probably fucking this up */

PyObject *loader_python, *func_args_tuple_orig, *frame_python, *func;

PyObject *func_args_tuple;

PyObject *new_args, *result;

GdkPixbufFrame *frame;

int check;

PyGtk_BlockThreads ();

dbg ();

frame = (GdkPixbufFrame *) GTK_VALUE_POINTER(args[0]);

func_args_tuple = (PyObject *) func_args_tuple_ptr;

Py_XINCREF (func_args_tuple);

//loader_python = PyGdkPixbuf_LoaderNew ((GdkPixbufLoader *) loader_ptr);

loader_python = PyGtk_New (loader_ptr);

if (loader_python == NULL)

{ dprint ("couldn't make loader_python\n");

goto error;

}

frame_python = PyGdkPixbuf_FrameNew (frame);

if (frame_python == NULL)

{ dprint ("couldn't make frame_python\n");

goto error;

}

func = PyTuple_GetItem (func_args_tuple, 0);

if (func == NULL)

{ dprint ("couldn't get func from tuple\n");

goto error;

}

check = PyTuple_SetItem (func_args_tuple, 1, loader_python);

if (check != 0)

{ dprint ("func_args_tuple[1] = loader_python failed\n");

goto error;

}

check = PyTuple_SetItem (func_args_tuple, 2, frame_python);

if (check != 0)

{ dprint ("func_args_tuple[2] = frame_python failed\n");

goto error;

}

/*FIXME are the tuple items "stolen" references??? */

new_args = PyTuple_GetSlice (func_args_tuple, 1,

PyTuple_Size(func_args_tuple));

if (new_args == NULL)

{ dprint ("new_args = func_args_tuple[1:] failed\n");

goto error;

}

result = PyObject_CallObject (func, new_args);

if (result == NULL)

{ Py_XDECREF (new_args);

dprint ("func(new_args) returned NULL\n");

goto error;

}

GtkRet_FromPyObject (&args[nargs], result);

Py_DECREF (result);

PyGtk_UnblockThreads ();

return;

error:

Py_XDECREF (func_args_tuple);

if (PyGtk_FatalExceptions)

gtk_main_quit ();

else

{ PyErr_Print ();

PyErr_Clear ();

}

PyGtk_UnblockThreads ();

return;

}

#if 0

static void frame_done_cb_destroy_notify (gpointer func_args_tuple)

{

/* data == the arg tuple */

/*FIXME handle threads ? */

//PyGTK_BLOCK_THREADS

PyGtk_BlockThreads ();

dbg();

Py_DECREF ((PyObject *) func_args_tuple);

PyGtk_UnblockThreads ();

//PyGTK_UNBLOCK_THREADS

}

#endif

PFUNC (_wrap_connect_frame_done)

{

PyObject *loader_python, *func;

//PyObject *func_args_tuple;

PyObject *args_tuple;

//PyObject *result;

//int args_tuple_length, check, signum, i;

int signum;

GET_ARGS ("O!OO!", &PyGtk_Type, &loader_python, &func,

&PyTuple_Type, &args_tuple);

if (!PyCallable_Check (func))

{ PyErr_SetString (PyExc_TypeError, "2nd arg not callable");

return NULL;

}

Py_XINCREF (args_tuple);

#if 0

args_tuple_length = PyTuple_Size (args_tuple);

/* func_args_tuple ==

(func, None <room for GdkPixbufLoader*>, None <room for

GdkPixbufFrame*>) + args_tuple

*/

func_args_tuple = PyTuple_New (args_tuple_length + 3);

if (func_args_tuple == NULL)

{ Py_XDECREF (args_tuple);

return NULL;

}

check = PyTuple_SetItem (func_args_tuple, 0, func);

if (check != 0)

{ Py_XDECREF (args_tuple);

return NULL;

}

for (i = 0; i < args_tuple_length; i++)

{

PyObject *tuple_item;

tuple_item = PyTuple_GetItem (args_tuple, i);

if (tuple_item == NULL)

{ Py_XDECREF (args_tuple);

return NULL;

}

check = PyTuple_SetItem (func_args_tuple, i + 3, tuple_item);

if (check != 0)

{ Py_XDECREF (args_tuple);

return NULL;

}

}

signum = gtk_signal_connect_full (PyGtk_Get(loader_python),

"frame_done", NULL,

(GtkCallbackMarshal) marshal_frame_done_cb,

func_args_tuple,

frame_done_cb_destroy_notify, FALSE, FALSE);

#endif

signum = gtk_signal_connect_full (PyGtk_Get(loader_python),

"frame_done", NULL,

(GtkCallbackMarshal) marshal_frame_done_cb,

args_tuple,

frame_done_cb_destroy_notify, FALSE, FALSE);

return PyInt_FromLong(signum);

}

PFUNC (_get_type)

{

GET_ARGS ("");

return PyInt_FromLong (gdk_pixbuf_loader_get_type());

}

PFUNC (_new)

{

GET_ARGS ("");

return PyGtk_New((GtkObject *) gdk_pixbuf_loader_new());

}

PFUNC (_write)

{

PyObject *loader_py;

GdkPixbufLoader *loader;

char *buf;

int count;

gboolean ret;

GET_ARGS ("O!s#", &PyGtk_Type, &loader_py, &buf, &count);

Py_XINCREF (loader_py);

loader = (GdkPixbufLoader *) PyGtk_Get (loader_py);

ret = gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (loader),

(guchar *) buf,

(size_t) count);

Py_XDECREF (loader_py);

return Py_BuildValue ("i", ret);

}

PFUNC (_get_pixbuf)

{

PyObject *loader_py;

GdkPixbufLoader *loader;

GdkPixbuf *pixbuf;

GET_ARGS ("O!", &PyGtk_Type, &loader_py);

Py_XINCREF (loader_py);

loader = (GdkPixbufLoader *) PyGtk_Get (loader_py);

pixbuf = gdk_pixbuf_loader_get_pixbuf (GDK_PIXBUF_LOADER (loader));

gdk_pixbuf_ref (pixbuf);

Py_XDECREF (loader_py);

return PyGdkPixbuf_PixbufNew (pixbuf);

}

PFUNC (_get_animation)

{

PyObject *python_loader;

GdkPixbufLoader *loader;

GdkPixbufAnimation *animation;

GET_ARGS ("O!", &PyGtk_Type, &python_loader);

Py_XINCREF (python_loader);

loader = (GdkPixbufLoader *) PyGtk_Get(python_loader);

animation = gdk_pixbuf_loader_get_animation (loader);

Py_XDECREF (python_loader);

return PyGdkPixbuf_AnimationNew (animation);

}

PFUNC (_close)

{

PyObject *loader_py;

GdkPixbufLoader *loader;

GET_ARGS ("O!", &PyGtk_Type, &loader_py);

Py_XINCREF (loader_py);

loader = (GdkPixbufLoader *) PyGtk_Get(loader_py);

gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (loader));

Py_XDECREF (loader_py);

Py_INCREF (Py_None);

return Py_None;

}

PFUNC (_frame_to_pyobject)

{

PyObject *frame_cobject;

GdkPixbufFrame *frame;

//PyObject *frame_new;

GET_ARGS ("O", &frame_cobject);

Py_XINCREF (frame_cobject);

if (!PyCObject_Check (frame_cobject))

{ PyErr_SetString (PyExc_TypeError, "arg not a CObject");

Py_XDECREF (frame_cobject);

return NULL;

}

frame = (GdkPixbufFrame *) PyCObject_AsVoidPtr (frame_cobject);

dprint ("returning\n");

Py_XDECREF (frame_cobject);

//frame_new = _PyGdkPixbuf_API->pygdkpixbuf_frame_new (frame);

//return frame_new;

return PyGdkPixbuf_FrameNew (frame);

}

#define PYMETHOD(function) { #function, _ ## function, METH_VARARGS }

static PyMethodDef _GdkPixbufLoader_Methods[] = {

#ifdef DEBUG__PYGDKPIXBUF

PYMETHOD (set_debugging),

#endif

PYMETHOD (wrap_connect_frame_done),

PYMETHOD (get_type),

PYMETHOD (new),

PYMETHOD (write),

PYMETHOD (get_pixbuf),

PYMETHOD (get_animation),

PYMETHOD (close),

PYMETHOD (frame_to_pyobject),

{NULL, NULL}

};

extern void init_GdkPixbufLoader (void)

{

dbg();

(void) Py_InitModule ("_GdkPixbufLoader", _GdkPixbufLoader_Methods);

init_pygtk ();

init_pygdkpixbuf ();

if (PyErr_Occurred())

Py_FatalError ("can't initialize module _GdkPixbufLoader");

//dbg();

}