/* -*- Mode: C; c-basic-offset: 2; indent-tabs-mode: nil -*-
 *
 * Pigment Python binding
 *
 * Copyright © 2006, 2007, 2008 Fluendo Embedded S.L.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser 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(s): Loïc Molinari <loic@fluendo.com>
 *            Philippe Normand <philippe@fluendo.com>
 */

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

/* tp_getset override */

%%
override-attr PgmViewport.title
static PyObject *
_wrap_pgm_viewport__get_title (PyGObject *self,
                               void *closure)
{
  return _wrap_pgm_viewport_get_title (self);
}

static int
_wrap_pgm_viewport__set_title (PyGObject *self,
                               PyObject *value,
                               void *closure)
{
  gchar *title = encode_string (value);

  if (!title)
      return -1;

  pyg_begin_allow_threads;
  pgm_viewport_set_title (PGM_VIEWPORT (self->obj), title);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.visible
static PyObject *
_wrap_pgm_viewport__get_visible (PyGObject *self,
                                 void *closure)
{
  gboolean visible;

  pyg_begin_allow_threads;
  pgm_viewport_is_visible (PGM_VIEWPORT (self->obj), &visible);
  pyg_end_allow_threads;

  if (visible)
    Py_RETURN_TRUE;
  else
    Py_RETURN_FALSE;
}

static int
_wrap_pgm_viewport__set_visible (PyGObject *self,
                                 PyObject *value,
                                 void *closure)
{
  gint show;

  if (!PyBool_Check (value))
    {
      PyErr_SetString (PyExc_TypeError, "a boolean is required");
      return -1;
    }

  show = PyInt_AsLong (value);
  pyg_begin_allow_threads;
  if (show)
    pgm_viewport_show (PGM_VIEWPORT (self->obj));
  else
    pgm_viewport_hide (PGM_VIEWPORT (self->obj));
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.decorated
static PyObject *
_wrap_pgm_viewport__get_decorated (PyGObject *self,
                                   void *closure)
{
  gboolean decorated;

  pyg_begin_allow_threads;
  pgm_viewport_get_decorated (PGM_VIEWPORT (self->obj), &decorated);
  pyg_end_allow_threads;

  if (decorated)
    Py_RETURN_TRUE;
  else
    Py_RETURN_FALSE;
}

static int
_wrap_pgm_viewport__set_decorated (PyGObject *self,
                                   PyObject *value,
                                   void *closure)
{
  gboolean decorated;

  if (!PyBool_Check (value))
    {
      PyErr_SetString (PyExc_TypeError, "a boolean is required");
      return -1;
    }

  decorated = PyInt_AsLong (value);
  pyg_begin_allow_threads;
  pgm_viewport_set_decorated (PGM_VIEWPORT (self->obj), decorated);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.cursor
static PyObject *
_wrap_pgm_viewport__get_cursor (PyGObject *self,
                                void *closure)
{
  return _wrap_pgm_viewport_get_cursor (self);
}

static int
_wrap_pgm_viewport__set_cursor (PyGObject *self,
                                PyObject *value,
                                void *closure)
{
  PgmViewportCursor cursor;

  if (pyg_enum_get_value (PGM_TYPE_VIEWPORT_CURSOR, value, (gint *) &cursor))
    {
      PyErr_SetString (PyExc_TypeError, "an integer is required");
      return -1;
    }

  pyg_begin_allow_threads;
  pgm_viewport_set_cursor (PGM_VIEWPORT (self->obj), cursor);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.icon
static PyObject *
_wrap_pgm_viewport__get_icon (PyGObject *self,
                              void *closure)
{
  return _wrap_pgm_viewport_get_icon (self);
}

static int
_wrap_pgm_viewport__set_icon (PyGObject *self,
                              PyObject *value,
                              void *closure)
{
  GdkPixbuf *icon = NULL;

  if (Py_None != value)
    {
      if (!pygobject_check(value, &PyGdkPixbuf_Type))
        {
          PyErr_SetString(PyExc_TypeError, "a gtk.gdk.Pixbuf is required");
          return -1;
        }

      icon = GDK_PIXBUF (pygobject_get (value));
    }

  pyg_begin_allow_threads;
  pgm_viewport_set_icon (PGM_VIEWPORT (self->obj), icon);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.size
static PyObject *
_wrap_pgm_viewport__get_size (PyGObject *self,
                              void *closure)
{
  return _wrap_pgm_viewport_get_size (self);
}

static int
_wrap_pgm_viewport__set_size (PyGObject *self,
                              PyObject *value,
                              void *closure)
{
  PyObject *object;
  gint width, height;

  object = PyTuple_GetItem (value, 0);
  width = PyInt_AsLong (object);
  object = PyTuple_GetItem (value, 1);
  height = PyInt_AsLong (object);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_set_size (PGM_VIEWPORT (self->obj), width, height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.width
static PyObject *
_wrap_pgm_viewport__get_width (PyGObject *self,
                               void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_size (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (width);
}

static int
_wrap_pgm_viewport__set_width (PyGObject *self,
                               PyObject *value,
                               void *closure)
{
  gint width, _width, height;

  _width = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_size (PGM_VIEWPORT (self->obj), &width, &height);
  pgm_viewport_set_size (PGM_VIEWPORT (self->obj), _width, height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.height
static PyObject *
_wrap_pgm_viewport__get_height (PyGObject *self,
                                void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_size (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (height);
}

static int
_wrap_pgm_viewport__set_height (PyGObject *self,
                                PyObject *value,
                                void *closure)
{
  gint width, height, _height;

  _height = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_size (PGM_VIEWPORT (self->obj), &width, &height);
  pgm_viewport_set_size (PGM_VIEWPORT (self->obj), width, _height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.alpha_blending
static PyObject *
_wrap_pgm_viewport__get_alpha_blending (PyGObject *self,
                                        void *closure)
{
  return _wrap_pgm_viewport_get_alpha_blending (self);
}

static int
_wrap_pgm_viewport__set_alpha_blending (PyGObject *self,
                                        PyObject *value,
                                        void *closure)
{
  gint alpha_blending;

  if (!PyBool_Check (value))
    {
      PyErr_SetString (PyExc_TypeError, "a boolean is required");
      return -1;
    }

  alpha_blending = PyInt_AsLong (value);
  pyg_begin_allow_threads;
  pgm_viewport_set_alpha_blending (PGM_VIEWPORT (self->obj), alpha_blending);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.opacity
static PyObject *
_wrap_pgm_viewport__get_opacity (PyGObject *self,
                                 void *closure)
{
  guchar opacity;

  pyg_begin_allow_threads;
  pgm_viewport_get_opacity (PGM_VIEWPORT (self->obj), &opacity);
  pyg_end_allow_threads;

  return PyInt_FromLong ((long) opacity);
}

static int
_wrap_pgm_viewport__set_opacity (PyGObject *self,
                                 PyObject *value,
                                 void *closure)
{
  gint opacity;

  opacity = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  opacity = CLAMP (opacity, 0, 255);

  pyg_begin_allow_threads;
  pgm_viewport_set_opacity (PGM_VIEWPORT (self->obj), (guchar) opacity);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.fullscreen
static PyObject *
_wrap_pgm_viewport__get_fullscreen (PyGObject *self,
                                    void *closure)
{
  return _wrap_pgm_viewport_get_fullscreen (self);
}

static int
_wrap_pgm_viewport__set_fullscreen (PyGObject *self,
                                    PyObject *value,
                                    void *closure)
{
  gint fullscreen;

  if (!PyBool_Check (value))
    {
      PyErr_SetString (PyExc_TypeError, "a boolean is required");
      return -1;
    }

  fullscreen = PyInt_AsLong (value);
  pyg_begin_allow_threads;
  pgm_viewport_set_fullscreen (PGM_VIEWPORT (self->obj), fullscreen);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.iconified
static PyObject *
_wrap_pgm_viewport__get_iconified (PyGObject *self,
                                   void *closure)
{
  return _wrap_pgm_viewport_get_iconified (self);
}

static int
_wrap_pgm_viewport__set_iconified (PyGObject *self,
                                   PyObject *value,
                                   void *closure)
{
  gint iconified;

  if (!PyBool_Check (value))
    {
      PyErr_SetString (PyExc_TypeError, "a boolean is required");
      return -1;
    }

  iconified = PyInt_AsLong (value);
  pyg_begin_allow_threads;
  pgm_viewport_set_iconified (PGM_VIEWPORT (self->obj), iconified);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.frame_rate
static PyObject *
_wrap_pgm_viewport__get_frame_rate (PyGObject *self,
                                    void *closure)
{
  guint frame_rate;

  pyg_begin_allow_threads;
  pgm_viewport_get_frame_rate (PGM_VIEWPORT (self->obj), &frame_rate);
  pyg_end_allow_threads;

  return PyInt_FromLong ((long) frame_rate);
}

%%
override-attr PgmViewport.canvas_rotation
static PyObject *
_wrap_pgm_viewport__get_canvas_rotation (PyGObject *self,
                                         void *closure)
{
  return _wrap_pgm_viewport_get_canvas_rotation (self);
}

static int
_wrap_pgm_viewport__set_canvas_rotation (PyGObject *self,
                                         PyObject *value,
                                         void *closure)
{
  PgmViewportRotation rotation;

  if (pyg_enum_get_value (PGM_TYPE_VIEWPORT_ROTATION, value, (gint *) &rotation))
    {
      PyErr_SetString (PyExc_TypeError, "an integer is required");
      return -1;
    }

  pyg_begin_allow_threads;
  pgm_viewport_set_canvas_rotation (PGM_VIEWPORT (self->obj), rotation);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.canvas_reflection
static PyObject *
_wrap_pgm_viewport__get_canvas_reflection (PyGObject *self,
                                           void *closure)
{
  return _wrap_pgm_viewport_get_canvas_reflection (self);
}

static int
_wrap_pgm_viewport__set_canvas_reflection (PyGObject *self,
                                           PyObject *value,
                                           void *closure)
{
  PgmViewportReflection reflection;

  if (pyg_enum_get_value (PGM_TYPE_VIEWPORT_REFLECTION, value,
                          (gint *) &reflection))
    {
      PyErr_SetString (PyExc_TypeError, "an integer is required");
      return -1;
    }

  pyg_begin_allow_threads;
  pgm_viewport_set_canvas_reflection (PGM_VIEWPORT (self->obj), reflection);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_resolution
static PyObject *
_wrap_pgm_viewport__get_screen_resolution (PyGObject *self,
                                           void *closure)
{
  return _wrap_pgm_viewport_get_screen_resolution (self);
}

static int
_wrap_pgm_viewport__set_screen_resolution (PyGObject *self,
                                           PyObject *value,
                                           void *closure)
{
  PyObject *object;
  gint width, height;

  object = PyTuple_GetItem (value, 0);
  width = PyInt_AsLong (object);
  object = PyTuple_GetItem (value, 1);
  height = PyInt_AsLong (object);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_set_screen_resolution (PGM_VIEWPORT (self->obj), width, height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_resolution_width
static PyObject *
_wrap_pgm_viewport__get_screen_resolution_width (PyGObject *self,
                                                 void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_resolution (PGM_VIEWPORT (self->obj), &width,
                                      &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (width);
}

static int
_wrap_pgm_viewport__set_screen_resolution_width (PyGObject *self,
                                                 PyObject *value,
                                                 void *closure)
{
  gint width, _width, height;

  _width = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_resolution (PGM_VIEWPORT (self->obj), &width,
                                      &height);
  pgm_viewport_set_screen_resolution (PGM_VIEWPORT (self->obj), _width,
                                      height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_resolution_height
static PyObject *
_wrap_pgm_viewport__get_screen_resolution_height (PyGObject *self,
                                                  void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_resolution (PGM_VIEWPORT (self->obj), &width,
                                      &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (height);
}

static int
_wrap_pgm_viewport__set_screen_resolution_height (PyGObject *self,
                                                  PyObject *value,
                                                  void *closure)
{
  gint width, height, _height;

  _height = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_resolution (PGM_VIEWPORT (self->obj), &width,
                                      &height);
  pgm_viewport_set_screen_resolution (PGM_VIEWPORT (self->obj), width,
                                      _height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_size_mm
static PyObject *
_wrap_pgm_viewport__get_screen_size_mm (PyGObject *self,
                                        void *closure)
{
  return _wrap_pgm_viewport_get_screen_size_mm (self);
}

static int
_wrap_pgm_viewport__set_screen_size_mm (PyGObject *self,
                                        PyObject *value,
                                        void *closure)
{
  PyObject *object;
  gint width, height;

  object = PyTuple_GetItem (value, 0);
  width = PyInt_AsLong (object);
  object = PyTuple_GetItem (value, 1);
  height = PyInt_AsLong (object);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_set_screen_size_mm (PGM_VIEWPORT (self->obj), width, height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_size_mm_width
static PyObject *
_wrap_pgm_viewport__get_screen_size_mm_width (PyGObject *self,
                                              void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_size_mm (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (width);
}

static int
_wrap_pgm_viewport__set_screen_size_mm_width (PyGObject *self,
                                              PyObject *value,
                                              void *closure)
{
  gint width, _width, height;

  _width = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_size_mm (PGM_VIEWPORT (self->obj), &width, &height);
  pgm_viewport_set_screen_size_mm (PGM_VIEWPORT (self->obj), _width, height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.screen_size_mm_height
static PyObject *
_wrap_pgm_viewport__get_screen_size_mm_height (PyGObject *self,
                                               void *closure)
{
  gint width, height;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_size_mm (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  return PyInt_FromLong (height);
}

static int
_wrap_pgm_viewport__set_screen_size_mm_height (PyGObject *self,
                                               PyObject *value,
                                               void *closure)
{
  gint width, height, _height;

  _height = PyInt_AsLong (value);

  if (PyErr_Occurred ())
    return -1;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_size_mm (PGM_VIEWPORT (self->obj), &width, &height);
  pgm_viewport_set_screen_size_mm (PGM_VIEWPORT (self->obj), width, _height);
  pyg_end_allow_threads;

  return 0;
}

%%
override-attr PgmViewport.pixel_formats
static PyObject *
_wrap_pgm_viewport__get_pixel_formats (PyGObject *self,
                                       void *closure)
{
  return _wrap_pgm_viewport_get_pixel_formats (self);
}

%%
override-attr PgmViewport.embedding_id
static PyObject *
_wrap_pgm_viewport__get_embedding_id (PyGObject *self,
                                      void *closure)
{
  return _wrap_pgm_viewport_get_embedding_id (self);
}

%%
override-attr PgmViewport.caps_mask
static PyObject *
_wrap_pgm_viewport__get_caps_mask (PyGObject *self,
                                   void *closure)
{
  return _wrap_pgm_viewport_get_caps_mask (self);
}

%%
override-attr PgmViewport.max_texture_size
static PyObject *
_wrap_pgm_viewport__get_max_texture_size (PyGObject *self,
                                          void *closure)
{
  return _wrap_pgm_viewport_get_max_texture_size (self);
}

/* Methods override */

%%
override pgm_viewport_is_visible noargs
static PyObject *
_wrap_pgm_viewport_is_visible (PyGObject *self)
{
  gboolean visible;

  pyg_begin_allow_threads;
  pgm_viewport_is_visible (PGM_VIEWPORT (self->obj), &visible);
  pyg_end_allow_threads;

  return PyBool_FromLong (visible);
}

%%
override pgm_viewport_get_decorated noargs
static PyObject *
_wrap_pgm_viewport_get_decorated (PyGObject *self)
{
  gboolean decorated;

  pyg_begin_allow_threads;
  pgm_viewport_get_decorated (PGM_VIEWPORT (self->obj), &decorated);
  pyg_end_allow_threads;

  return PyBool_FromLong (decorated);
}

%%
override pgm_viewport_get_title noargs
static PyObject *
_wrap_pgm_viewport_get_title (PyGObject *self)
{
  gchar *title = NULL;
  PyObject *py_string = NULL;

  pyg_begin_allow_threads;
  pgm_viewport_get_title (PGM_VIEWPORT (self->obj), &title);
  pyg_end_allow_threads;

  py_string = PyString_FromStringAndSize (title, strlen (title));
  g_free (title);

  if (!py_string)
    {
      Py_INCREF (Py_None);
      return (Py_None);
    }

  return py_string;
}

%%
override pgm_viewport_get_cursor noargs
static PyObject *
_wrap_pgm_viewport_get_cursor (PyGObject *self)
{
  PgmViewportCursor cursor;

  pyg_begin_allow_threads;
  pgm_viewport_get_cursor (PGM_VIEWPORT (self->obj), &cursor);
  pyg_end_allow_threads;

  return pyg_enum_from_gtype (PGM_TYPE_VIEWPORT_CURSOR, cursor);
}

%%
override pgm_viewport_get_icon noargs
static PyObject *
_wrap_pgm_viewport_get_icon (PyGObject *self)
{
  PyObject *object;
  GdkPixbuf *icon;
  gint ret;

  pyg_begin_allow_threads;
  ret = pgm_viewport_get_icon (PGM_VIEWPORT (self->obj), &icon);
  pyg_end_allow_threads;

  if (PGM_ERROR_OK != ret)
    PyErr_SetString (PyExc_RuntimeError, "problem while getting icon pixbuf");

  if (NULL == icon)
    Py_RETURN_NONE;

  object = pygobject_new (G_OBJECT (icon));
  g_object_unref (icon);

  return object;
}

%%
override pgm_viewport_set_icon kwargs
static PyObject *
_wrap_pgm_viewport_set_icon (PyGObject *self,
                             PyObject *args,
                             PyObject *kwargs)
{
  static char *kwlist[] = { "icon", NULL };
  PyObject *icon;
  GdkPixbuf *cicon = NULL;
  gint ret;

  if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O:PgmViewport.set_icon",
                                    kwlist, &icon))
    return NULL;

  if (Py_None != icon)
    {
      if (!pygobject_check (icon, &PyGdkPixbuf_Type))
        {
          PyErr_SetString (PyExc_TypeError, "a gtk.gdk.Pixbuf is required");
          return NULL;
        }

      cicon = GDK_PIXBUF (pygobject_get (icon));
    }

  pyg_begin_allow_threads;
  ret = pgm_viewport_set_icon (PGM_VIEWPORT (self->obj), cicon);
  pyg_end_allow_threads;

  return pyg_enum_from_gtype (PGM_TYPE_ERROR, ret);
}

%%
override pgm_viewport_get_size noargs
static PyObject *
_wrap_pgm_viewport_get_size (PyGObject *self)
{
  gint width, height;
  PyObject *py_tuple = NULL;

  pyg_begin_allow_threads;
  pgm_viewport_get_size (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  py_tuple = PyTuple_New (2);
  PyTuple_SetItem (py_tuple, 0, PyInt_FromLong (width));
  PyTuple_SetItem (py_tuple, 1, PyInt_FromLong (height));

  return py_tuple;
}

%%
override pgm_viewport_get_alpha_blending noargs
static PyObject *
_wrap_pgm_viewport_get_alpha_blending (PyGObject *self)
{
  gboolean alpha_blending;

  pyg_begin_allow_threads;
  pgm_viewport_get_alpha_blending (PGM_VIEWPORT (self->obj), &alpha_blending);
  pyg_end_allow_threads;

  return PyBool_FromLong (alpha_blending);
}

%%
override pgm_viewport_get_opacity noargs
static PyObject *
_wrap_pgm_viewport_get_opacity (PyGObject *self)
{
  guchar opacity;
  PyObject *py_tuple = NULL;

  pyg_begin_allow_threads;
  pgm_viewport_get_opacity (PGM_VIEWPORT (self->obj), &opacity);
  pyg_end_allow_threads;

  return PyInt_FromLong ((long) opacity);
}

%%
override pgm_viewport_get_frame_rate noargs
static PyObject *
_wrap_pgm_viewport_get_frame_rate (PyGObject *self)
{
  guint frame_rate;

  pyg_begin_allow_threads;
  pgm_viewport_get_frame_rate (PGM_VIEWPORT (self->obj), &frame_rate);
  pyg_end_allow_threads;

  return PyInt_FromLong ((long) frame_rate);
}

%%
override pgm_viewport_get_fullscreen noargs
static PyObject *
_wrap_pgm_viewport_get_fullscreen (PyGObject *self)
{
  gboolean fullscreen;

  pyg_begin_allow_threads;
  pgm_viewport_get_fullscreen (PGM_VIEWPORT (self->obj), &fullscreen);
  pyg_end_allow_threads;

  return PyBool_FromLong (fullscreen);
}

%%
override pgm_viewport_get_iconified noargs
static PyObject *
_wrap_pgm_viewport_get_iconified (PyGObject *self)
{
  gboolean iconified;

  pyg_begin_allow_threads;
  pgm_viewport_get_iconified (PGM_VIEWPORT (self->obj), &iconified);
  pyg_end_allow_threads;

  return PyBool_FromLong (iconified);
}

%%
override pgm_viewport_get_embedding_id noargs
static PyObject *
_wrap_pgm_viewport_get_embedding_id (PyGObject *self)
{
  gulong embedding_id;

  pyg_begin_allow_threads;
  pgm_viewport_get_embedding_id (PGM_VIEWPORT (self->obj), &embedding_id);
  pyg_end_allow_threads;

  return PyInt_FromLong (embedding_id);
}

%%
override pgm_viewport_get_caps_mask noargs
static PyObject *
_wrap_pgm_viewport_get_caps_mask (PyGObject *self)
{
  PyObject *py_tuple = NULL;
  gulong mask = 0;
  guint size = 0;
  guint i;

  pyg_begin_allow_threads;
  pgm_viewport_get_caps_mask (PGM_VIEWPORT (self->obj), &mask);
  pyg_end_allow_threads;

  /* Get the size */
  for (i = 0; i < 3; i++)
    {
      if (mask & (1 << i))
        size++;
    }

  /* Build the tuple */
  py_tuple = PyTuple_New (size);

  /* And fill it */
  size = 0;
  for (i = 0; i < 3; i++)
    {
      if (mask & (1 << i))
        {
          PyTuple_SetItem (py_tuple, size,
                           pyg_flags_from_gtype (PGM_TYPE_VIEWPORT_CAPACITY,
                                                 mask & (1 << i)));
          size++;
        }
    }

  return py_tuple;
}

%%
override pgm_viewport_get_max_texture_size noargs
static PyObject *
_wrap_pgm_viewport_get_max_texture_size (PyGObject *self)
{
  guint32 max_texture_size;

  pyg_begin_allow_threads;
  pgm_viewport_get_max_texture_size (PGM_VIEWPORT (self->obj),
                                     &max_texture_size);
  pyg_end_allow_threads;

  return PyInt_FromLong (max_texture_size);
}

%%
override pgm_viewport_get_pixel_formats noargs
static PyObject *
_wrap_pgm_viewport_get_pixel_formats (PyGObject *self)
{
  PyObject *py_tuple = NULL;
  gulong mask = 0;
  guint size = 0;
  guint i;

  pyg_begin_allow_threads;
  pgm_viewport_get_pixel_formats (PGM_VIEWPORT (self->obj), &mask);
  pyg_end_allow_threads;

  /* Get the size */
  for (i = 0; i < PGM_IMAGE_NB_PIXEL_FORMATS; i++)
    {
      if (mask & (1 << i))
        size++;
    }

  /* Build the tuple */
  py_tuple = PyTuple_New (size);

  /* And fill it */
  size = 0;
  for (i = 0; i < PGM_IMAGE_NB_PIXEL_FORMATS; i++)
    {
      if (mask & (1 << i))
        {
          PyTuple_SetItem (py_tuple, size,
                           pyg_flags_from_gtype (PGM_TYPE_IMAGE_PIXEL_FORMAT,
                                                 mask & (1 << i)));
          size++;
        }
    }

  return py_tuple;
}

%%
override pgm_viewport_get_screen_resolution noargs
static PyObject *
_wrap_pgm_viewport_get_screen_resolution (PyGObject *self)
{
  gint width, height;
  PyObject *py_tuple = NULL;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_resolution (PGM_VIEWPORT (self->obj), &width,
                                      &height);
  pyg_end_allow_threads;

  py_tuple = PyTuple_New (2);
  PyTuple_SetItem (py_tuple, 0, PyInt_FromLong (width));
  PyTuple_SetItem (py_tuple, 1, PyInt_FromLong (height));

  return py_tuple;
}

%%
override pgm_viewport_get_screen_size_mm noargs
static PyObject *
_wrap_pgm_viewport_get_screen_size_mm (PyGObject *self)
{
  gint width, height;
  PyObject *py_tuple = NULL;

  pyg_begin_allow_threads;
  pgm_viewport_get_screen_size_mm (PGM_VIEWPORT (self->obj), &width, &height);
  pyg_end_allow_threads;

  py_tuple = PyTuple_New (2);
  PyTuple_SetItem (py_tuple, 0, PyInt_FromLong (width));
  PyTuple_SetItem (py_tuple, 1, PyInt_FromLong (height));

  return py_tuple;
}

%%
override pgm_viewport_get_canvas noargs
static PyObject *
_wrap_pgm_viewport_get_canvas (PyGObject *self)
{
  PgmCanvas* canvas;
  PyObject* py_canvas;
  PgmError ret;

  pyg_begin_allow_threads;
  ret = pgm_viewport_get_canvas (PGM_VIEWPORT (self->obj), &canvas);
  pyg_end_allow_threads;
  /* TODO: error management */

  py_canvas = pygobject_new ((GObject *) canvas);
  if (canvas)
    gst_object_unref (canvas);
  return py_canvas;
}

%%
override pgm_viewport_set_canvas kwargs
static PyObject *
_wrap_pgm_viewport_set_canvas (PyGObject *self,
                               PyObject *args,
                               PyObject *kwargs)
{
  static char *kwlist[] = { "canvas", NULL };
  PyObject  *py_canvas;
  gint ret;

  if (!PyArg_ParseTupleAndKeywords (args, kwargs,"O:PgmViewport.set_canvas",
                                    kwlist, &py_canvas))
    return NULL;

  if (!pygobject_check (py_canvas, &PyPgmCanvas_Type))
    {
      if (py_canvas == Py_None)
        {
          pyg_begin_allow_threads;
          ret = pgm_viewport_set_canvas (PGM_VIEWPORT (self->obj), NULL);
          pyg_end_allow_threads;
        }
      else
        {
          PyErr_SetString (PyExc_TypeError,
                           "a pgm.Canvas or None object is required");
          return NULL;
        }
    }
  else
    {
      PyGObject *canvas = (PyGObject*) py_canvas;
      pyg_begin_allow_threads;
      ret = pgm_viewport_set_canvas (PGM_VIEWPORT (self->obj),
                                     PGM_CANVAS (canvas->obj));
      pyg_end_allow_threads;
    }

  return pyg_enum_from_gtype (PGM_TYPE_ERROR, ret);
}

%%
override pgm_viewport_get_canvas_rotation noargs
static PyObject *
_wrap_pgm_viewport_get_canvas_rotation (PyGObject *self)
{
  PgmViewportRotation rotation;

  pyg_begin_allow_threads;
  pgm_viewport_get_canvas_rotation (PGM_VIEWPORT (self->obj), &rotation);
  pyg_end_allow_threads;

  return pyg_enum_from_gtype (PGM_TYPE_VIEWPORT_ROTATION, rotation);
}

%%
override pgm_viewport_get_canvas_reflection noargs
static PyObject *
_wrap_pgm_viewport_get_canvas_reflection (PyGObject *self)
{
  PgmViewportReflection reflection;

  pyg_begin_allow_threads;
  pgm_viewport_get_canvas_reflection (PGM_VIEWPORT (self->obj), &reflection);
  pyg_end_allow_threads;

  return pyg_enum_from_gtype (PGM_TYPE_VIEWPORT_REFLECTION, reflection);
}

%%
override pgm_viewport_get_message_filter noargs
static PyObject *
_wrap_pgm_viewport_get_message_filter (PyGObject *self)
{
  PyObject *py_filter = NULL;
  GList *filter = NULL;
  GList *walk = NULL;
  guint i = 0;
  glong message;
  guint size;

  pyg_begin_allow_threads;
  pgm_viewport_get_message_filter (PGM_VIEWPORT (self->obj), &filter);
  pyg_end_allow_threads;

  filter = g_list_reverse (filter);
  py_filter = PyList_New (g_list_length (filter));
  walk = filter;
  while (walk)
    {
      message = (long) walk->data;
      PyList_SetItem (py_filter, i, PyInt_FromLong (message));
      walk = walk->next;
      i++;
    }

  if (filter)
    g_list_free (filter);

  return py_filter;
}

%%
override pgm_viewport_set_message_filter args
static PyObject *
_wrap_pgm_viewport_set_message_filter (PyGObject *self,
                                       PyObject *args)
{
  PyObject *py_filter;
  gint ret;

  py_filter = PyTuple_GetItem (args, 0);

  if (!pygobject_check (py_filter, &PyList_Type))
    {
      PyErr_SetString (PyExc_TypeError, "a List containing integers is "
                       "required");
      return NULL;
    }
  else
    {
      GList *filter = NULL;
      guint i;

      for (i = 0; i < PyList_Size (py_filter); i++)
        {
          PyObject *py_message;
          guint message;

          py_message = PyList_GetItem (py_filter, i);
          if (!PyInt_Check (py_message))
            {
              if (filter)
                g_list_free (filter);
              PyErr_SetString (PyExc_TypeError, "a List containing integers "
                               "is required");
              return NULL;
            }
          message = (guint) PyInt_AsLong (py_message);
          filter = g_list_prepend (filter, GUINT_TO_POINTER (message));
        }

      pyg_begin_allow_threads;
      ret = pgm_viewport_set_message_filter (PGM_VIEWPORT (self->obj), filter);
      pyg_end_allow_threads;

      if (filter)
        g_list_free (filter);
    }

  return pyg_enum_from_gtype (PGM_TYPE_ERROR, ret);
}

%%
override pgm_viewport_from_canvas kwargs
static PyObject *
_wrap_pgm_viewport_from_canvas (PyGObject *self,
                                PyObject *args,
                                PyObject *kwargs)
{
  static char *kwlist[] = { "x", "y", "z", NULL };
  PyObject *py_tuple = NULL;
  gfloat viewport_x, viewport_y, viewport_z;
  gfloat x, y, z;
  PgmError ret;

  if (!PyArg_ParseTupleAndKeywords (args, kwargs, "fff", kwlist, &x, &y, &z))
    return NULL;

  pyg_begin_allow_threads;
  ret = pgm_viewport_from_canvas (PGM_VIEWPORT (self->obj), &viewport_x,
                                  &viewport_y, &viewport_z, x, y, z);
  pyg_end_allow_threads;

  py_tuple = PyTuple_New (3);
  PyTuple_SetItem (py_tuple, 0, PyFloat_FromDouble (viewport_x));
  PyTuple_SetItem (py_tuple, 1, PyFloat_FromDouble (viewport_y));
  PyTuple_SetItem (py_tuple, 2, PyFloat_FromDouble (viewport_z));

  return py_tuple;
}

%%
override pgm_viewport_to_canvas kwargs
static PyObject *
_wrap_pgm_viewport_to_canvas (PyGObject *self,
                              PyObject *args,
                              PyObject *kwargs)
{
  static char *kwlist[] = { "x", "y", "z", NULL };
  PyObject *py_tuple = NULL;
  gfloat canvas_x, canvas_y, canvas_z;
  gfloat x, y, z;
  PgmError ret;

  if (!PyArg_ParseTupleAndKeywords (args, kwargs, "fff", kwlist, &x, &y, &z))
    return NULL;

  pyg_begin_allow_threads;
  ret = pgm_viewport_to_canvas (PGM_VIEWPORT (self->obj), &canvas_x,
                                &canvas_y, &canvas_z, x, y, z);
  pyg_end_allow_threads;

  py_tuple = PyTuple_New (3);
  PyTuple_SetItem (py_tuple, 0, PyFloat_FromDouble (canvas_x));
  PyTuple_SetItem (py_tuple, 1, PyFloat_FromDouble (canvas_y));
  PyTuple_SetItem (py_tuple, 2, PyFloat_FromDouble (canvas_z));

  return py_tuple;
}