1/* -*- C -*- */
2%%
3headers
4#define NO_IMPORT_PYGOBJECT
5#include "pygobject.h"
6
7#include "pygtksourceview-private.h"
8
9#include <gtksourceview/gtksourceview.h>
10#include <gtksourceview/gtksourceview-typebuiltins.h>
11#include <gtksourceview/gtksourcelanguagemanager.h>
12#include <gtksourceview/gtksourcestyleschememanager.h>
13#include <gtksourceview/gtksourcestyle.h>
14#include <gtksourceview/gtksourcestylescheme.h>
15#include <gtksourceview/gtksourcelanguage.h>
16#include <gtksourceview/gtksourcegutter.h>
17
18#include <gtksourceview/gtksourceiter.h>
19#include <gtksourceview/gtksourcebuffer.h>
20#include <gtksourceview/gtksourceprintcompositor.h>
21#include <gtksourceview/gtksourcecompletion.h>
22#include <gtksourceview/gtksourcecompletionitem.h>
23#include <gtksourceview/gtksourcecompletionprovider.h>
24#include <gtksourceview/gtksourcecompletioninfo.h>
25#include <gtksourceview/completion-providers/words/gtksourcecompletionwords.h>
26
27static PyObject *
28glist_to_pylist_objs (const GList *source)
29{
30    const GList *iter;
31    PyObject *dest = PyList_New (0);
32    for (iter = source; iter != NULL; iter = iter->next)
33    {
34        PyObject *item = pygobject_new ((GObject *)iter->data);
35        PyList_Append (dest, item);
36        Py_DECREF (item);
37    }
38    return dest;
39}
40
41static PyObject *
42gslist_to_pylist_objs (const GSList *source)
43{
44    const GSList *iter;
45    PyObject *dest = PyList_New (0);
46    for (iter = source; iter != NULL; iter = iter->next)
47    {
48        PyObject *item = pygobject_new ((GObject *)iter->data);
49        PyList_Append (dest, item);
50        Py_DECREF (item);
51    }
52    return dest;
53}
54
55static PyObject *
56strv_to_pylist (char **strv)
57{
58    gsize len, i;
59    PyObject *list;
60
61    len = strv ? g_strv_length (strv) : 0;
62    list = PyList_New (len);
63
64    for (i = 0; i < len; i++)
65        PyList_SetItem (list, i, PyString_FromString (strv[i]));
66
67    return list;
68}
69
70static gboolean
71pylist_to_strv (PyObject *list,
72                char   ***strvp)
73{
74    int i, len;
75    char **ret;
76
77    *strvp = NULL;
78
79    if (list == Py_None)
80        return TRUE;
81
82    if (!PySequence_Check (list))
83    {
84        PyErr_Format (PyExc_TypeError, "argument must be a list or tuple of strings");
85        return FALSE;
86    }
87
88    if ((len = PySequence_Size (list)) < 0)
89        return FALSE;
90
91    ret = g_new (char*, len + 1);
92    for (i = 0; i <= len; ++i)
93        ret[i] = NULL;
94
95    for (i = 0; i < len; ++i)
96    {
97        PyObject *item = PySequence_GetItem (list, i);
98
99        if (!item)
100        {
101            g_strfreev (ret);
102            return FALSE;
103        }
104
105        if (!PyString_Check (item))
106        {
107            Py_DECREF (item);
108            g_strfreev (ret);
109            PyErr_Format (PyExc_TypeError, "argument must be a list of strings");
110            return FALSE;
111        }
112
113        ret[i] = g_strdup (PyString_AsString (item));
114        Py_DECREF (item);
115    }
116
117    *strvp = ret;
118    return TRUE;
119}
120
121void
122pygtksourceview_custom_destroy_notify(gpointer user_data)
123{
124    PyGtkSourceViewCustomNotify *cunote = user_data;
125    PyGILState_STATE state;
126
127    g_return_if_fail(user_data);
128    state = pyg_gil_state_ensure();
129    Py_XDECREF(cunote->func);
130    Py_XDECREF(cunote->data);
131    pyg_gil_state_release(state);
132
133    g_free(cunote);
134}
135
136%%
137modulename gtksourceview2
138
139%%
140import gobject.GObject as PyGObject_Type
141import gtk.gdk.Pixbuf as PyGdkPixbuf_Type
142import gtk.TextTagTable as PyGtkTextTagTable_Type
143import gtk.TextView as PyGtkTextView_Type
144import gtk.TextBuffer as PyGtkTextBuffer_Type
145import gtk.TextMark as PyGtkTextMark_Type
146import gtk.PrintContext as PyGtkPrintContext_Type
147import gtk.Widget as PyGtkWidget_Type
148import gtk.Window as PyGtkWindow_Type
149import gtk.TextIter as PyGtkTextIter_Type
150import gtk.CellRenderer as PyGtkCellRenderer_Type
151import gtk.Tooltip as PyGtkTooltip_Type
152import gobject.GObject as PyGInitiallyUnowned_Type
153%%
154ignore-glob
155*_get_type
156
157%%
158override gtk_source_language_get_globs noargs
159static PyObject *
160_wrap_gtk_source_language_get_globs(PyGObject *self)
161{
162    gchar **globs;
163    PyObject *ret;
164
165    globs = gtk_source_language_get_globs (GTK_SOURCE_LANGUAGE (self->obj));
166    ret = strv_to_pylist (globs);
167    g_strfreev (globs);
168
169    return ret;
170}
171
172%%
173override gtk_source_language_get_mime_types noargs
174static PyObject *
175_wrap_gtk_source_language_get_mime_types(PyGObject *self)
176{
177    gchar **mime_types;
178    PyObject *ret;
179
180    mime_types = gtk_source_language_get_mime_types (GTK_SOURCE_LANGUAGE (self->obj));
181    ret = strv_to_pylist (mime_types);
182    g_strfreev (mime_types);
183
184    return ret;
185}
186
187%%
188override gtk_source_language_manager_get_language_ids noargs
189static PyObject *
190_wrap_gtk_source_language_manager_get_language_ids (PyGObject *self)
191{
192    PyObject *py_ret;
193    const char * const *ret;
194
195    ret = gtk_source_language_manager_get_language_ids (GTK_SOURCE_LANGUAGE_MANAGER (self->obj));
196    py_ret = strv_to_pylist ((char**) ret);
197
198    return py_ret;
199}
200
201%%
202override gtk_source_language_manager_get_search_path noargs
203static PyObject *
204_wrap_gtk_source_language_manager_get_search_path(PyGObject *self)
205{
206    const char * const *ret;
207    PyObject  *py_ret;
208
209    ret = gtk_source_language_manager_get_search_path (GTK_SOURCE_LANGUAGE_MANAGER(self->obj));
210    py_ret = strv_to_pylist ((char**) ret);
211
212    return py_ret;
213}
214
215%%
216override gtk_source_language_manager_set_search_path kwargs
217static PyObject *
218_wrap_gtk_source_language_manager_set_search_path (PyGObject *self, PyObject *args, PyObject *kwargs)
219{
220    static char *kwlist[] = { "dirs", NULL };
221    PyObject *py_dirs;
222    char **dirs;
223
224    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GtkSourceLanguageManager.set_search_path", kwlist, &py_dirs))
225        return NULL;
226
227    if (!pylist_to_strv (py_dirs, &dirs))
228        return NULL;
229
230    gtk_source_language_manager_set_search_path (GTK_SOURCE_LANGUAGE_MANAGER (self->obj), dirs);
231    g_strfreev (dirs);
232
233    Py_INCREF(Py_None);
234    return Py_None;
235}
236
237%%
238override gtk_source_style_scheme_manager_get_search_path noargs
239static PyObject *
240_wrap_gtk_source_style_scheme_manager_get_search_path(PyGObject *self)
241{
242    const char * const *ret;
243    PyObject *py_ret;
244
245    ret = gtk_source_style_scheme_manager_get_search_path (GTK_SOURCE_STYLE_SCHEME_MANAGER (self->obj));
246    py_ret = strv_to_pylist ((char**) ret);
247
248    return py_ret;
249}
250
251%%
252override gtk_source_style_scheme_manager_set_search_path kwargs
253static PyObject *
254_wrap_gtk_source_style_scheme_manager_set_search_path(PyGObject *self, PyObject *args, PyObject *kwargs)
255{
256    static char *kwlist[] = { "dirs", NULL };
257    PyObject *py_dirs;
258    char **dirs;
259
260    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GtkSourceStyleSchemeManager.set_search_path", kwlist, &py_dirs))
261        return NULL;
262
263    if (!pylist_to_strv (py_dirs, &dirs))
264        return NULL;
265
266    gtk_source_style_scheme_manager_set_search_path (GTK_SOURCE_STYLE_SCHEME_MANAGER (self->obj), dirs);
267    g_strfreev (dirs);
268
269    Py_INCREF(Py_None);
270    return Py_None;
271}
272
273%%
274override gtk_source_style_scheme_manager_get_scheme_ids noargs
275static PyObject *
276_wrap_gtk_source_style_scheme_manager_get_scheme_ids (PyGObject *self)
277{
278    PyObject *py_ret;
279    const char * const *ret;
280
281    ret = gtk_source_style_scheme_manager_get_scheme_ids (GTK_SOURCE_STYLE_SCHEME_MANAGER (self->obj));
282    py_ret = strv_to_pylist ((char**) ret);
283
284    return py_ret;
285}
286
287%%
288override gtk_source_style_scheme_get_authors noargs
289static PyObject *
290_wrap_gtk_source_style_scheme_get_authors (PyGObject *self)
291{
292    PyObject *py_ret;
293    const char * const *ret;
294
295    ret = gtk_source_style_scheme_get_authors (GTK_SOURCE_STYLE_SCHEME (self->obj));
296    py_ret = strv_to_pylist ((char**) ret);
297
298    return py_ret;
299}
300
301%%
302override-slot GtkSourceLanguage.tp_new
303static PyObject *
304_wrap_gtk_source_language_tp_new(PyTypeObject *type)
305{
306    PyErr_SetString(PyExc_TypeError,
307            "cannot create instance of type `GtkSourceLanguage'");
308    return NULL;
309}
310
311%%
312override-slot GtkSourceStyleScheme.tp_new
313static PyObject *
314_wrap_gtk_source_style_scheme_tp_new(PyTypeObject *type)
315{
316    PyErr_SetString(PyExc_TypeError,
317            "cannot create instance of type `GtkSourceStyleScheme'");
318    return NULL;
319}
320
321%%
322override gtk_source_language_get_style_ids noargs
323static PyObject *
324_wrap_gtk_source_language_get_style_ids(PyGObject *self)
325{
326    gchar       **ret;
327    PyObject    *py_ret;
328
329    ret = gtk_source_language_get_style_ids(GTK_SOURCE_LANGUAGE(self->obj));
330    py_ret = strv_to_pylist ((char**) ret);
331
332    return py_ret;
333}
334
335%%
336override gtk_source_buffer_get_source_marks_at_iter kwargs
337static PyObject *
338_wrap_gtk_source_buffer_get_source_marks_at_iter(PyGObject *self,
339                                                 PyObject *args,
340                                                 PyObject *kwargs)
341{
342    static char *kwlist[] = { "iter", "category", NULL };
343    PyObject    *py_iter, *py_ret;
344    gchar       *category;
345    GtkTextIter *iter = NULL;
346    GSList      *ret;
347
348    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
349                                     "Oz:GtkSourceBuffer.get_source_marks_at_iter",
350                                     kwlist, &py_iter, &category))
351        return NULL;
352
353    if (pyg_boxed_check(py_iter, GTK_TYPE_TEXT_ITER))
354        iter = pyg_boxed_get(py_iter, GtkTextIter);
355    else {
356        PyErr_SetString(PyExc_TypeError, "iter should be a GtkTextIter");
357        return NULL;
358    }
359
360    ret = gtk_source_buffer_get_source_marks_at_iter(GTK_SOURCE_BUFFER(self->obj),
361                                                     iter, category);
362
363    py_ret = gslist_to_pylist_objs (ret);
364
365    return py_ret;
366}
367
368%%
369override gtk_source_buffer_get_source_marks_at_line kwargs
370static PyObject *
371_wrap_gtk_source_buffer_get_source_marks_at_line(PyGObject *self,
372                                                 PyObject *args,
373                                                 PyObject *kwargs)
374{
375    static char *kwlist[] = { "line", "category", NULL };
376    PyObject    *py_ret;
377    gint        line;
378    gchar       *category;
379    GSList      *ret;
380
381    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
382                                     "iz:GtkSourceBuffer.get_source_marks_at_line",
383                                     kwlist, &line, &category))
384        return NULL;
385
386    ret = gtk_source_buffer_get_source_marks_at_line(GTK_SOURCE_BUFFER(self->obj),
387                                                     line, category);
388
389    py_ret = gslist_to_pylist_objs (ret);
390
391    return py_ret;
392}
393
394%%
395override gtk_source_iter_backward_search kwargs
396static PyObject *
397_wrap_gtk_source_iter_backward_search(PyObject *self, PyObject *args,
398                                      PyObject *kwargs)
399{
400    static char *kwlist[] = { "iter", "str", "flags", "limit", NULL };
401    gchar *str;
402    PyObject *py_flags, *py_iter, *py_limit = Py_None;
403    GtkTextIter match_start, match_end, *iter = NULL, *limit = NULL;
404    GtkSourceSearchFlags flags;
405
406    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
407                                    "OsO|O:gtksourceview2.iter_backward_search",
408                                    kwlist, &py_iter, &str, &py_flags,
409                                    &py_limit))
410        return NULL;
411
412    if (pyg_boxed_check(py_iter, GTK_TYPE_TEXT_ITER))
413        iter = pyg_boxed_get(py_iter, GtkTextIter);
414
415    if (pyg_boxed_check(py_limit, GTK_TYPE_TEXT_ITER))
416        limit = pyg_boxed_get(py_limit, GtkTextIter);
417
418    else if (py_limit != Py_None) {
419        PyErr_SetString(PyExc_TypeError,"limit must be a GtkTextIter or None");
420        return NULL;
421    }
422
423    if (pyg_flags_get_value(GTK_TYPE_TEXT_SEARCH_FLAGS, py_flags,
424                            (gint *)&flags))
425        return NULL;
426
427    if (gtk_source_iter_backward_search(iter, str, flags, &match_start,
428                                        &match_end, limit))
429        return Py_BuildValue("(NN)",
430                             pyg_boxed_new(GTK_TYPE_TEXT_ITER, &match_start,
431                                           TRUE, TRUE),
432                             pyg_boxed_new(GTK_TYPE_TEXT_ITER, &match_end,
433                                           TRUE, TRUE));
434
435    Py_INCREF(Py_None);
436    return Py_None;
437}
438
439%%
440override gtk_source_iter_forward_search kwargs
441static PyObject *
442_wrap_gtk_source_iter_forward_search(PyObject *self, PyObject *args,
443                                      PyObject *kwargs)
444{
445    static char *kwlist[] = { "iter", "str", "flags", "limit", NULL };
446    gchar *str;
447    PyObject *py_flags, *py_iter, *py_limit = Py_None;
448    GtkTextIter match_start, match_end, *iter = NULL, *limit = NULL;
449    GtkSourceSearchFlags flags;
450
451    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
452                                    "OsO|O:gtksourceview2.iter_forward_search",
453                                    kwlist, &py_iter, &str, &py_flags,
454                                    &py_limit))
455        return NULL;
456
457    if (pyg_boxed_check(py_iter, GTK_TYPE_TEXT_ITER))
458        iter = pyg_boxed_get(py_iter, GtkTextIter);
459
460    if (pyg_boxed_check(py_limit, GTK_TYPE_TEXT_ITER))
461        limit = pyg_boxed_get(py_limit, GtkTextIter);
462
463    else if (py_limit != Py_None) {
464        PyErr_SetString(PyExc_TypeError,"limit must be a GtkTextIter or None");
465        return NULL;
466    }
467
468    if (pyg_flags_get_value(GTK_TYPE_TEXT_SEARCH_FLAGS, py_flags,
469                            (gint *)&flags))
470        return NULL;
471
472    if (gtk_source_iter_forward_search(iter, str, flags, &match_start,
473                                        &match_end, limit))
474        return Py_BuildValue("(NN)",
475                             pyg_boxed_new(GTK_TYPE_TEXT_ITER, &match_start,
476                                           TRUE, TRUE),
477                             pyg_boxed_new(GTK_TYPE_TEXT_ITER, &match_end,
478                                           TRUE, TRUE));
479
480    Py_INCREF(Py_None);
481    return Py_None;
482}
483
484%%
485override gtk_source_view_get_mark_category_background kwargs
486static PyObject *
487_wrap_gtk_source_view_get_mark_category_background(PyGObject *self,
488                                                   PyObject *args,
489                                                   PyObject *kwargs)
490{
491    static char *kwlist[] = { "category", NULL };
492    char *category;
493    int ret;
494    GdkColor dest = { 0, 0, 0, 0 };
495
496    if (!PyArg_ParseTupleAndKeywords(args,
497                                kwargs,
498                                "s:GtkSourceView.get_mark_category_background",
499                                kwlist, &category))
500        return NULL;
501
502    ret = gtk_source_view_get_mark_category_background(
503                                                    GTK_SOURCE_VIEW(self->obj),
504                                                    category, &dest);
505
506    if (ret)
507        return pyg_boxed_new(GDK_TYPE_COLOR, &dest, TRUE, TRUE);
508    else {
509        Py_INCREF(Py_None);
510        return(Py_None);
511    }
512}
513
514%%
515override gtk_source_gutter_set_cell_data_func kwargs
516static void
517pygtksourceview_cell_data_func_marshal (GtkSourceGutter *gutter,
518                                        GtkCellRenderer *cell,
519                                        gint line_number,
520                                        gboolean current_line,
521                                        gpointer data)
522{
523    PyGILState_STATE state;
524    PyGtkSourceViewCustomNotify *cunote = data;
525    PyObject *retobj;
526    PyObject *pygutter, *pycell;
527
528    g_assert (cunote->func);
529
530    state = pyg_gil_state_ensure();
531
532    pygutter = pygobject_new((GObject *)gutter);
533    pycell = pygobject_new((GObject *)cell);
534
535    if (cunote->data)
536        retobj = PyEval_CallFunction(cunote->func, "(NNiiO)",
537                                     pygutter, pycell,
538                                     line_number, current_line, cunote->data);
539    else
540        retobj = PyEval_CallFunction(cunote->func, "(NNii)",
541                                     pygutter, pycell,
542                                     line_number, current_line);
543
544    if (retobj == NULL) {
545        PyErr_Print();
546    } else
547        Py_DECREF(retobj);
548
549    pyg_gil_state_release(state);
550}
551
552static PyObject *
553_wrap_gtk_source_gutter_set_cell_data_func (PyGObject *self,
554                                            PyObject *args,
555                                            PyObject *kwargs)
556{
557    PyObject *pycell, *pyfunc, *pyarg = NULL;
558    GtkCellRenderer *cell;
559    PyGtkSourceViewCustomNotify *cunote;
560
561    if (!PyArg_ParseTuple(args, "OO|O:GtkSourceGutter.set_cell_data_func",
562                          &pycell, &pyfunc, &pyarg))
563        return NULL;
564
565    if (pygobject_check(pycell, &PyGtkCellRenderer_Type))
566        cell = GTK_CELL_RENDERER(pygobject_get(pycell));
567    else {
568        PyErr_SetString(PyExc_TypeError,
569                        "first argument must be a GtkCellRenderer");
570        return NULL;
571    }
572
573    if (pyfunc == Py_None) {
574        PyErr_SetString(PyExc_TypeError,
575                        "Function can't be None");
576    } else {
577        cunote = g_new0(PyGtkSourceViewCustomNotify, 1);
578        cunote->func = pyfunc;
579        cunote->data = pyarg;
580        Py_INCREF(cunote->func);
581        Py_XINCREF(cunote->data);
582
583        gtk_source_gutter_set_cell_data_func(GTK_SOURCE_GUTTER(self->obj), cell,
584                                        pygtksourceview_cell_data_func_marshal,
585                                        cunote,
586                                        pygtksourceview_custom_destroy_notify);
587    }
588
589    Py_INCREF(Py_None);
590    return Py_None;
591}
592
593%%
594override gtk_source_completion_context_add_proposals kwargs
595static PyObject *
596_wrap_gtk_source_completion_context_add_proposals(PyGObject *self,
597                                                  PyObject *args,
598                                                  PyObject *kwargs)
599{
600    static char *kwlist[] = { "provider", "proposals", "finished", NULL };
601    PyGObject   *py_provider;
602    PyObject    *py_proposals;
603    PyObject    *py_finished = NULL;
604    GList       *ret;
605
606    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
607                                     "O!O|O:GtkSourceCompletionContext.add_proposals",
608                                     kwlist,
609                                     &PyGtkSourceCompletionProvider_Type, &py_provider,
610                                     &py_proposals,
611                                     &py_finished))
612        return NULL;
613
614	if (py_proposals != Py_None && !PySequence_Check(py_proposals)) {
615        PyErr_SetString(PyExc_TypeError, "proposals must be a list");
616        return NULL;
617    }
618
619	ret = pylist_to_glist_gobjs (py_proposals, GTK_TYPE_SOURCE_COMPLETION_PROPOSAL);
620	gtk_source_completion_context_add_proposals(GTK_SOURCE_COMPLETION_CONTEXT (self->obj),
621	                                            GTK_SOURCE_COMPLETION_PROVIDER (py_provider->obj),
622	                                            ret,
623	                                            py_finished == NULL ? TRUE : PyObject_IsTrue (py_finished));
624
625    g_list_foreach(ret, (GFunc)g_object_unref, NULL);
626    g_list_free(ret);
627
628	Py_INCREF(Py_None);
629    return Py_None;
630}
631
632%%
633override gtk_source_completion_get_providers kwargs
634static GList *
635pylist_to_glist_gobjs (PyObject *object, GType gtype)
636{
637    PyObject *item;
638    GObject *obj;
639    GList *ret = NULL;
640    int num;
641    int i;
642
643    if (object == Py_None) {
644        return ret;
645    }
646
647    num = PySequence_Size (object);
648
649    for (i = 0; i < num; ++i) {
650        item = PySequence_GetItem (object, i);
651
652        if (PyObject_TypeCheck(item, &PyGObject_Type)) {
653            obj = pygobject_get (item);
654
655            if (g_type_is_a (G_TYPE_FROM_INSTANCE (obj), gtype)) {
656                ret = g_list_prepend (ret, g_object_ref (obj));
657            }
658        }
659    }
660
661    return g_list_reverse (ret);
662}
663
664static PyObject *
665_wrap_gtk_source_completion_get_providers(PyGObject *self,
666                                          PyObject *args,
667                                          PyObject *kwargs)
668{
669    static char *kwlist[] = { NULL };
670    PyObject    *py_ret;
671    GList      *ret;
672
673    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
674                                     "Oz:GtkSourceCompletion.get_providers",
675                                     kwlist))
676        return NULL;
677
678    ret = gtk_source_completion_get_providers(GTK_SOURCE_COMPLETION(self->obj));
679
680    py_ret = glist_to_pylist_objs (ret);
681
682    return py_ret;
683}
684
685%%
686override gtk_source_completion_show kwargs
687
688static PyObject *
689_wrap_gtk_source_completion_show(PyGObject *self,
690                                  PyObject  *args,
691                                  PyObject  *kwargs)
692{
693    static char *kwlist[] = { "providers", "context", NULL };
694    PyObject *providers;
695    PyGObject *context;
696    GList *items;
697
698    if (!PyArg_ParseTupleAndKeywords(args,
699                                         kwargs,
700                                         "|OO!:GtkSourceCompletion.show",
701                                         kwlist, &providers, &PyGtkSourceCompletionContext_Type, &context));
702
703    if (providers != Py_None && !PySequence_Check(providers)) {
704        PyErr_SetString(PyExc_TypeError, "providers must be a list");
705        return NULL;
706    }
707
708    items = pylist_to_glist_gobjs (providers, GTK_TYPE_SOURCE_COMPLETION_PROVIDER);
709
710    gtk_source_completion_show (GTK_SOURCE_COMPLETION(self->obj),
711                                items,
712                                GTK_SOURCE_COMPLETION_CONTEXT (context->obj));
713
714    g_list_foreach (items, (GFunc)g_object_unref, NULL);
715    g_list_free (items);
716
717    Py_INCREF(Py_None);
718    return Py_None;
719}
720
721%%
722override gtk_source_completion_context_get_iter noargs
723static PyObject *
724_wrap_gtk_source_completion_context_get_iter(PyGObject *self)
725{
726	GtkTextIter iter;
727    gtk_source_completion_context_get_iter(GTK_SOURCE_COMPLETION_CONTEXT(self->obj), &iter);
728
729    return pyg_boxed_new(GTK_TYPE_TEXT_ITER, &iter, TRUE, TRUE);
730}
731
732%%
733override GtkSourceCompletionProvider__do_get_start_iter kwargs
734static PyObject *
735_wrap_GtkSourceCompletionProvider__do_get_start_iter(PyObject *cls,
736                                                     PyObject *args,
737                                                     PyObject *kwargs)
738{
739    GtkSourceCompletionProviderIface *iface;
740    static char *kwlist[] = { "self", "context", "proposal", NULL };
741    PyGObject *self;
742    PyGObject *context;
743    PyGObject *proposal;
744    gboolean ret;
745    GtkTextIter iter;
746
747    if (!PyArg_ParseTupleAndKeywords(args,
748                                     kwargs,
749                                     "O!O!O!:GtkSourceCompletionProvider.get_start_iter", kwlist,
750                                     &PyGtkSourceCompletionProvider_Type, &self,
751                                     &PyGtkSourceCompletionContext_Type, &context,
752                                     &PyGtkSourceCompletionProposal_Type, &proposal))
753        return NULL;
754
755    iface = g_type_interface_peek(g_type_class_peek(pyg_type_from_object(cls)), GTK_TYPE_SOURCE_COMPLETION_PROVIDER);
756
757    if (iface->get_start_iter)
758        ret = iface->get_start_iter(GTK_SOURCE_COMPLETION_PROVIDER(self->obj),
759                                    GTK_SOURCE_COMPLETION_CONTEXT(context->obj),
760                                    GTK_SOURCE_COMPLETION_PROPOSAL(proposal->obj),
761                                    &iter);
762    else{
763        PyErr_SetString(PyExc_NotImplementedError, "interface method GtkSourceCompletionProvider.get_start_iter not implemented");
764        return NULL;
765    }
766
767    if (ret)
768    {
769	    return pyg_boxed_new(GTK_TYPE_TEXT_ITER, &iter, TRUE, TRUE);
770	}
771	else
772	{
773		Py_INCREF(Py_None);
774		return Py_None;
775	}
776}
777
778%%
779override gtk_source_completion_provider_get_start_iter kwargs
780static PyObject *
781_wrap_gtk_source_completion_provider_get_start_iter(PyGObject *self,
782                                                    PyObject  *args,
783                                                    PyObject  *kwargs)
784{
785    static char *kwlist[] = { "context", "proposal", NULL };
786    PyGObject *context;
787    PyGObject *proposal;
788	gboolean ret;
789	GtkTextIter iter;
790
791	if (!PyArg_ParseTupleAndKeywords(args,
792                                         kwargs,
793                                         "|O!O!:GtkSourceCompletionProvider.get_start_iter",
794                                         kwlist,
795                                         &PyGtkSourceCompletionContext_Type, &context,
796                                         &PyGtkSourceCompletionProposal_Type, &proposal));
797
798	ret = gtk_source_completion_provider_get_start_iter (GTK_SOURCE_COMPLETION_PROVIDER (self->obj),
799	                                                     GTK_SOURCE_COMPLETION_CONTEXT (context->obj),
800	                                                     GTK_SOURCE_COMPLETION_PROPOSAL (proposal->obj),
801	                                                     &iter);
802
803	if (!ret)
804	{
805		Py_INCREF(Py_None);
806		return Py_None;
807	}
808	else
809	{
810		return pyg_boxed_new(GTK_TYPE_TEXT_ITER, &iter, TRUE, TRUE);
811	}
812}
813%%
814override GtkSourceCompletionProvider__proxy_do_get_start_iter
815static gboolean
816_wrap_GtkSourceCompletionProvider__proxy_do_get_start_iter(GtkSourceCompletionProvider *self, GtkSourceCompletionContext*context, GtkSourceCompletionProposal*proposal, GtkTextIter*iter)
817{
818    PyGILState_STATE __py_state;
819    PyObject *py_self;
820    PyObject *py_context = NULL;
821    PyObject *py_proposal = NULL;
822    PyObject *py_retval;
823    PyObject *py_args;
824    PyObject *py_method;
825
826    __py_state = pyg_gil_state_ensure();
827    py_self = pygobject_new((GObject *) self);
828    if (!py_self) {
829        if (PyErr_Occurred())
830            PyErr_Print();
831        pyg_gil_state_release(__py_state);
832        return FALSE;
833    }
834
835    if (context)
836        py_context = pygobject_new((GObject *) context);
837    else {
838        Py_INCREF(Py_None);
839        py_context = Py_None;
840    }
841
842    if (proposal)
843        py_proposal = pygobject_new((GObject *) proposal);
844    else {
845        Py_INCREF(Py_None);
846        py_proposal = Py_None;
847    }
848
849    py_args = PyTuple_New(2);
850    PyTuple_SET_ITEM(py_args, 0, py_context);
851    PyTuple_SET_ITEM(py_args, 1, py_proposal);
852
853    py_method = PyObject_GetAttrString(py_self, "do_get_start_iter");
854    if (!py_method) {
855        if (PyErr_Occurred())
856            PyErr_Print();
857        Py_DECREF(py_args);
858        Py_DECREF(py_self);
859        pyg_gil_state_release(__py_state);
860        return FALSE;
861    }
862    py_retval = PyObject_CallObject(py_method, py_args);
863    if (!py_retval || py_retval == Py_None) {
864        if (PyErr_Occurred())
865            PyErr_Print();
866        Py_XDECREF(py_retval);
867        Py_DECREF(py_method);
868        Py_DECREF(py_args);
869        Py_DECREF(py_self);
870        pyg_gil_state_release(__py_state);
871        return FALSE;
872    }
873
874    if (!pyg_boxed_check(py_retval, GTK_TYPE_TEXT_ITER)) {
875        PyErr_SetString(PyExc_TypeError, "retval should be a GtkTextIter");
876        PyErr_Print();
877        Py_XDECREF(py_retval);
878        Py_DECREF(py_method);
879        Py_DECREF(py_args);
880        Py_DECREF(py_self);
881        pyg_gil_state_release(__py_state);
882        return FALSE;
883    }
884
885    *iter = *pyg_boxed_get(py_retval, GtkTextIter);
886
887    Py_XDECREF(py_retval);
888    Py_DECREF(py_method);
889    Py_DECREF(py_args);
890    Py_DECREF(py_self);
891    pyg_gil_state_release(__py_state);
892
893    return TRUE;
894}
895%%
896override GtkSourceCompletionProvider__proxy_do_get_info_widget
897
898static GtkWidget*
899_wrap_GtkSourceCompletionProvider__proxy_do_get_info_widget(GtkSourceCompletionProvider *self, GtkSourceCompletionProposal*proposal)
900{
901    PyGILState_STATE __py_state;
902    PyObject *py_self;
903    PyObject *py_proposal = NULL;
904    GtkWidget* retval;
905    PyObject *py_retval;
906    PyObject *py_args;
907    PyObject *py_method;
908
909    __py_state = pyg_gil_state_ensure();
910    py_self = pygobject_new((GObject *) self);
911    if (!py_self) {
912        if (PyErr_Occurred())
913            PyErr_Print();
914        pyg_gil_state_release(__py_state);
915        return NULL;
916    }
917    if (proposal)
918        py_proposal = pygobject_new((GObject *) proposal);
919    else {
920        Py_INCREF(Py_None);
921        py_proposal = Py_None;
922    }
923
924    py_args = PyTuple_New(1);
925    PyTuple_SET_ITEM(py_args, 0, py_proposal);
926
927    py_method = PyObject_GetAttrString(py_self, "do_get_info_widget");
928    if (!py_method) {
929        if (PyErr_Occurred())
930            PyErr_Print();
931        Py_DECREF(py_args);
932        Py_DECREF(py_self);
933        pyg_gil_state_release(__py_state);
934        return NULL;
935    }
936    py_retval = PyObject_CallObject(py_method, py_args);
937    if (!py_retval) {
938        if (PyErr_Occurred())
939            PyErr_Print();
940        Py_XDECREF(py_retval);
941        Py_DECREF(py_method);
942        Py_DECREF(py_args);
943        Py_DECREF(py_self);
944        pyg_gil_state_release(__py_state);
945        return NULL;
946    }
947    if (!PyObject_TypeCheck(py_retval, &PyGObject_Type)) {
948        PyErr_SetString(PyExc_TypeError, "retval should be a GObject");
949        PyErr_Print();
950        Py_XDECREF(py_retval);
951        Py_DECREF(py_method);
952        Py_DECREF(py_args);
953        Py_DECREF(py_self);
954        pyg_gil_state_release(__py_state);
955        return NULL;
956    }
957    retval = (GtkWidget*) pygobject_get(py_retval);
958
959    Py_XDECREF(py_retval);
960    Py_DECREF(py_method);
961    Py_DECREF(py_args);
962    Py_DECREF(py_self);
963    pyg_gil_state_release(__py_state);
964
965    return retval;
966}
967
968%%
969override gtk_source_completion_item_new kwargs
970static int
971_wrap_gtk_source_completion_item_new(PyGObject *self, PyObject *args, PyObject *kwargs)
972{
973    static char *kwlist[] = { "label", "text", "icon", "info", NULL };
974    char *label, *text = NULL, *info = NULL;
975    PyGObject *icon = NULL;
976
977    if (!PyArg_ParseTupleAndKeywords(args,
978                                     kwargs, "s|sO!s:GtkSourceCompletionItem.__init__",
979                                     kwlist,
980                                     &label,
981                                     &text,
982                                     &PyGdkPixbuf_Type, &icon,
983                                     &info))
984        return -1;
985
986    self->obj = (GObject *)gtk_source_completion_item_new(label, text, icon ? GDK_PIXBUF(icon->obj) : NULL, info);
987
988    if (!self->obj) {
989        PyErr_SetString(PyExc_RuntimeError, "could not create GtkSourceCompletionItem object");
990        return -1;
991    }
992    pygobject_register_wrapper((PyObject *)self);
993    return 0;
994}
995
996%%
997override gtk_source_completion_create_context kwargs
998static PyObject *
999_wrap_gtk_source_completion_create_context(PyGObject *self, PyObject *args, PyObject *kwargs)
1000{
1001    static char *kwlist[] = { "position", NULL };
1002    PyObject *py_position = NULL;
1003    GtkSourceCompletionContext *ret;
1004    GtkTextIter *position = NULL;
1005
1006    if (!PyArg_ParseTupleAndKeywords(args,
1007                                     kwargs,
1008                                     "|O!:GtkSourceCompletion.create_context",
1009                                     kwlist,
1010                                     &PyGtkTextIter_Type, &py_position))
1011        return NULL;
1012
1013	if (py_position != NULL)
1014	{
1015		if (pyg_boxed_check(py_position, GTK_TYPE_TEXT_ITER))
1016		    position = pyg_boxed_get(py_position, GtkTextIter);
1017		else {
1018		    PyErr_SetString(PyExc_TypeError, "position should be a GtkTextIter");
1019		    return NULL;
1020	    }
1021	}
1022
1023    ret = gtk_source_completion_create_context(GTK_SOURCE_COMPLETION(self->obj), position);
1024
1025    /* pygobject_new handles NULL checking */
1026    return pygobject_new((GObject *)ret);
1027}
1028
1029%%
1030override gtk_source_gutter_set_cell_size_func kwargs
1031static void
1032pygtksourceview_cell_size_func_marshal (GtkSourceGutter *gutter,
1033                                        GtkCellRenderer *cell,
1034                                        gpointer data)
1035{
1036    PyGILState_STATE state;
1037    PyGtkSourceViewCustomNotify *cunote = data;
1038    PyObject *retobj;
1039    PyObject *pygutter, *pycell;
1040
1041    g_assert (cunote->func);
1042
1043    state = pyg_gil_state_ensure();
1044
1045    pygutter = pygobject_new((GObject *)gutter);
1046    pycell = pygobject_new((GObject *)cell);
1047
1048    if (cunote->data)
1049        retobj = PyEval_CallFunction(cunote->func, "(NNO)",
1050                                     pygutter, pycell,
1051                                     cunote->data);
1052    else
1053        retobj = PyEval_CallFunction(cunote->func, "(NN)",
1054                                     pygutter, pycell);
1055
1056    if (retobj == NULL) {
1057        PyErr_Print();
1058    } else
1059        Py_DECREF(retobj);
1060
1061    pyg_gil_state_release(state);
1062}
1063
1064static PyObject *
1065_wrap_gtk_source_gutter_set_cell_size_func (PyGObject *self,
1066                                            PyObject *args,
1067                                            PyObject *kwargs)
1068{
1069    PyObject *pycell, *pyfunc, *pyarg = NULL;
1070    GtkCellRenderer *cell;
1071    PyGtkSourceViewCustomNotify *cunote;
1072
1073    if (!PyArg_ParseTuple(args, "OO|O:GtkSourceGutter.set_cell_size_func",
1074                          &pycell, &pyfunc, &pyarg))
1075        return NULL;
1076
1077    if (pygobject_check(pycell, &PyGtkCellRenderer_Type))
1078        cell = GTK_CELL_RENDERER(pygobject_get(pycell));
1079    else {
1080        PyErr_SetString(PyExc_TypeError,
1081                        "first argument must be a GtkCellRenderer");
1082        return NULL;
1083    }
1084
1085    if (pyfunc == Py_None) {
1086        PyErr_SetString(PyExc_TypeError,
1087                        "func must be a callable object");
1088    } else {
1089        cunote = g_new0(PyGtkSourceViewCustomNotify, 1);
1090        cunote->func = pyfunc;
1091        cunote->data = pyarg;
1092        Py_INCREF(cunote->func);
1093        Py_XINCREF(cunote->data);
1094
1095        gtk_source_gutter_set_cell_size_func(GTK_SOURCE_GUTTER(self->obj), cell,
1096                                        pygtksourceview_cell_size_func_marshal,
1097                                        cunote,
1098                                        pygtksourceview_custom_destroy_notify);
1099    }
1100
1101    Py_INCREF(Py_None);
1102    return Py_None;
1103}
1104
1105%%
1106override gtk_source_view_set_mark_category_tooltip_func kwargs
1107static gchar *
1108pygtksourceview_mark_tooltip_func_marshal (GtkSourceMark *mark,
1109                                           gpointer data)
1110{
1111    PyGILState_STATE state;
1112    PyGtkSourceViewCustomNotify *cunote = data;
1113    PyObject *retobj;
1114    PyObject *pymark;
1115    gchar *retval = NULL;
1116
1117    g_assert (cunote->func);
1118
1119    state = pyg_gil_state_ensure();
1120
1121    pymark = pygobject_new((GObject *)mark);
1122
1123    if (cunote->data)
1124        retobj = PyEval_CallFunction(cunote->func, "(NO)",
1125                                     pymark,
1126                                     cunote->data);
1127    else
1128        retobj = PyEval_CallFunction(cunote->func, "(N)",
1129                                     pymark);
1130
1131    if (retobj == NULL) {
1132        PyErr_Print();
1133    } else
1134        retval = PyString_AsString(retobj);
1135        Py_DECREF(retobj);
1136
1137    pyg_gil_state_release(state);
1138
1139    return retval;
1140}
1141
1142static PyObject *
1143_wrap_gtk_source_view_set_mark_category_tooltip_func (PyGObject *self,
1144                                                      PyObject *args,
1145                                                      PyObject *kwargs)
1146{
1147    PyObject *pyfunc, *pyarg = NULL;
1148    PyGtkSourceViewCustomNotify *cunote;
1149    gchar *category;
1150
1151    if (!PyArg_ParseTuple(args, "sO|O:GtkSourceView.set_mark_category_tooltip_func",
1152                          &category, &pyfunc, &pyarg))
1153        return NULL;
1154
1155    if (pyfunc == Py_None) {
1156        gtk_source_view_set_mark_category_tooltip_func(GTK_SOURCE_VIEW(self->obj),
1157                                        category, NULL, NULL, NULL);
1158    } else {
1159        cunote = g_new0(PyGtkSourceViewCustomNotify, 1);
1160        cunote->func = pyfunc;
1161        cunote->data = pyarg;
1162        Py_INCREF(cunote->func);
1163        Py_XINCREF(cunote->data);
1164
1165        gtk_source_view_set_mark_category_tooltip_func(GTK_SOURCE_VIEW(self->obj),
1166                                        category,
1167                                        pygtksourceview_mark_tooltip_func_marshal,
1168                                        cunote,
1169                                        pygtksourceview_custom_destroy_notify);
1170    }
1171
1172    Py_INCREF(Py_None);
1173    return Py_None;
1174}
1175
1176%%
1177override gtk_source_view_set_mark_category_tooltip_markup_func kwargs
1178static PyObject *
1179_wrap_gtk_source_view_set_mark_category_tooltip_markup_func (PyGObject *self,
1180                                                             PyObject *args,
1181                                                             PyObject *kwargs)
1182{
1183    PyObject *pyfunc, *pyarg = NULL;
1184    PyGtkSourceViewCustomNotify *cunote;
1185    gchar *category;
1186
1187    if (!PyArg_ParseTuple(args, "sO|O:GtkSourceView.set_mark_category_tooltip_markup_func",
1188                          &category, &pyfunc, &pyarg))
1189        return NULL;
1190
1191    if (pyfunc == Py_None) {
1192        gtk_source_view_set_mark_category_tooltip_markup_func(GTK_SOURCE_VIEW(self->obj),
1193                                        category, NULL, NULL, NULL);
1194    } else {
1195        cunote = g_new0(PyGtkSourceViewCustomNotify, 1);
1196        cunote->func = pyfunc;
1197        cunote->data = pyarg;
1198        Py_INCREF(cunote->func);
1199        Py_XINCREF(cunote->data);
1200
1201        gtk_source_view_set_mark_category_tooltip_markup_func(GTK_SOURCE_VIEW(self->obj),
1202                                        category,
1203                                        pygtksourceview_mark_tooltip_func_marshal,
1204                                        cunote,
1205                                        pygtksourceview_custom_destroy_notify);
1206    }
1207
1208    Py_INCREF(Py_None);
1209    return Py_None;
1210}
1211
1212%%
1213override gtk_source_completion_words_new kwargs
1214static int
1215_wrap_gtk_source_completion_words_new(PyGObject *self, PyObject *args, PyObject *kwargs)
1216{
1217    static char *kwlist[] = { "name", "icon", NULL };
1218    char *name = NULL;
1219    PyGObject *icon = NULL;
1220
1221    if (!PyArg_ParseTupleAndKeywords(args,
1222                                     kwargs,
1223                                     "|sO!:GtkSourceCompletionWords.__init__",
1224                                     kwlist,
1225                                     &name, &PyGdkPixbuf_Type, &icon))
1226        return -1;
1227
1228    self->obj = (GObject *)gtk_source_completion_words_new(name, icon ? GDK_PIXBUF(icon->obj) : NULL);
1229
1230    if (!self->obj) {
1231        PyErr_SetString(PyExc_RuntimeError, "could not create GtkSourceCompletionWords object");
1232        return -1;
1233    }
1234    pygobject_register_wrapper((PyObject *)self);
1235    return 0;
1236}
1237
1238%%
1239override gtk_source_buffer_get_context_classes_at_iter kwargs
1240static PyObject *
1241_wrap_gtk_source_buffer_get_context_classes_at_iter(PyGObject *self, PyObject *args, PyObject *kwargs)
1242{
1243    static char *kwlist[] = { "iter", NULL };
1244    PyObject *py_iter;
1245    GtkTextIter *iter = NULL;
1246    gchar **context_classes;
1247
1248    PyObject *ret;
1249
1250    if (!PyArg_ParseTupleAndKeywords(args,
1251                                     kwargs,
1252                                     "Os:GtkSourceBuffer.get_context_classes_at_iter",
1253                                     kwlist,
1254                                     &py_iter))
1255        return NULL;
1256
1257    if (pyg_boxed_check(py_iter, GTK_TYPE_TEXT_ITER))
1258    {
1259        iter = pyg_boxed_get(py_iter, GtkTextIter);
1260    }
1261    else
1262    {
1263        PyErr_SetString(PyExc_TypeError, "iter should be a GtkTextIter");
1264        return NULL;
1265    }
1266
1267    context_classes = gtk_source_buffer_get_context_classes_at_iter (GTK_SOURCE_BUFFER (self->obj),
1268                                                                     iter);
1269    ret = strv_to_pylist (context_classes);
1270    g_strfreev (context_classes);
1271
1272    return ret;
1273}
1274