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