/* -*- Mode: C; ; c-file-style: "python" -*- */
/* gst-python
 * Copyright (C) 2004 Johan Dahlin
 *
 * 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>
 */

%%
ignore
  gst_bin_get_by_name_recurse_up
%%
override gst_bin_add args
static PyObject *
_wrap_gst_bin_add(PyGObject *self, PyObject *args)
{
	PyGObject *element;
	int i, len;

	len = PyTuple_Size(args);
	if (len == 0) {
		PyErr_SetString(PyExc_TypeError, "GstBin.add_many requires at least one argument");
		return NULL;
	}
       
    
	for (i = 0; i < len; i++) {
		element = (PyGObject*)PyTuple_GetItem(args, i);
		if (!pygobject_check(element, &PyGstElement_Type))
		{
			PyErr_SetString(PyExc_TypeError, "argument must be a GstElement");
			return NULL;
		}
	}
	
	for (i = 0; i < len; i++) {
		gboolean rest;

		element = (PyGObject*)PyTuple_GetItem(args, i);
		pyg_begin_allow_threads;
		rest = gst_bin_add(GST_BIN(self->obj), GST_ELEMENT(element->obj));
		pyg_end_allow_threads;
		if (!rest) {
			PyErr_Format(PyGstExc_AddError, "Could not add element '%s'", GST_OBJECT_NAME(element->obj));
			return NULL;
                }
	}

	Py_INCREF(Py_None);
	return Py_None;
}

%%
override gst_bin_add_many kwargs
static PyObject *
_wrap_gst_bin_add_many(PyGObject *self, PyObject *args)
{
    if (PyErr_Warn(PyExc_DeprecationWarning, "gst.Bin.add_many() is deprecated, use gst.Bin.add()") < 0)
        return NULL;
    return _wrap_gst_bin_add (self, args);
}

%%
override gst_bin_remove args
static PyObject *
_wrap_gst_bin_remove(PyGObject *self, PyObject *args)
{
	PyGObject *element;
	int i, len;

	len = PyTuple_Size(args);
	if (len == 0) {
		PyErr_SetString(PyExc_TypeError, "GstBin.remove_many requires at least one argument");
		return NULL;
	}
       
    
	for (i = 0; i < len; i++) {
		element = (PyGObject*)PyTuple_GetItem(args, i);
		if (!pygobject_check(element, &PyGstElement_Type))
		{
			PyErr_SetString(PyExc_TypeError, "argument must be a GstElement");
			return NULL;
		}
	}
	
	for (i = 0; i < len; i++) {
		gboolean rest;
		element = (PyGObject*)PyTuple_GetItem(args, i);
		pyg_begin_allow_threads;
		rest = gst_bin_remove(GST_BIN(self->obj), GST_ELEMENT(element->obj));
		pyg_end_allow_threads;
		if (!rest) {
			PyErr_Format(PyGstExc_RemoveError, "Could not remove element '%s'", GST_OBJECT_NAME(element->obj));
			return NULL;
	        }
	}

	Py_INCREF(Py_None);
	return Py_None;
}

