/* -*- Mode: C; ; c-file-style: "k&r"; c-basic-offset: 4 -*- */
/* gst-python
 * Copyright (C) 2005 Edward Hervey
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 * 
 * Author: Johan Dahlin <johan@gnome.org>
 */
%%
override gst_event_get_structure noargs
static PyObject *
_wrap_gst_event_get_structure(PyGstMiniObject *self)
{
     GstStructure *ret;

     ret = (GstStructure *) gst_event_get_structure(GST_EVENT(self->obj));
     /* pyg_boxed_new handles NULL checking */
     return pyg_boxed_new(GST_TYPE_STRUCTURE, ret, TRUE, TRUE);
}

%%
override-slot GstEvent.tp_repr
static PyObject *
_wrap_gst_event_tp_repr (PyGObject *self)
{
     char *buf;
     PyObject *retval;
     GstEvent *event;

     event = GST_EVENT(self->obj);

     buf = g_strdup_printf ("<GstEvent (%s) at %lx>",
			    gst_event_type_get_name (event->type), (long) self->obj);

     retval = PyString_FromString(buf);
     g_free(buf);
     return retval;
}
%%
override gst_event_parse_new_segment noargs
static PyObject *
_wrap_gst_event_parse_new_segment (PyGstMiniObject *self)
{
     gboolean   update;
     gdouble	rate;
     GstFormat	format;
     gint64	start_value, stop_value, base;

     if (GST_EVENT_TYPE(self->obj) != GST_EVENT_NEWSEGMENT) {
	  PyErr_SetString(PyExc_TypeError, "Even is not a 'NewSegment' event");
	  return NULL;
     }
     
     gst_event_parse_new_segment (GST_EVENT(self->obj), &update, &rate, &format,
				 &start_value, &stop_value, &base);

     return Py_BuildValue("(OdOLLL)",
			  PyBool_FromLong(update),
			  rate, pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			  start_value, stop_value, base);
}
%%
override gst_event_parse_tag noargs
static PyObject *
_wrap_gst_event_parse_tag (PyGstMiniObject *self)
{
	PyObject	*ret;
	GstTagList	*taglist;
	
	if (GST_EVENT_TYPE(self->obj) != GST_EVENT_TAG) {
		PyErr_SetString(PyExc_TypeError, "Event is not an 'Tag' event");
		return NULL;
	}

	gst_event_parse_tag (GST_EVENT(self->obj), &taglist);

	ret = pyg_boxed_new (GST_TYPE_TAG_LIST, taglist, TRUE, TRUE);

	return ret;
}
%%
override gst_event_parse_qos noargs
static PyObject *
_wrap_gst_event_parse_qos (PyGstMiniObject *self)
{
	gdouble		proportion;
	GstClockTimeDiff	diff;
	GstClockTime	timestamp;
	
	if (GST_EVENT_TYPE(self->obj) != GST_EVENT_QOS) {
		PyErr_SetString(PyExc_TypeError, "Event is not an 'Qos' event");
		return NULL;
	}

	gst_event_parse_qos (GST_EVENT(self->obj), &proportion,
			     &diff, &timestamp);
	
       return Py_BuildValue("(dLK)", proportion, diff, timestamp);
}
%%
override gst_event_parse_seek noargs
static PyObject *
_wrap_gst_event_parse_seek (PyGstMiniObject *self)
{
	gdouble	        rate;
	GstFormat	format;
	GstSeekFlags	flags;
	GstSeekType	cur_type;
	gint64		cur;
	GstSeekType	stop_type;
	gint64		stop;
	
	if (GST_EVENT_TYPE(self->obj) != GST_EVENT_SEEK) {
		PyErr_SetString(PyExc_TypeError, "Event is not an 'Seek' event");
		return NULL;
	}

	gst_event_parse_seek (GST_EVENT(self->obj), &rate, &format, &flags,
			      &cur_type, &cur, &stop_type, &stop);
	
	return Py_BuildValue("(dOOOLOL)",
			     rate,
			     pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			     pyg_flags_from_gtype (GST_TYPE_SEEK_FLAGS, flags),
			     pyg_enum_from_gtype (GST_TYPE_SEEK_TYPE, cur_type),
			     cur,
			     pyg_enum_from_gtype (GST_TYPE_SEEK_TYPE, stop_type),
			     stop);
}
%%
override gst_event_parse_buffer_size noargs
static PyObject *
_wrap_gst_event_parse_buffer_size (PyGstMiniObject *self)
{
     GstFormat		format;
     gint64		minsize;
     gint64		maxsize;
     gboolean		async;

     if (GST_EVENT_TYPE (self->obj) != GST_EVENT_BUFFERSIZE) {
	  PyErr_SetString(PyExc_TypeError, "Event is not an 'BufferSize' event");
	  return NULL;
     }
     
     gst_event_parse_buffer_size (GST_EVENT (self->obj),
				  &format, &minsize,
				  &maxsize, &async);

     return Py_BuildValue("(OLLO)",
			  pyg_enum_from_gtype(GST_TYPE_FORMAT, format),
			  minsize, maxsize,
			  PyBool_FromLong(async));
}
%%
override gst_event_parse_latency noargs
static PyObject *
_wrap_gst_event_parse_latency (PyGstMiniObject * self)
{
     GstClockTime	ctime = GST_CLOCK_TIME_NONE;

     if (GST_EVENT_TYPE (self->obj) != GST_EVENT_LATENCY) {
	  PyErr_SetString(PyExc_TypeError, "Event is not a 'latency' event");
	  return NULL;
     }
     
     gst_event_parse_latency (GST_EVENT (self->obj), &ctime);
     
     return PyLong_FromUnsignedLongLong(ctime);
}
%%
override gst_event_new_navigation kwargs
static PyObject *
_wrap_gst_event_new_navigation(PyObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "structure", NULL };
    PyObject *py_structure, *py_ret;
    GstEvent *ret;
    GstStructure *structure = NULL;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:event_new_navigation", kwlist, &py_structure))
        return NULL;
    if (pyg_boxed_check(py_structure, GST_TYPE_STRUCTURE))
        structure = pyg_boxed_get(py_structure, GstStructure);
    else {
        PyErr_SetString(PyExc_TypeError, "structure should be a GstStructure");
        return NULL;
    }
    pyg_begin_allow_threads;
    ret = gst_event_new_navigation(gst_structure_copy(structure));
    pyg_end_allow_threads;
    py_ret = pygstminiobject_new((GstMiniObject *)ret);
    if (ret != NULL)
       gst_mini_object_unref((GstMiniObject *)ret);
    return py_ret;
}
%%
override gst_event_new_custom kwargs
static PyObject *
_wrap_gst_event_new_custom(PyObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "type", "structure", NULL };
    PyObject *py_type = NULL, *py_structure, *py_ret;
    GstEvent *ret;
    GstStructure *structure = NULL;
    GstEventType type;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:event_new_custom", kwlist, &py_type, &py_structure))
        return NULL;
    if (pyg_enum_get_value(GST_TYPE_EVENT_TYPE, py_type, (gint *)&type))
        return NULL;
    if (pyg_boxed_check(py_structure, GST_TYPE_STRUCTURE))
        structure = pyg_boxed_get(py_structure, GstStructure);
    else {
        PyErr_SetString(PyExc_TypeError, "structure should be a GstStructure");
        return NULL;
    }
    pyg_begin_allow_threads;
    ret = gst_event_new_custom(type, gst_structure_copy(structure));
    pyg_end_allow_threads;
    py_ret = pygstminiobject_new((GstMiniObject *)ret);
    if (ret != NULL)
       gst_mini_object_unref((GstMiniObject *)ret);
    return py_ret;
}
%%
override gst_event_new_tag kwargs
static PyObject *
_wrap_gst_event_new_tag(PyObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "taglist", NULL };
    GstTagList *taglist = NULL;
    PyObject *py_taglist, *py_ret;
    GstEvent *ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:event_new_tag", kwlist, &py_taglist))
        return NULL;
    if (pyg_boxed_check(py_taglist, GST_TYPE_TAG_LIST))
        taglist = pyg_boxed_get(py_taglist, GstTagList);
    else {
        PyErr_SetString(PyExc_TypeError, "taglist should be a GstTagList");
        return NULL;
    }
    pyg_begin_allow_threads;
    ret = gst_event_new_tag(gst_tag_list_copy(taglist));
    pyg_end_allow_threads;
    py_ret = pygstminiobject_new((GstMiniObject *)ret);
    if (ret != NULL)
       gst_mini_object_unref((GstMiniObject *)ret);
    return py_ret;
}
%%
override gst_event_parse_step noargs
static PyObject *
_wrap_gst_event_parse_step (PyGstMiniObject * self)
{
     GstFormat format;
     guint64 amount;
     gdouble rate;
     gboolean flush, intermediate;

     if (GST_EVENT_TYPE (self->obj) != GST_EVENT_STEP) {
	  PyErr_SetString(PyExc_TypeError, "Event is not a 'step' event");
	  return NULL;
     }
     
     gst_event_parse_step (GST_EVENT (self->obj), &format, &amount, &rate,
			   &flush, &intermediate);

     return Py_BuildValue("OKdOO",
			  pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			  amount, rate,
			  PyBool_FromLong(flush),
			  PyBool_FromLong(intermediate));
}
%%
override gst_event_parse_new_segment_full noargs
static PyObject *
_wrap_gst_event_parse_new_segment_full (PyGstMiniObject *self)
{
     gboolean   update;
     gdouble	rate, applied_rate;
     GstFormat	format;
     gint64	start_value, stop_value, base;

     if (GST_EVENT_TYPE(self->obj) != GST_EVENT_NEWSEGMENT) {
	  PyErr_SetString(PyExc_TypeError, "Even is not a 'NewSegment' event");
	  return NULL;
     }
     
     gst_event_parse_new_segment_full (GST_EVENT(self->obj), &update, &rate,
				       &applied_rate, &format,
				       &start_value, &stop_value, &base);

     return Py_BuildValue("(OddOLLL)",
			  PyBool_FromLong(update),
			  rate, applied_rate, pyg_enum_from_gtype (GST_TYPE_FORMAT, format),
			  start_value, stop_value, base);
}