Merge fixes to the python binding from my branch
[vlc.git] / bindings / python / vlcglue.c
1 /*****************************************************************************
2  * vlcglue.c: VLC Module
3  *****************************************************************************
4  * Copyright (C) 1998-2004 the VideoLAN team
5  * $Id: vlc.c 12667 2005-09-25 10:19:26Z zorglub $
6  *
7  * Authors: Olivier Aubert <oaubert at bat710.univ-lyon1.fr>
8  *          ClĂ©ment Stenac <zorglub@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24 #include "vlcglue.h"
25
26 /**************************************************************************
27  * VLC Module
28  **************************************************************************/
29
30 #ifndef vlcMODINIT_FUNC /* declarations for DLL import/export */
31 #define vlcMODINIT_FUNC void
32 #endif
33
34 static PyMethodDef vlc_methods[] = {
35     {NULL}  /* Sentinel */
36 };
37
38 /* Module globals */
39 PyObject* MediaControl_InternalException          = NULL;
40 PyObject* MediaControl_PositionKeyNotSupported    = NULL;
41 PyObject *MediaControl_PositionOriginNotSupported = NULL;
42 PyObject* MediaControl_InvalidPosition            = NULL;
43 PyObject *MediaControl_PlaylistException          = NULL;
44
45 vlcMODINIT_FUNC  initvlc(void)
46 {
47     PyObject* m;
48
49     PyPosition_Type.tp_new = PyType_GenericNew;
50     PyPosition_Type.tp_alloc = PyType_GenericAlloc;
51
52     if (PyType_Ready(&PyPosition_Type) < 0)
53         return;
54     if (PyType_Ready(&MediaControl_Type) < 0)
55         return;
56 #ifdef VLCOBJECT_SUPPORT
57     if (PyType_Ready(&vlcObject_Type) < 0)
58         return;
59 #endif
60
61         /*  PyEval_InitThreads(); */
62
63         /* Have a look at
64 http://base.bel-epa.com/pyapache/Python/MySQL-python/MySQL-python-0.3.0/_mysqlmodule.c */
65
66     m = Py_InitModule3( "vlc", vlc_methods,
67                         "VLC media player embedding module.");
68
69     /* Exceptions */
70     MediaControl_InternalException =
71             PyErr_NewException("vlc.InternalException", NULL, NULL);
72     PyModule_AddObject(m, "InternalException", MediaControl_InternalException);
73
74     MediaControl_PositionKeyNotSupported =
75             PyErr_NewException("vlc.PositionKeyNotSupported", NULL, NULL);
76     PyModule_AddObject(m, "PositionKeyNotSupported",
77                     MediaControl_PositionKeyNotSupported);
78
79     MediaControl_PositionOriginNotSupported=
80             PyErr_NewException("vlc.InvalidPosition", NULL, NULL);
81     PyModule_AddObject(m, "PositionOriginNotSupported",
82                     MediaControl_PositionOriginNotSupported);
83
84     MediaControl_InvalidPosition =
85             PyErr_NewException("vlc.InvalidPosition", NULL, NULL);
86     PyModule_AddObject(m, "InvalidPosition", MediaControl_InvalidPosition);
87
88     MediaControl_PlaylistException =
89             PyErr_NewException("vlc.PlaylistException", NULL, NULL);
90     PyModule_AddObject(m, "PlaylistException", MediaControl_PlaylistException);
91
92     /* Types */
93     Py_INCREF(&PyPosition_Type);
94     PyModule_AddObject(m, "Position", (PyObject *)&PyPosition_Type);
95     Py_INCREF(&MediaControl_Type);
96     PyModule_AddObject(m, "MediaControl", (PyObject *)&MediaControl_Type);
97 #ifdef VLCOBJECT_SUPPORT
98     Py_INCREF(&vlcObject_Type);
99     PyModule_AddObject(m, "Object", (PyObject *)&vlcObject_Type);
100 #endif
101
102     /* Constants */
103     PyModule_AddIntConstant(m, "AbsolutePosition",
104                     mediacontrol_AbsolutePosition);
105     PyModule_AddIntConstant(m, "RelativePosition",
106                     mediacontrol_RelativePosition);
107     PyModule_AddIntConstant(m, "ModuloPosition",
108                     mediacontrol_ModuloPosition);
109
110     PyModule_AddIntConstant(m, "ByteCount",        mediacontrol_ByteCount);
111     PyModule_AddIntConstant(m, "SampleCount",      mediacontrol_SampleCount);
112     PyModule_AddIntConstant(m, "MediaTime",        mediacontrol_MediaTime);
113     PyModule_AddIntConstant(m, "PlayingStatus",    mediacontrol_PlayingStatus);
114     PyModule_AddIntConstant(m, "PauseStatus", mediacontrol_PauseStatus);
115     PyModule_AddIntConstant(m, "ForwardStatus", mediacontrol_ForwardStatus);
116     PyModule_AddIntConstant(m, "BackwardStatus", mediacontrol_BackwardStatus);
117     PyModule_AddIntConstant(m, "InitStatus", mediacontrol_InitStatus);
118     PyModule_AddIntConstant(m, "EndStatus", mediacontrol_EndStatus);
119     PyModule_AddIntConstant(m, "UndefinedStatus", mediacontrol_UndefinedStatus);
120 }
121
122
123 /* Make libpostproc happy... */
124 void * fast_memcpy(void * to, const void * from, size_t len)
125 {
126   return memcpy(to, from, len);
127 }
128
129
130 /*****************************************************************************
131  * VLCObject implementation
132  *****************************************************************************/
133
134 #ifdef VLCOBJECT_SUPPORT
135
136 static PyObject *vlcObject_new(
137                 PyTypeObject *type, PyObject *args, PyObject *kwds)
138 {
139     vlcObject *self;
140     vlc_object_t *p_object;
141     int i_id;
142
143     self = PyObject_New(vlcObject, &vlcObject_Type);
144
145     if ( !PyArg_ParseTuple(args, "i", &i_id) )
146       return NULL;
147
148     /* Maybe we were already initialized */
149     p_object = (vlc_object_t*)vlc_current_object(i_id);
150
151     if (! p_object)
152     {
153         /* Try to initialize */
154         i_id = VLC_Create();
155         p_object = (vlc_object_t*)vlc_current_object(i_id);
156     }
157
158     if (! p_object)
159     {
160         PyErr_SetString(PyExc_StandardError, "Unable to get object.");
161         return NULL;
162     }
163
164     self->p_object = p_object;
165     self->b_released = 0;
166
167     Py_INCREF( self ); /* Ah bon ? */
168     return (PyObject *)self;
169 }
170
171 static PyObject * vlcObject_release( PyObject *self )
172 {
173     if( VLCSELF->b_released == 0 )
174     {
175         vlc_object_release( VLCSELF->p_object );
176         VLCSELF->b_released = 1;
177     }
178     Py_INCREF( Py_None);
179     return Py_None;
180 }
181
182 static void  vlcObject_dealloc(PyObject *self)
183 {
184     vlcObject_release( self );
185     PyMem_DEL(self);
186 }
187
188 static PyObject * vlcObject_find_object(PyObject *self, PyObject *args)
189 {
190     vlcObject *retval;
191     vlc_object_t *p_obj;
192     char *psz_name;
193     int i_object_type;
194
195     if ( !PyArg_ParseTuple(args, "s", &psz_name) )
196       return NULL;
197
198     /* psz_name is in
199        (aout, decoder, input, httpd, intf, playlist, root, vlc, vout)
200     */
201     switch (psz_name[0])
202     {
203         case 'a':
204             i_object_type = VLC_OBJECT_AOUT;
205             break;
206         case 'd':
207             i_object_type = VLC_OBJECT_DECODER;
208             break;
209         case 'h':
210             i_object_type = VLC_OBJECT_HTTPD;
211             break;
212         case 'i':
213             if (strlen(psz_name) < 3)
214                     i_object_type = VLC_OBJECT_INTF;
215             else if (psz_name[2] == 't')
216                     i_object_type = VLC_OBJECT_INTF;
217             else
218                     i_object_type = VLC_OBJECT_INPUT;
219             break;
220         case 'p':
221             i_object_type = VLC_OBJECT_PLAYLIST;
222             break;
223         case 'r':
224             i_object_type = VLC_OBJECT_ROOT;
225             break;
226         case 'v':
227             if (strlen(psz_name) < 3)
228                     i_object_type = VLC_OBJECT_VLC;
229             else if (psz_name[1] == 'l')
230                     i_object_type = VLC_OBJECT_VLC;
231             else
232                     i_object_type = VLC_OBJECT_VOUT;
233             break;
234         default:
235             /* FIXME: raise an exception */
236             return Py_None;
237     }
238
239     p_obj = vlc_object_find( VLCSELF->p_object, i_object_type, FIND_ANYWHERE );
240
241     if (! p_obj)
242     {
243         Py_INCREF(Py_None);
244         return Py_None;
245     }
246
247     retval = PyObject_New(vlcObject, &vlcObject_Type);
248
249     retval->p_object = p_obj;
250
251     return (PyObject *)retval;
252 }
253
254 static PyObject * vlcObject_info(PyObject *self, PyObject *args)
255 {
256     PyObject *retval;
257     vlc_object_t *p_obj;
258
259     p_obj = VLCSELF->p_object;
260
261     /* Return information about the object as a dict. */
262     retval = PyDict_New();
263
264     PyDict_SetItemString(retval, "object-id",
265                     Py_BuildValue("l", p_obj->i_object_id));
266     PyDict_SetItemString(retval, "object-type",
267                   Py_BuildValue("s", p_obj->psz_object_type));
268     PyDict_SetItemString(retval, "object-name",
269                   Py_BuildValue("s", p_obj->psz_object_name));
270     PyDict_SetItemString(retval, "thread",
271                   PyBool_FromLong(p_obj->b_thread));
272     PyDict_SetItemString(retval, "thread-id",
273                   PyLong_FromLongLong(p_obj->thread_id));
274     PyDict_SetItemString(retval, "refcount",
275                   PyInt_FromLong(p_obj->i_refcount));
276
277     return retval;
278 }
279
280 static PyObject * vlcObject_find_id(PyObject *self, PyObject *args)
281 {
282     vlcObject *retval;
283     vlc_object_t* p_object;
284     int i_id;
285
286     if ( !PyArg_ParseTuple(args, "i", &i_id) )
287     {
288         PyErr_SetString(PyExc_StandardError, "Error: no id was given.\n");
289         return Py_None;
290     }
291
292     p_object = (vlc_object_t*)vlc_current_object(i_id);
293
294     if (! p_object)
295     {
296         Py_INCREF(Py_None);
297         return Py_None;
298     }
299
300     retval = PyObject_NEW(vlcObject, &vlcObject_Type);
301
302     retval->p_object = p_object;
303
304     return (PyObject *)retval;
305 }
306
307 /* Do a var_Get call on the object. Parameter: the variable name. */
308 /* FIXME: We should make them attributes */
309 static PyObject * vlcObject_var_get(PyObject *self, PyObject *args)
310 {
311     PyObject *retval;
312     vlc_value_t value;
313     char *psz_name;
314     int i_type;
315
316     if ( !PyArg_ParseTuple(args, "s", &psz_name) )
317     {
318         PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n");
319         Py_INCREF(Py_None);
320         return Py_None;
321     }
322
323     if( var_Get( VLCSELF->p_object, psz_name, &value ) != VLC_SUCCESS )
324     {
325             PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n");
326             Py_INCREF(Py_None);
327             return Py_None;
328     }
329
330     i_type = var_Type (VLCSELF->p_object, psz_name);
331
332     switch (i_type)
333     {
334             case VLC_VAR_VOID   :
335                     retval = PyString_FromString("A void variable");
336                     break;
337             case VLC_VAR_BOOL      :
338                     retval = PyBool_FromLong(value.b_bool);
339                     break;
340             case VLC_VAR_INTEGER   :
341                     retval = PyInt_FromLong((long)value.i_int);
342                     break;
343             case VLC_VAR_HOTKEY   :
344                     retval = PyString_FromFormat("A hotkey variable (%d)", value.i_int);
345                     break;
346             case VLC_VAR_FILE      :
347             case VLC_VAR_STRING    :
348             case VLC_VAR_DIRECTORY :
349             case VLC_VAR_VARIABLE  :
350                     retval = PyString_FromString(value.psz_string);
351                     break;
352             case VLC_VAR_MODULE   :
353                     retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type);
354                     ((vlcObject*)retval)->p_object = value.p_object;
355                     break;
356             case VLC_VAR_FLOAT     :
357                     retval = PyFloat_FromDouble((double)value.f_float);
358                     break;
359             case VLC_VAR_TIME      :
360                     retval = PyLong_FromLongLong(value.i_time);
361                     break;
362             case VLC_VAR_ADDRESS   :
363                     retval = PyString_FromString("A VLC address (not handled yet)");
364                     break;
365             case VLC_VAR_LIST      :
366                     retval = PyString_FromString("A VLC list (not handled yet)");
367                     break;
368             case VLC_VAR_MUTEX :
369                     retval = PyString_FromString("A mutex");
370                     break;
371             default:
372                     retval = Py_None;
373     }
374
375     Py_INCREF(retval);
376     return retval;
377 }
378
379 static PyObject * vlcObject_var_type(PyObject *self,
380                 PyObject *args)
381 {
382         char *psz_name;
383         PyObject *retval;
384         int i_type;
385
386         if ( !PyArg_ParseTuple(args, "s", &psz_name))
387         {
388                 PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n");
389                 Py_INCREF(Py_None);
390                 return Py_None;
391         }
392
393         i_type = var_Type(VLCSELF->p_object, psz_name);
394
395         switch (i_type)
396         {
397                 case VLC_VAR_VOID   :
398                         retval = PyString_FromString("Void");
399                         break;
400                 case VLC_VAR_BOOL      :
401                         retval = PyString_FromString("Boolean");
402                         break;
403                 case VLC_VAR_INTEGER   :
404                         retval = PyString_FromString("Integer");
405                         break;
406                 case VLC_VAR_HOTKEY   :
407                         retval = PyString_FromString("Hotkey");
408                         break;
409                 case VLC_VAR_FILE      :
410                         retval = PyString_FromString("File");
411                         break;
412                 case VLC_VAR_STRING    :
413                         retval = PyString_FromString("String");
414                         break;
415                 case VLC_VAR_DIRECTORY :
416                         retval = PyString_FromString("Directory");
417                         break;
418                 case VLC_VAR_VARIABLE  :
419                         retval = PyString_FromString("Variable");
420                         break;
421                 case VLC_VAR_MODULE   :
422                         retval = PyString_FromString("Module");
423                         break;
424                 case VLC_VAR_FLOAT     :
425                         retval = PyString_FromString("Float");
426                         break;
427                 case VLC_VAR_TIME      :
428                         retval = PyString_FromString("Time");
429                         break;
430                 case VLC_VAR_ADDRESS   :
431                         retval = PyString_FromString("Address");
432                         break;
433                 case VLC_VAR_LIST      :
434                         retval = PyString_FromString("List");
435                         break;
436                 case VLC_VAR_MUTEX :
437                         retval = PyString_FromString("Mutex");
438                         break;
439                 default:
440                         retval = PyString_FromString("Unknown");
441         }
442         return retval;
443 }
444
445 /* Do a var_Set call on the object. Parameter: the variable name. */
446 /* FIXME: We should make them attributes */
447 static PyObject * vlcObject_var_set(PyObject *self,
448                 PyObject *args)
449 {
450         vlc_value_t value;
451         char *psz_name;
452         PyObject *py_value;
453         int i_type;
454         vlc_object_t *p_obj;
455
456         if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) )
457         {
458                 PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n");
459                 Py_INCREF(Py_None);
460                 return Py_None;
461         }
462
463         p_obj = VLCSELF->p_object;
464         i_type = var_Type(p_obj, psz_name);
465
466         switch (i_type)
467         {
468                 case VLC_VAR_VOID   :
469                         break;
470                 case VLC_VAR_BOOL      :
471                         value.b_bool = PyInt_AsLong(py_value);
472                         break;
473                 case VLC_VAR_INTEGER   :
474                 case VLC_VAR_HOTKEY   :
475                         value.i_int = PyInt_AsLong(py_value);
476                         break;
477                 case VLC_VAR_FILE      :
478                 case VLC_VAR_STRING    :
479                 case VLC_VAR_DIRECTORY :
480                 case VLC_VAR_VARIABLE  :
481                         value.psz_string = strdup(PyString_AsString(py_value));
482                         break;
483                 case VLC_VAR_MODULE   :
484                         /* FIXME: we should check the PyObject type and get its p_object */
485                         value.p_object = ((vlcObject*)p_obj)->p_object;
486                         break;
487                 case VLC_VAR_FLOAT     :
488                         value.f_float = PyFloat_AsDouble(py_value);
489                         break;
490                 case VLC_VAR_TIME      :
491                         value.i_time = PyLong_AsLongLong(py_value);
492                         break;
493                 case VLC_VAR_ADDRESS   :
494                         value.p_address = (char*)PyLong_AsVoidPtr(py_value);
495                         break;
496                 case VLC_VAR_LIST      :
497                         /* FIXME */
498                         value.p_list = NULL;
499                         break;
500                 case VLC_VAR_MUTEX :
501                         break;
502         }
503
504         var_Set(p_obj, psz_name, value);
505
506         Py_INCREF(Py_None);
507         return Py_None;
508 }
509
510 static PyObject * vlcObject_var_list(PyObject *self,
511                 PyObject *args)
512 {
513         PyObject *retval;
514         int i_size;
515         int i_index;
516
517         i_size = VLCSELF->p_object->i_vars;
518         retval = PyTuple_New(i_size);
519
520         for (i_index = 0 ; i_index < i_size ; i_index++)
521         {
522                 PyTuple_SetItem(retval, i_index, 
523                                 Py_BuildValue("s", VLCSELF->p_object->p_vars[i_index].psz_name));
524         }
525
526         /* Py_INCREF(retval); */
527         return retval;
528 }
529
530 /* Do a config_Get call on the object. Parameter: the variable name. */
531 static PyObject * vlcObject_config_get(PyObject *self,
532                 PyObject *args)
533 {
534         PyObject *retval;
535         vlc_value_t value;
536         char *psz_name;
537         module_config_t *p_config;
538
539         if ( !PyArg_ParseTuple(args, "s", &psz_name) )
540         {
541                 PyErr_SetString(PyExc_StandardError, "Error: no config variable name was given.\n");
542                 Py_INCREF(Py_None);
543                 return Py_None;
544         }
545
546         p_config = config_FindConfig( VLCSELF->p_object, psz_name );
547
548         if( !p_config )
549         {
550                 PyErr_SetString(PyExc_StandardError, "Error: config variable does not exist.\n");
551                 Py_INCREF(Py_None);
552                 return Py_None;
553         }
554
555         switch (p_config->i_type)
556         {
557                 case CONFIG_ITEM_BOOL      :
558                         retval = PyBool_FromLong(p_config->i_value);
559                         break;
560                 case CONFIG_ITEM_INTEGER   :
561                         retval = PyInt_FromLong((long)p_config->i_value);
562                         break;
563                 case CONFIG_ITEM_KEY   :
564                         retval = PyString_FromFormat("A hotkey variable (%d)", p_config->i_value);
565                         break;
566                 case CONFIG_ITEM_FILE      :
567                 case CONFIG_ITEM_STRING    :
568                 case CONFIG_ITEM_DIRECTORY :
569                 case CONFIG_ITEM_MODULE    :
570                         vlc_mutex_lock( p_config->p_lock );
571                         if( p_config->psz_value )
572                                 retval = PyString_FromString( p_config->psz_value );
573                         else
574                                 retval = PyString_FromString( "" );
575                         vlc_mutex_unlock( p_config->p_lock );
576                         break;
577                         retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type);
578                         ((vlcObject*)retval)->p_object = value.p_object;
579                         break;
580                 case CONFIG_ITEM_FLOAT     :
581                         retval = PyFloat_FromDouble((double)p_config->f_value);
582                         break;
583                 default:
584                         retval = Py_None;
585                         Py_INCREF(retval);
586         }
587
588         return retval;
589 }
590
591 /* Do a var_Set call on the object. Parameter: the variable name. */
592 /* FIXME: We should make them attributes */
593 static PyObject * vlcObject_config_set(PyObject *self,
594                 PyObject *args)
595 {
596         char *psz_name;
597         PyObject *py_value;
598         vlc_object_t *p_obj;
599         module_config_t *p_config;
600
601
602         if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) )
603         {
604             PyErr_SetString(PyExc_StandardError,
605                             "Error: no variable name was given.\n");
606             Py_INCREF(Py_None);
607             return Py_None;
608         }
609
610         p_obj = VLCSELF->p_object;
611         p_config = config_FindConfig( p_obj, psz_name );
612         /* sanity checks */
613         if( !p_config )
614         {
615             PyErr_SetString(PyExc_StandardError,
616                             "Error: option does not exist.\n");
617             Py_INCREF(Py_None);
618             return Py_None;
619         }
620
621         switch (p_config->i_type)
622         {
623                 case CONFIG_ITEM_BOOL      :
624                 case CONFIG_ITEM_INTEGER   :
625                 case CONFIG_ITEM_KEY       :
626                         config_PutInt(p_obj, psz_name, PyInt_AsLong(py_value));
627                         break;
628                 case CONFIG_ITEM_FILE      :
629                 case CONFIG_ITEM_STRING    :
630                 case CONFIG_ITEM_DIRECTORY :
631                 case CONFIG_ITEM_MODULE   :
632                         config_PutPsz(p_obj, psz_name, PyString_AsString(py_value));
633                         break;
634                 case CONFIG_ITEM_FLOAT     :
635                         config_PutFloat(p_obj, psz_name, PyFloat_AsDouble(py_value));
636                         break;
637         }
638         Py_INCREF(Py_None);
639         return Py_None;
640 }
641
642 static PyObject * vlcObject_children(PyObject *self,
643                 PyObject *args)
644 {
645         PyObject *retval;
646         int i_size;
647         int i_index;
648
649         i_size = VLCSELF->p_object->i_children;
650         retval = PyTuple_New(i_size);
651
652         for (i_index = 0 ; i_index < i_size ; i_index++)
653         {
654             PyTuple_SetItem(retval, i_index,
655                  Py_BuildValue("i",
656                       VLCSELF->p_object->pp_children[i_index]->i_object_id));
657         }
658
659         /* Py_INCREF(retval); */
660         return retval;
661 }
662
663
664 /* Method table */
665 static PyMethodDef vlcObject_methods[] =
666 {
667     { "get", vlcObject_var_get, METH_VARARGS,
668       "get(str) -> value   Get a variable value."},
669     { "set", vlcObject_var_set, METH_VARARGS,
670       "set(str, value)     Set a variable value" },
671     { "config_get", vlcObject_config_get, METH_VARARGS,
672       "get(str) -> value   Get an option value." },
673     { "config_set", vlcObject_config_set, METH_VARARGS,
674       "set(str, value)     Set an option value" },
675     { "type", vlcObject_var_type, METH_VARARGS,
676       "type(str) -> str     Get a variable type" },
677     { "list", vlcObject_var_list, METH_VARARGS,
678       "list()             List the available variables" },
679     { "children", vlcObject_children, METH_VARARGS,
680       "children()             List the children ids" },
681     { "find_object", vlcObject_find_object, METH_VARARGS,
682       "find_object(str) -> Object     Find the object of a given type.\n\nAvailable types are : aout, decoder, input, httpd, intf, playlist, root, vlc, vout"},
683     { "find_id", vlcObject_find_id, METH_VARARGS,
684       "find_id(int) -> Object      Find an object by id" },
685     { "info", vlcObject_info, METH_VARARGS,
686        "info() -> dict    Return information about the object" },
687     { "release", vlcObject_release, METH_VARARGS,
688       "release() ->     Release the VLC Object" },
689     { NULL, NULL, 0, NULL },
690 };
691
692 static PyTypeObject vlcObject_Type =
693 {
694     PyObject_HEAD_INIT(NULL)
695     0,                         /*ob_size*/
696     "vlc.Object",       /*tp_name*/
697     sizeof(vlcObject_Type), /*tp_basicsize*/
698     0,                         /*tp_itemsize*/
699     (destructor)vlcObject_dealloc,      /*tp_dealloc*/
700     0,                         /*tp_print*/
701     0,                         /*tp_getattr*/
702     0,                         /*tp_setattr*/
703     0,                         /*tp_compare*/
704     0,                         /*tp_repr*/
705     0,                         /*tp_as_number*/
706     0,                         /*tp_as_sequence*/
707     0,                         /*tp_as_mapping*/
708     0,                         /*tp_hash */
709     0,                         /*tp_call*/
710     0,                         /*tp_str*/
711     0,                         /*tp_getattro*/
712     0,                         /*tp_setattro*/
713     0,                         /*tp_as_buffer*/
714     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
715     "Explore VLC objects.",  /* tp_doc */
716     0,                     /* tp_traverse */
717     0,                     /* tp_clear */
718     0,                     /* tp_richcompare */
719     0,                     /* tp_weaklistoffset */
720     0,                     /* tp_iter */
721     0,                     /* tp_iternext */
722     vlcObject_methods,             /* tp_methods */
723     0,             /* tp_members */
724     0,                         /* tp_getset */
725     0,                         /* tp_base */
726     0,                         /* tp_dict */
727     0,                         /* tp_descr_get */
728     0,                         /* tp_descr_set */
729     0,                         /* tp_dictoffset */
730     0,                         /* tp_init */
731     0,                         /* tp_alloc */
732     vlcObject_new,          /* tp_new */
733 };
734
735 #endif
736
737
738 /*****************************************************************************
739  * VLC MediaControl object implementation
740  *****************************************************************************/
741
742 static PyObject *MediaControl_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
743 {
744     MediaControl *self;
745     mediacontrol_Exception *exception = NULL;
746     PyObject* py_list = NULL;
747     char** ppsz_args = NULL;
748
749     self = PyObject_New(MediaControl, &MediaControl_Type);
750
751     if (PyArg_ParseTuple(args, "O", &py_list))
752     {
753         int i_size;
754         int i_index;
755
756         Py_INCREF(py_list);
757         if (! PySequence_Check(py_list))
758         {
759             PyErr_SetString(PyExc_TypeError, "Parameter must be a sequence.");
760             return NULL;
761         }
762         i_size = PySequence_Size(py_list);
763         ppsz_args = malloc(i_size + 1);
764         if (! ppsz_args)
765         {
766             PyErr_SetString(PyExc_MemoryError, "Out of memory");
767             return NULL;
768         }
769
770         for ( i_index = 0; i_index < i_size; i_index++ )
771         {
772             ppsz_args[i_index] =
773                strdup( PyString_AsString( PyObject_Str(
774                                                PySequence_GetItem(py_list,
775                                                     i_index ) ) ) );
776         }
777         ppsz_args[i_size] = NULL;
778         Py_DECREF(py_list);
779     }
780
781     Py_BEGIN_ALLOW_THREADS
782     MC_TRY;
783     self->mc = mediacontrol_new( ppsz_args, exception );
784     MC_EXCEPT;
785     Py_END_ALLOW_THREADS
786
787     Py_INCREF(self);
788     return (PyObject *)self;
789 }
790
791 static void MediaControl_dealloc(PyObject *self)
792 {
793     PyMem_DEL(self);
794 }
795
796 /**
797  *  Returns the current position in the stream. The returned value can
798    be relative or absolute (according to PositionOrigin) and the unit
799    is set by PositionKey
800  */
801 static PyObject * MediaControl_get_media_position(
802                                       PyObject *self, PyObject *args)
803 {
804     mediacontrol_Position* pos;
805     mediacontrol_Exception* exception = NULL;
806     PyObject *py_origin;
807     PyObject *py_key;
808     PyObject *py_retval;
809     mediacontrol_PositionOrigin origin;
810     mediacontrol_PositionKey key;
811
812     if( !PyArg_ParseTuple( args, "OO", &py_origin, &py_key ) )
813         return NULL;
814
815     origin = positionOrigin_py_to_c(py_origin);
816     key    = positionKey_py_to_c(py_key);
817
818     Py_BEGIN_ALLOW_THREADS
819     MC_TRY;
820     pos = mediacontrol_get_media_position(SELF->mc, origin, key, exception);
821     Py_END_ALLOW_THREADS
822     MC_EXCEPT;
823
824     py_retval = (PyObject*)position_c_to_py(pos);
825     free( pos );
826     return py_retval;
827 }
828
829 /** Sets the media position */
830 static PyObject *MediaControl_set_media_position(
831                                         PyObject *self, PyObject *args )
832 {
833     mediacontrol_Exception* exception = NULL;
834     mediacontrol_Position *a_position;
835     PyObject *py_pos;
836
837     if( !PyArg_ParseTuple( args, "O", &py_pos ) )
838         return NULL;
839
840     a_position = position_py_to_c(py_pos);
841     if (!a_position )
842     {
843         PyErr_SetString(PyExc_MemoryError, "Out of memory");
844         return NULL;
845     }
846
847     Py_BEGIN_ALLOW_THREADS
848     MC_TRY;
849     mediacontrol_set_media_position( SELF->mc, a_position, exception );
850     free( a_position );
851     Py_END_ALLOW_THREADS
852     MC_EXCEPT;
853
854     Py_INCREF(Py_None);
855     return Py_None;
856 }
857
858 static PyObject *MediaControl_start(PyObject *self, PyObject *args)
859 {
860     mediacontrol_Position *a_position;
861     mediacontrol_Exception *exception = NULL;
862     PyObject *py_pos;
863
864     if( !PyArg_ParseTuple(args, "O", &py_pos ) )
865         return NULL;
866
867     a_position = position_py_to_c(py_pos);
868     if ( !a_position )
869         return NULL;
870
871     Py_BEGIN_ALLOW_THREADS
872     MC_TRY;
873     mediacontrol_start(SELF->mc, a_position, exception);
874     free(a_position);
875     Py_END_ALLOW_THREADS
876     MC_EXCEPT;
877
878     Py_INCREF(Py_None);
879     return Py_None;
880 }
881
882 static PyObject *MediaControl_pause(PyObject *self, PyObject *args)
883 {
884     mediacontrol_Position *a_position;
885     mediacontrol_Exception *exception = NULL;
886     PyObject *py_pos;
887
888     if( !PyArg_ParseTuple(args, "O", &py_pos ) )
889         return NULL;
890
891     a_position = position_py_to_c(py_pos);
892
893     Py_BEGIN_ALLOW_THREADS
894     MC_TRY;
895     mediacontrol_pause(SELF->mc, a_position, exception);
896     free(a_position);
897     Py_END_ALLOW_THREADS
898     MC_EXCEPT;
899
900   Py_INCREF( Py_None );
901   return Py_None;
902 }
903
904 static PyObject * MediaControl_resume(PyObject *self, PyObject *args)
905 {
906     mediacontrol_Position *a_position;
907     mediacontrol_Exception *exception = NULL;
908     PyObject *py_pos;
909
910     if( !PyArg_ParseTuple(args, "O", &py_pos ) )
911         return NULL;
912
913     a_position = position_py_to_c(py_pos);
914
915     Py_BEGIN_ALLOW_THREADS
916     MC_TRY;
917     mediacontrol_start(SELF->mc, a_position, exception);
918     free(a_position);
919     Py_END_ALLOW_THREADS
920     MC_EXCEPT;
921
922     Py_INCREF(Py_None);
923     return Py_None;
924 }
925
926 static PyObject *MediaControl_stop(PyObject *self, PyObject *args)
927 {
928     mediacontrol_Position *a_position;
929     mediacontrol_Exception *exception = NULL;
930     PyObject *py_pos;
931
932     if( !PyArg_ParseTuple(args, "O", &py_pos ) )
933         return NULL;
934
935     a_position = position_py_to_c(py_pos);
936
937     Py_BEGIN_ALLOW_THREADS
938     MC_TRY;
939     mediacontrol_stop(SELF->mc, a_position, exception);
940     free(a_position);
941     Py_END_ALLOW_THREADS
942     MC_EXCEPT;
943
944     Py_INCREF(Py_None);
945     return Py_None;
946 }
947
948 static PyObject *MediaControl_exit(PyObject *self, PyObject *args)
949 {
950     mediacontrol_exit(SELF->mc);
951     Py_INCREF(Py_None);
952     return Py_None;
953 }
954
955 static PyObject *MediaControl_playlist_add_item(PyObject *self, PyObject *args)
956 {
957     char *psz_file;
958     mediacontrol_Exception *exception = NULL;
959
960     if ( !PyArg_ParseTuple(args, "s", &psz_file) )
961       return NULL;
962
963     Py_BEGIN_ALLOW_THREADS
964     MC_TRY;
965     mediacontrol_playlist_add_item(SELF->mc, psz_file, exception);
966     Py_END_ALLOW_THREADS
967     MC_EXCEPT;
968
969     Py_INCREF(Py_None);
970     return Py_None;
971 }
972
973 static PyObject * MediaControl_playlist_clear( PyObject *self,
974                                                 PyObject *args)
975 {
976     mediacontrol_Exception *exception = NULL;
977
978     Py_BEGIN_ALLOW_THREADS
979     MC_TRY;
980     mediacontrol_playlist_clear(SELF->mc, exception);
981     Py_END_ALLOW_THREADS
982     MC_EXCEPT;
983
984     Py_INCREF(Py_None);
985     return Py_None;
986 }
987
988 static PyObject * MediaControl_playlist_get_list( PyObject *self,
989                                                   PyObject *args )
990 {
991     PyObject *py_retval;
992     mediacontrol_Exception *exception = NULL;
993     mediacontrol_PlaylistSeq* pl;
994     int i_index;
995     int i_playlist_size;
996
997     Py_BEGIN_ALLOW_THREADS
998     MC_TRY;
999     pl = mediacontrol_playlist_get_list(SELF->mc, exception);
1000     Py_END_ALLOW_THREADS
1001     MC_EXCEPT;
1002
1003     i_playlist_size = pl->size;
1004
1005     py_retval = PyList_New( i_playlist_size );
1006
1007     for (i_index = 0 ; i_index < i_playlist_size ; i_index++)
1008     {
1009         PyList_SetItem( py_retval, i_index,
1010                         Py_BuildValue("s", pl->data[i_index] ) );
1011     }
1012     mediacontrol_PlaylistSeq__free(pl);
1013
1014     return py_retval;
1015 }
1016
1017
1018 static PyObject * MediaControl_snapshot(PyObject *self, PyObject *args)
1019 {
1020     mediacontrol_RGBPicture *retval  = NULL;
1021     mediacontrol_Exception* exception = NULL;
1022     mediacontrol_Position *a_position    = NULL;
1023     PyObject *py_pos        = NULL;
1024     PyObject *py_obj        = NULL;
1025
1026     if( !PyArg_ParseTuple(args, "O", &py_pos))
1027       return NULL;
1028
1029     a_position = position_py_to_c(py_pos);
1030
1031     Py_BEGIN_ALLOW_THREADS
1032     MC_TRY;
1033     retval = mediacontrol_snapshot(SELF->mc, a_position, exception);
1034     free( a_position );
1035     Py_END_ALLOW_THREADS
1036     MC_EXCEPT;
1037
1038     if( !retval )
1039     {
1040         Py_INCREF( Py_None );
1041         return Py_None;
1042     }
1043
1044     /* FIXME: create a real RGBPicture object */
1045     py_obj = PyDict_New();
1046
1047     PyDict_SetItemString(py_obj, "width",
1048                     Py_BuildValue("i", retval->width) );
1049     PyDict_SetItemString(py_obj, "height",
1050                     Py_BuildValue("i", retval->height) );
1051     PyDict_SetItemString(py_obj, "type",
1052                     Py_BuildValue("i", retval->type) );
1053     PyDict_SetItemString(py_obj, "data",
1054                   Py_BuildValue("s#", retval->data, retval->size) );
1055
1056     /*  Py_INCREF(py_obj); */
1057     return py_obj;
1058 }
1059
1060 static PyObject* MediaControl_display_text(PyObject *self, PyObject *args)
1061 {
1062     mediacontrol_Exception* exception = NULL;
1063     PyObject *py_begin, *py_end;
1064     char* message;
1065     mediacontrol_Position * begin;
1066     mediacontrol_Position * end;
1067
1068     if( !PyArg_ParseTuple(args, "sOO", &message, &py_begin, &py_end))
1069       return NULL;
1070
1071     begin = position_py_to_c(py_begin);
1072     end   = position_py_to_c(py_end);
1073
1074     Py_BEGIN_ALLOW_THREADS
1075     MC_TRY;
1076     mediacontrol_display_text(SELF->mc, message, begin, end, exception);
1077     Py_END_ALLOW_THREADS
1078     MC_EXCEPT;
1079
1080     free(begin);
1081     free(end);
1082
1083     Py_INCREF(Py_None);
1084     return Py_None;
1085 }
1086
1087 static PyObject* MediaControl_get_stream_information(
1088                         PyObject *self, PyObject *args)
1089 {
1090     mediacontrol_StreamInformation *retval  = NULL;
1091     mediacontrol_Exception* exception = NULL;
1092     PyObject *py_obj;
1093
1094     Py_BEGIN_ALLOW_THREADS
1095     MC_TRY;
1096     retval = mediacontrol_get_stream_information(
1097                                 SELF->mc, mediacontrol_MediaTime, exception);
1098     Py_END_ALLOW_THREADS
1099     MC_EXCEPT;
1100
1101     py_obj = PyDict_New();
1102
1103      /* FIXME: create a real StreamInformation object */
1104     PyDict_SetItemString(py_obj, "status",
1105                   Py_BuildValue("i", retval->streamstatus));
1106     PyDict_SetItemString(py_obj, "url",
1107                   Py_BuildValue("s", retval->url));
1108     PyDict_SetItemString(py_obj, "position",
1109                   Py_BuildValue("L", retval->position));
1110     PyDict_SetItemString(py_obj, "length",
1111                   Py_BuildValue("L", retval->length));
1112
1113     free(retval->url);
1114     free(retval);
1115
1116     /* Py_INCREF(py_obj); */
1117     return py_obj;
1118 }
1119
1120 static PyObject* MediaControl_sound_set_volume(PyObject *self, PyObject *args)
1121 {
1122     mediacontrol_Exception* exception = NULL;
1123     unsigned short volume;
1124
1125     if (!PyArg_ParseTuple(args, "H", &volume))
1126        return NULL;
1127
1128     Py_BEGIN_ALLOW_THREADS
1129     MC_TRY;
1130     mediacontrol_sound_set_volume(SELF->mc, volume, exception);
1131     Py_END_ALLOW_THREADS
1132     MC_EXCEPT;
1133
1134     Py_INCREF(Py_None);
1135     return Py_None;
1136 }
1137
1138 static PyObject* MediaControl_sound_get_volume(PyObject *self, PyObject *args)
1139 {
1140     mediacontrol_Exception* exception = NULL;
1141     PyObject *py_retval;
1142     unsigned short volume;
1143
1144     Py_BEGIN_ALLOW_THREADS
1145     MC_TRY;
1146     volume=mediacontrol_sound_get_volume(SELF->mc, exception);
1147     Py_END_ALLOW_THREADS
1148     MC_EXCEPT;
1149
1150     py_retval = Py_BuildValue("H", volume);
1151     return py_retval;
1152 }
1153
1154 static PyObject* MediaControl_set_visual(PyObject *self, PyObject *args)
1155 {
1156     mediacontrol_Exception* exception = NULL;
1157     WINDOWHANDLE visual;
1158
1159     if (!PyArg_ParseTuple(args, "i", &visual))
1160        return NULL;
1161
1162     Py_BEGIN_ALLOW_THREADS
1163     MC_TRY;
1164     mediacontrol_set_visual(SELF->mc, visual, exception);
1165     Py_END_ALLOW_THREADS
1166     MC_EXCEPT;
1167
1168     Py_INCREF(Py_None);
1169     return Py_None;
1170 }
1171
1172 static PyMethodDef MediaControl_methods[] =
1173 {
1174     {"get_media_position", MediaControl_get_media_position, METH_VARARGS,
1175      "get_media_position(origin, key) -> Position    Get current media position." },
1176     { "set_media_position", MediaControl_set_media_position, METH_VARARGS,
1177       "set_media_position(Position)            Set media position" },
1178     { "start", MediaControl_start, METH_VARARGS, 
1179       "start(Position)         Start the player." },
1180     { "pause", MediaControl_pause, METH_VARARGS,
1181       "pause(Position)         Pause the player." },
1182     { "resume", MediaControl_resume, METH_VARARGS,
1183       "resume(Position)        Resume the player" },
1184     { "stop", MediaControl_stop, METH_VARARGS,
1185       "stop(Position)              Stop the player" },
1186     { "exit", MediaControl_exit, METH_VARARGS,
1187       "exit()                     Exit the player" },
1188     { "playlist_add_item", MediaControl_playlist_add_item, METH_VARARGS,
1189       "playlist_add_item(str)               Add an item to the playlist" },
1190     { "playlist_get_list", MediaControl_playlist_get_list, METH_VARARGS,
1191       "playlist_get_list() -> list       Get the contents of the playlist" },
1192     { "playlist_clear", MediaControl_playlist_clear, METH_VARARGS,
1193       "clear()         Clear the playlist." },
1194     { "snapshot", MediaControl_snapshot, METH_VARARGS,
1195       "snapshot(Position) -> dict        Take a snapshot" },
1196     { "display_text", MediaControl_display_text, METH_VARARGS,
1197       "display_text(str, Position, Position)    Display a text on the video" },
1198     { "get_stream_information", MediaControl_get_stream_information,
1199       METH_VARARGS,
1200       "get_stream_information() -> dict      Get information about the stream"},
1201     { "sound_get_volume", MediaControl_sound_get_volume, METH_VARARGS,
1202       "sound_get_volume() -> int       Get the volume" },
1203     { "sound_set_volume", MediaControl_sound_set_volume, METH_VARARGS,
1204       "sound_set_volume(int)           Set the volume" },
1205     { "set_visual", MediaControl_set_visual, METH_VARARGS,
1206       "set_visual(int)           Set the embedding window visual ID" },  
1207     { NULL, NULL, 0, NULL },
1208 };
1209
1210 static PyTypeObject MediaControl_Type =
1211 {
1212     PyObject_HEAD_INIT(NULL)
1213     0,                         /*ob_size*/
1214     "vlc.MediaControl",        /*tp_name*/
1215     sizeof(MediaControl_Type), /*tp_basicsize*/
1216     0,                         /*tp_itemsize*/
1217     (destructor)MediaControl_dealloc,      /*tp_dealloc*/
1218     0,                         /*tp_print*/
1219     0,                         /*tp_getattr*/
1220     0,                         /*tp_setattr*/
1221     0,                         /*tp_compare*/
1222     0,                         /*tp_repr*/
1223     0,                         /*tp_as_number*/
1224     0,                         /*tp_as_sequence*/
1225     0,                         /*tp_as_mapping*/
1226     0,                         /*tp_hash */
1227     0,                         /*tp_call*/
1228     0,                         /*tp_str*/
1229     0,                         /*tp_getattro*/
1230     0,                         /*tp_setattro*/
1231     0,                         /*tp_as_buffer*/
1232     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1233     "Control of a VLC instance.",  /* tp_doc */
1234     0,                     /* tp_traverse */
1235     0,                     /* tp_clear */
1236     0,                     /* tp_richcompare */
1237     0,                     /* tp_weaklistoffset */
1238     0,                     /* tp_iter */
1239     0,                     /* tp_iternext */
1240     MediaControl_methods,             /* tp_methods */
1241     0,             /* tp_members */
1242     0,                         /* tp_getset */
1243     0,                         /* tp_base */
1244     0,                         /* tp_dict */
1245     0,                         /* tp_descr_get */
1246     0,                         /* tp_descr_set */
1247     0,                         /* tp_dictoffset */
1248     0,                         /* tp_init */
1249     0,                         /* tp_alloc */
1250     MediaControl_new,          /* tp_new */
1251 };
1252
1253 /***********************************************************************
1254  * Position
1255  ***********************************************************************/
1256
1257
1258 static int PyPosition_init( PyPosition *self, PyObject *args, PyObject *kwds )
1259 {
1260     self->origin = mediacontrol_AbsolutePosition;
1261     self->key    = mediacontrol_MediaTime;
1262     self->value  = 0;
1263     return 0;
1264 }
1265
1266 mediacontrol_PositionKey positionKey_py_to_c( PyObject * py_key )
1267 {
1268     mediacontrol_PositionKey key_position = mediacontrol_MediaTime;
1269     int key;
1270
1271     if( !PyArg_Parse( py_key, "i", &key ) )
1272     {
1273         PyErr_SetString (MediaControl_InternalException, "Invalid key value"); 
1274         return key_position;
1275     }
1276
1277     switch (key)
1278     {
1279         case 0: key = mediacontrol_ByteCount;   break;
1280         case 1: key = mediacontrol_SampleCount; break;
1281         case 2: key = mediacontrol_MediaTime;   break;
1282     }
1283     return key_position;
1284 }
1285
1286 mediacontrol_PositionOrigin positionOrigin_py_to_c( PyObject * py_origin )
1287 {
1288     mediacontrol_PositionOrigin  origin_position =
1289             mediacontrol_AbsolutePosition;
1290     int origin;
1291
1292     if(!PyArg_Parse(py_origin,"i", &origin))
1293     {
1294         PyErr_SetString( MediaControl_InternalException,
1295                          "Invalid origin value");
1296         return origin_position;
1297     }
1298
1299     switch (origin)
1300     {
1301        case 0: origin_position = mediacontrol_AbsolutePosition; break;
1302        case 1: origin_position = mediacontrol_RelativePosition; break;
1303        case 2: origin_position = mediacontrol_ModuloPosition;   break;
1304     }
1305
1306     return origin_position;
1307 }
1308
1309 /* Methods for transforming the Position Python object to Position structure*/
1310 mediacontrol_Position* position_py_to_c( PyObject * py_position )
1311 {
1312     mediacontrol_Position * a_position = NULL;
1313     PyPosition *pos = (PyPosition*)py_position;
1314
1315     a_position = (mediacontrol_Position*)malloc(sizeof(mediacontrol_Position));
1316     if (! a_position)
1317     {
1318         PyErr_SetString(PyExc_MemoryError, "Out of memory");
1319         return NULL;
1320     }
1321
1322     if (PyObject_IsInstance(py_position, (PyObject*)&PyPosition_Type))
1323     {
1324         a_position->origin = pos->origin;
1325         a_position->key    = pos->key;
1326         a_position->value  = pos->value;
1327     }
1328     else
1329     {
1330         /* Feature: if we give an integer, it will be considered as
1331            a relative position in mediatime */
1332         a_position->origin = mediacontrol_RelativePosition;
1333         a_position->key    = mediacontrol_MediaTime;
1334         a_position->value  = PyLong_AsLongLong(py_position);
1335     }
1336     return a_position;
1337 }
1338
1339 PyPosition* position_c_to_py(mediacontrol_Position *position)
1340 {
1341     PyPosition* py_retval;
1342
1343     py_retval = PyObject_New(PyPosition, &PyPosition_Type);
1344     py_retval->origin = position->origin;
1345     py_retval->key    = position->key;
1346     py_retval->value  = position->value;
1347
1348     return py_retval;
1349 }
1350
1351 static PyMethodDef PyPosition_methods[] =
1352 {
1353     { NULL }  /* Sentinel */
1354 };
1355
1356 static PyMemberDef PyPosition_members[] =
1357 {
1358     { "origin", T_INT, offsetof(PyPosition, origin), 0, "Position origin" },
1359     { "key",    T_INT, offsetof(PyPosition, key),    0, "Position key" },
1360     { "value",  T_ULONG, offsetof(PyPosition, value), 0, "Position value" },
1361     { NULL }  /* Sentinel */
1362 };
1363
1364 static PyTypeObject PyPosition_Type =
1365 {
1366     PyObject_HEAD_INIT(NULL)
1367     0,                         /*ob_size*/
1368     "vlc.Position",            /*tp_name*/
1369     sizeof(PyPosition_Type),   /*tp_basicsize*/
1370     0,                         /*tp_itemsize*/
1371     0,                         /*tp_dealloc*/
1372     0,                         /*tp_print*/
1373     0,                         /*tp_getattr*/
1374     0,                         /*tp_setattr*/
1375     0,                         /*tp_compare*/
1376     0,                         /*tp_repr*/
1377     0,                         /*tp_as_number*/
1378     0,                         /*tp_as_sequence*/
1379     0,                         /*tp_as_mapping*/
1380     0,                         /*tp_hash */
1381     0,                         /*tp_call*/
1382     0,                         /*tp_str*/
1383     0,                         /*tp_getattro*/
1384     0,                         /*tp_setattro*/
1385     0,                         /*tp_as_buffer*/
1386     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1387     "Represent a Position with origin, key and value",  /* tp_doc */
1388     0,                        /* tp_traverse */
1389     0,                        /* tp_clear */
1390     0,                         /* tp_richcompare */
1391     0,                         /* tp_weaklistoffset */
1392     0,                         /* tp_iter */
1393     0,                          /* tp_iternext */
1394     PyPosition_methods,             /* tp_methods */
1395     PyPosition_members,             /* tp_members */
1396     0,                         /* tp_getset */
1397     0,                         /* tp_base */
1398     0,                         /* tp_dict */
1399     0,                         /* tp_descr_get */
1400     0,                         /* tp_descr_set */
1401     0,                         /* tp_dictoffset */
1402     (initproc)PyPosition_init, /* tp_init */
1403     0,                         /* tp_alloc */
1404     0,                         /* tp_new */
1405 };