%%
override gst_bin_remove_many kwargs
static PyObject *
_wrap_gst_bin_remove_many(PyGObject *self, PyObject *args)
{
    if (PyErr_Warn(PyExc_DeprecationWarning, "gst.Bin.remove_many() is deprecated, use gst.Bin.remove()") < 0)
        return NULL;
    return _wrap_gst_bin_remove (self, args);
}
%%
override gst_bin_get_by_name kwargs
static PyObject *
_wrap_gst_bin_get_by_name(PyGObject *self, PyObject *args, PyObject *kwargs)
{
    static char *kwlist[] = { "name", "recurse", NULL };
    char *name;
    gboolean recurse = FALSE;
    GstElement *el;
    PyObject *ret;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|b:GstBin.get_by_name",
				     kwlist, &name, &recurse))
        return NULL;
    
    if (recurse)
	    el = gst_bin_get_by_name_recurse_up(GST_BIN(self->obj), name);
    else
	    el = gst_bin_get_by_name(GST_BIN(self->obj), name);
    
    /* pygobject_new handles NULL checking */
    ret = pygobject_new((GObject *)el);
    if (el)
	    gst_object_unref (el); /* from get_by_name */
    return ret;
}
%%
override-slot GstBin.tp_iter
static PyObject *
_wrap_gst_bin_tp_iter(PyGObject *self)
{
    return _wrap_gst_bin_iterate_elements(self);
}
%%
override GstBin__do_handle_message kwargs
static PyObject *
_wrap_GstBin__do_handle_message(PyObject *cls, PyObject *args, PyObject *kwargs)
{
    gpointer klass;
    static char *kwlist[] = { "self", "message", NULL };
    PyGObject *self;
    PyGstMiniObject *message;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!O!:GstBin.handle_message", kwlist, &PyGstBin_Type, &self, &PyGstMessage_Type, &message))
        return NULL;
    klass = g_type_class_ref(pyg_type_from_object(cls));
    if (GST_BIN_CLASS(klass)->handle_message) {
	    gst_mini_object_ref (message->obj);
	    pyg_begin_allow_threads;
	    GST_BIN_CLASS(klass)->handle_message(GST_BIN(self->obj), GST_MESSAGE(message->obj));
	    pyg_end_allow_threads;
    } else {
        PyErr_SetString(PyExc_NotImplementedError, "virtual method GstBin.handle_message not implemented");
        g_type_class_unref(klass);
        return NULL;
    }
    g_type_class_unref(klass);
    Py_INCREF(Py_None);
    return Py_None;
}

%%
override GstBin__proxy_do_handle_message
static void
_wrap_GstBin__proxy_do_handle_message(GstBin *self, GstMessage*message)
{
    PyGILState_STATE __py_state;
    PyObject *py_self;
    PyObject *py_message = NULL;
    PyObject *py_retval;
    PyObject *py_args;
    PyObject *py_method;
    
    __py_state = pyg_gil_state_ensure();
    py_self = pygobject_new((GObject *) self);
    if (!py_self) {
        if (PyErr_Occurred())
            PyErr_Print();
        pyg_gil_state_release(__py_state);
        return;
    }
    if (message) {
        py_message = pygstminiobject_new((GstMiniObject *) message);
        gst_mini_object_unref ((GstMiniObject *) message);
    } else {
        Py_INCREF(Py_None);
        py_message = Py_None;
    }
    
    py_args = PyTuple_New(1);
    Py_INCREF(py_message);
    PyTuple_SET_ITEM(py_args, 0, py_message);
    
    py_method = PyObject_GetAttrString(py_self, "do_handle_message");
    if (!py_method) {
        if (PyErr_Occurred())
            PyErr_Print();
        Py_DECREF(py_args);
        gst_mini_object_ref ((GstMiniObject *) message); Py_DECREF(py_message);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return;
    }
    py_retval = PyObject_CallObject(py_method, py_args);
    if (!py_retval) {
        if (PyErr_Occurred())
            PyErr_Print();
        Py_DECREF(py_method);
        Py_DECREF(py_args);
        gst_mini_object_ref ((GstMiniObject *) message); Py_DECREF(py_message);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return;
    }
    if (py_retval != Py_None) {
        if (PyErr_Occurred())
            PyErr_Print();
        PyErr_SetString(PyExc_TypeError, "retval should be None");
        Py_DECREF(py_retval);
        Py_DECREF(py_method);
        Py_DECREF(py_args);
        gst_mini_object_ref ((GstMiniObject *) message); Py_DECREF(py_message);
        Py_DECREF(py_self);
        pyg_gil_state_release(__py_state);
        return;
    }
    
    
    Py_DECREF(py_retval);
    Py_DECREF(py_method);
    Py_DECREF(py_args);
    gst_mini_object_ref ((GstMiniObject *) message); Py_DECREF(py_message);

    /* #577735: since the bus handler will return BUS_DROP, we should unref.
      This is the only change from the generated code. */
    gst_mini_object_unref ((GstMiniObject *) message);

    Py_DECREF(py_self);
    pyg_gil_state_release(__py_state);
}