static PyObject *_wrap_gtk_scintilla_get_type(PyObject *self, PyObject *args) {
    if (!PyArg_ParseTuple(args, ":gtk_scintilla_get_type"))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_type());
}

static PyObject *_wrap_gtk_scintilla_new(PyObject *self, PyObject *args) {
    if (!PyArg_ParseTuple(args, ":gtk_scintilla_new"))
        return NULL;
    return PyGtk_New((GtkObject *)gtk_scintilla_new());
}

static PyObject *_wrap_gtk_scintilla_insert_text(PyObject *self, PyObject *args) {
    int pos;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_insert_text", &PyGtk_Type, &sci, &pos, &text))
        return NULL;
    gtk_scintilla_insert_text(GTK_SCINTILLA(PyGtk_Get(sci)), pos, text);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_clear_all(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_clear_all", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_clear_all(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_clear_document_style(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_clear_document_style", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_clear_document_style(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_length(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_length", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_length(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_char_at(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_char_at", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_char_at(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_get_current_pos(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_current_pos", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_current_pos(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_anchor(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_anchor", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_anchor(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_style_at(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_style_at", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_style_at(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_redo(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_redo", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_redo(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_undo_collection(PyObject *self, PyObject *args) {
    int collect_undo;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_undo_collection", &PyGtk_Type, &sci, &collect_undo))
        return NULL;
    gtk_scintilla_set_undo_collection(GTK_SCINTILLA(PyGtk_Get(sci)), collect_undo);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_select_all(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_select_all", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_select_all(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_save_point(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_set_save_point", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_set_save_point(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_can_redo(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_can_redo", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_can_redo(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_marker_line_from_handle(PyObject *self, PyObject *args) {
    int handle;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_marker_line_from_handle", &PyGtk_Type, &sci, &handle))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_marker_line_from_handle(GTK_SCINTILLA(PyGtk_Get(sci)), handle));
}

static PyObject *_wrap_gtk_scintilla_marker_delete_handle(PyObject *self, PyObject *args) {
    int handle;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_marker_delete_handle", &PyGtk_Type, &sci, &handle))
        return NULL;
    gtk_scintilla_marker_delete_handle(GTK_SCINTILLA(PyGtk_Get(sci)), handle);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_undo_collection(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_undo_collection", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_undo_collection(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_view_ws(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_view_ws", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_view_ws(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_view_ws(PyObject *self, PyObject *args) {
    int view_ws;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_view_ws", &PyGtk_Type, &sci, &view_ws))
        return NULL;
    gtk_scintilla_set_view_ws(GTK_SCINTILLA(PyGtk_Get(sci)), view_ws);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_position_from_point(PyObject *self, PyObject *args) {
    int x, y;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_position_from_point", &PyGtk_Type, &sci, &x, &y))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_position_from_point(GTK_SCINTILLA(PyGtk_Get(sci)), x, y));
}

static PyObject *_wrap_gtk_scintilla_position_from_point_close(PyObject *self, PyObject *args) {
    int x, y;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_position_from_point_close", &PyGtk_Type, &sci, &x, &y))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_position_from_point_close(GTK_SCINTILLA(PyGtk_Get(sci)), x, y));
}

static PyObject *_wrap_gtk_scintilla_goto_line(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_goto_line", &PyGtk_Type, &sci, &line))
        return NULL;
    gtk_scintilla_goto_line(GTK_SCINTILLA(PyGtk_Get(sci)), line);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_goto_pos(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_goto_pos", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_goto_pos(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_anchor(PyObject *self, PyObject *args) {
    int pos_anchor;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_anchor", &PyGtk_Type, &sci, &pos_anchor))
        return NULL;
    gtk_scintilla_set_anchor(GTK_SCINTILLA(PyGtk_Get(sci)), pos_anchor);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_cur_line(PyObject *self, PyObject *args) {
    int length;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_get_cur_line", &PyGtk_Type, &sci, &length, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_cur_line(GTK_SCINTILLA(PyGtk_Get(sci)), length, text));
}

static PyObject *_wrap_gtk_scintilla_get_end_styled(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_end_styled", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_end_styled(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_convert_eols(PyObject *self, PyObject *args) {
    int eol_mode;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_convert_eols", &PyGtk_Type, &sci, &eol_mode))
        return NULL;
    gtk_scintilla_convert_eols(GTK_SCINTILLA(PyGtk_Get(sci)), eol_mode);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_eol_mode(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_eol_mode", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_eol_mode(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_eol_mode(PyObject *self, PyObject *args) {
    int eol_mode;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_eol_mode", &PyGtk_Type, &sci, &eol_mode))
        return NULL;
    gtk_scintilla_set_eol_mode(GTK_SCINTILLA(PyGtk_Get(sci)), eol_mode);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_start_styling(PyObject *self, PyObject *args) {
    int pos, mask;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_start_styling", &PyGtk_Type, &sci, &pos, &mask))
        return NULL;
    gtk_scintilla_start_styling(GTK_SCINTILLA(PyGtk_Get(sci)), pos, mask);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_styling(PyObject *self, PyObject *args) {
    int length, style;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_styling", &PyGtk_Type, &sci, &length, &style))
        return NULL;
    gtk_scintilla_set_styling(GTK_SCINTILLA(PyGtk_Get(sci)), length, style);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_buffered_draw(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_buffered_draw", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_buffered_draw(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_buffered_draw(PyObject *self, PyObject *args) {
    int buffered;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_buffered_draw", &PyGtk_Type, &sci, &buffered))
        return NULL;
    gtk_scintilla_set_buffered_draw(GTK_SCINTILLA(PyGtk_Get(sci)), buffered);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_tab_width(PyObject *self, PyObject *args) {
    int tab_width;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_tab_width", &PyGtk_Type, &sci, &tab_width))
        return NULL;
    gtk_scintilla_set_tab_width(GTK_SCINTILLA(PyGtk_Get(sci)), tab_width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_tab_width(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_tab_width", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_tab_width(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_code_page(PyObject *self, PyObject *args) {
    int code_page;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_code_page", &PyGtk_Type, &sci, &code_page))
        return NULL;
    gtk_scintilla_set_code_page(GTK_SCINTILLA(PyGtk_Get(sci)), code_page);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_use_palette(PyObject *self, PyObject *args) {
    int use_palette;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_use_palette", &PyGtk_Type, &sci, &use_palette))
        return NULL;
    gtk_scintilla_set_use_palette(GTK_SCINTILLA(PyGtk_Get(sci)), use_palette);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_define(PyObject *self, PyObject *args) {
    int marker_number, marker_symbol;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_define", &PyGtk_Type, &sci, &marker_number, &marker_symbol))
        return NULL;
    gtk_scintilla_marker_define(GTK_SCINTILLA(PyGtk_Get(sci)), marker_number, marker_symbol);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_set_fore(PyObject *self, PyObject *args) {
    int marker_number, fore;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_set_fore", &PyGtk_Type, &sci, &marker_number, &fore))
        return NULL;
    gtk_scintilla_marker_set_fore(GTK_SCINTILLA(PyGtk_Get(sci)), marker_number, fore);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_set_back(PyObject *self, PyObject *args) {
    int marker_number, back;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_set_back", &PyGtk_Type, &sci, &marker_number, &back))
        return NULL;
    gtk_scintilla_marker_set_back(GTK_SCINTILLA(PyGtk_Get(sci)), marker_number, back);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_add(PyObject *self, PyObject *args) {
    int line, marker_number;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_add", &PyGtk_Type, &sci, &line, &marker_number))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_marker_add(GTK_SCINTILLA(PyGtk_Get(sci)), line, marker_number));
}

static PyObject *_wrap_gtk_scintilla_marker_delete(PyObject *self, PyObject *args) {
    int line, marker_number;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_delete", &PyGtk_Type, &sci, &line, &marker_number))
        return NULL;
    gtk_scintilla_marker_delete(GTK_SCINTILLA(PyGtk_Get(sci)), line, marker_number);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_delete_all(PyObject *self, PyObject *args) {
    int marker_number;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_marker_delete_all", &PyGtk_Type, &sci, &marker_number))
        return NULL;
    gtk_scintilla_marker_delete_all(GTK_SCINTILLA(PyGtk_Get(sci)), marker_number);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_marker_get(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_marker_get", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_marker_get(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_marker_next(PyObject *self, PyObject *args) {
    int line_start, marker_mask;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_next", &PyGtk_Type, &sci, &line_start, &marker_mask))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_marker_next(GTK_SCINTILLA(PyGtk_Get(sci)), line_start, marker_mask));
}

static PyObject *_wrap_gtk_scintilla_marker_previous(PyObject *self, PyObject *args) {
    int line_start, marker_mask;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_marker_previous", &PyGtk_Type, &sci, &line_start, &marker_mask))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_marker_previous(GTK_SCINTILLA(PyGtk_Get(sci)), line_start, marker_mask));
}

static PyObject *_wrap_gtk_scintilla_set_margin_type_n(PyObject *self, PyObject *args) {
    int margin, margin_type;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_margin_type_n", &PyGtk_Type, &sci, &margin, &margin_type))
        return NULL;
    gtk_scintilla_set_margin_type_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin, margin_type);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_type_n(PyObject *self, PyObject *args) {
    int margin;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_margin_type_n", &PyGtk_Type, &sci, &margin))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_type_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin));
}

static PyObject *_wrap_gtk_scintilla_set_margin_width_n(PyObject *self, PyObject *args) {
    int margin, pixel_width;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_margin_width_n", &PyGtk_Type, &sci, &margin, &pixel_width))
        return NULL;
    gtk_scintilla_set_margin_width_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin, pixel_width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_width_n(PyObject *self, PyObject *args) {
    int margin;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_margin_width_n", &PyGtk_Type, &sci, &margin))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_width_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin));
}

static PyObject *_wrap_gtk_scintilla_set_margin_mask_n(PyObject *self, PyObject *args) {
    int margin, mask;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_margin_mask_n", &PyGtk_Type, &sci, &margin, &mask))
        return NULL;
    gtk_scintilla_set_margin_mask_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin, mask);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_mask_n(PyObject *self, PyObject *args) {
    int margin;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_margin_mask_n", &PyGtk_Type, &sci, &margin))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_mask_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin));
}

static PyObject *_wrap_gtk_scintilla_set_margin_sensitive_n(PyObject *self, PyObject *args) {
    int margin, sensitive;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_margin_sensitive_n", &PyGtk_Type, &sci, &margin, &sensitive))
        return NULL;
    gtk_scintilla_set_margin_sensitive_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin, sensitive);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_sensitive_n(PyObject *self, PyObject *args) {
    int margin;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_margin_sensitive_n", &PyGtk_Type, &sci, &margin))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_sensitive_n(GTK_SCINTILLA(PyGtk_Get(sci)), margin));
}

static PyObject *_wrap_gtk_scintilla_style_clear_all(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_style_clear_all", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_style_clear_all(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_fore(PyObject *self, PyObject *args) {
    int style, fore;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_fore", &PyGtk_Type, &sci, &style, &fore))
        return NULL;
    gtk_scintilla_style_set_fore(GTK_SCINTILLA(PyGtk_Get(sci)), style, fore);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_back(PyObject *self, PyObject *args) {
    int style, back;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_back", &PyGtk_Type, &sci, &style, &back))
        return NULL;
    gtk_scintilla_style_set_back(GTK_SCINTILLA(PyGtk_Get(sci)), style, back);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_bold(PyObject *self, PyObject *args) {
    int style, bold;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_bold", &PyGtk_Type, &sci, &style, &bold))
        return NULL;
    gtk_scintilla_style_set_bold(GTK_SCINTILLA(PyGtk_Get(sci)), style, bold);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_italic(PyObject *self, PyObject *args) {
    int style, italic;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_italic", &PyGtk_Type, &sci, &style, &italic))
        return NULL;
    gtk_scintilla_style_set_italic(GTK_SCINTILLA(PyGtk_Get(sci)), style, italic);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_size(PyObject *self, PyObject *args) {
    int style, size_points;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_size", &PyGtk_Type, &sci, &style, &size_points))
        return NULL;
    gtk_scintilla_style_set_size(GTK_SCINTILLA(PyGtk_Get(sci)), style, size_points);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_font(PyObject *self, PyObject *args) {
    int style;
    char *font_name;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_style_set_font", &PyGtk_Type, &sci, &style, &font_name))
        return NULL;
    gtk_scintilla_style_set_font(GTK_SCINTILLA(PyGtk_Get(sci)), style, font_name);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_eol_filled(PyObject *self, PyObject *args) {
    int style, filled;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_eol_filled", &PyGtk_Type, &sci, &style, &filled))
        return NULL;
    gtk_scintilla_style_set_eol_filled(GTK_SCINTILLA(PyGtk_Get(sci)), style, filled);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_reset_default(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_style_reset_default", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_style_reset_default(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_underline(PyObject *self, PyObject *args) {
    int style, underline;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_underline", &PyGtk_Type, &sci, &style, &underline))
        return NULL;
    gtk_scintilla_style_set_underline(GTK_SCINTILLA(PyGtk_Get(sci)), style, underline);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_case(PyObject *self, PyObject *args) {
    int style, case_force;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_case", &PyGtk_Type, &sci, &style, &case_force))
        return NULL;
    gtk_scintilla_style_set_case(GTK_SCINTILLA(PyGtk_Get(sci)), style, case_force);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_character_set(PyObject *self, PyObject *args) {
    int style, character_set;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_character_set", &PyGtk_Type, &sci, &style, &character_set))
        return NULL;
    gtk_scintilla_style_set_character_set(GTK_SCINTILLA(PyGtk_Get(sci)), style, character_set);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_sel_fore(PyObject *self, PyObject *args) {
    int use_setting, fore;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_sel_fore", &PyGtk_Type, &sci, &use_setting, &fore))
        return NULL;
    gtk_scintilla_set_sel_fore(GTK_SCINTILLA(PyGtk_Get(sci)), use_setting, fore);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_sel_back(PyObject *self, PyObject *args) {
    int use_setting, back;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_sel_back", &PyGtk_Type, &sci, &use_setting, &back))
        return NULL;
    gtk_scintilla_set_sel_back(GTK_SCINTILLA(PyGtk_Get(sci)), use_setting, back);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_caret_fore(PyObject *self, PyObject *args) {
    int fore;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_caret_fore", &PyGtk_Type, &sci, &fore))
        return NULL;
    gtk_scintilla_set_caret_fore(GTK_SCINTILLA(PyGtk_Get(sci)), fore);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_clear_all_cmd_keys(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_clear_all_cmd_keys", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_clear_all_cmd_keys(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_styling_ex(PyObject *self, PyObject *args) {
    int length;
    char *styles;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_set_styling_ex", &PyGtk_Type, &sci, &length, &styles))
        return NULL;
    gtk_scintilla_set_styling_ex(GTK_SCINTILLA(PyGtk_Get(sci)), length, styles);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_visible(PyObject *self, PyObject *args) {
    int style, visible;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_visible", &PyGtk_Type, &sci, &style, &visible))
        return NULL;
    gtk_scintilla_style_set_visible(GTK_SCINTILLA(PyGtk_Get(sci)), style, visible);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_caret_period(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_caret_period", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_caret_period(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_caret_period(PyObject *self, PyObject *args) {
    int period_milliseconds;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_caret_period", &PyGtk_Type, &sci, &period_milliseconds))
        return NULL;
    gtk_scintilla_set_caret_period(GTK_SCINTILLA(PyGtk_Get(sci)), period_milliseconds);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_word_chars(PyObject *self, PyObject *args) {
    char *characters;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_set_word_chars", &PyGtk_Type, &sci, &characters))
        return NULL;
    gtk_scintilla_set_word_chars(GTK_SCINTILLA(PyGtk_Get(sci)), characters);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_begin_undo_action(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_begin_undo_action", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_begin_undo_action(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_end_undo_action(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_end_undo_action", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_end_undo_action(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_indic_set_style(PyObject *self, PyObject *args) {
    int indic, style;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_indic_set_style", &PyGtk_Type, &sci, &indic, &style))
        return NULL;
    gtk_scintilla_indic_set_style(GTK_SCINTILLA(PyGtk_Get(sci)), indic, style);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_indic_get_style(PyObject *self, PyObject *args) {
    int indic;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_indic_get_style", &PyGtk_Type, &sci, &indic))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_indic_get_style(GTK_SCINTILLA(PyGtk_Get(sci)), indic));
}

static PyObject *_wrap_gtk_scintilla_indic_set_fore(PyObject *self, PyObject *args) {
    int indic, fore;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_indic_set_fore", &PyGtk_Type, &sci, &indic, &fore))
        return NULL;
    gtk_scintilla_indic_set_fore(GTK_SCINTILLA(PyGtk_Get(sci)), indic, fore);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_indic_get_fore(PyObject *self, PyObject *args) {
    int indic;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_indic_get_fore", &PyGtk_Type, &sci, &indic))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_indic_get_fore(GTK_SCINTILLA(PyGtk_Get(sci)), indic));
}

static PyObject *_wrap_gtk_scintilla_set_style_bits(PyObject *self, PyObject *args) {
    int bits;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_style_bits", &PyGtk_Type, &sci, &bits))
        return NULL;
    gtk_scintilla_set_style_bits(GTK_SCINTILLA(PyGtk_Get(sci)), bits);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_style_bits(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_style_bits", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_style_bits(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_line_state(PyObject *self, PyObject *args) {
    int line, state;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_line_state", &PyGtk_Type, &sci, &line, &state))
        return NULL;
    gtk_scintilla_set_line_state(GTK_SCINTILLA(PyGtk_Get(sci)), line, state);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_line_state(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_line_state", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_state(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_get_max_line_state(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_max_line_state", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_max_line_state(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_caret_line_visible(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_caret_line_visible", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_caret_line_visible(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_caret_line_visible(PyObject *self, PyObject *args) {
    int show;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_caret_line_visible", &PyGtk_Type, &sci, &show))
        return NULL;
    gtk_scintilla_set_caret_line_visible(GTK_SCINTILLA(PyGtk_Get(sci)), show);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_caret_line_back(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_caret_line_back", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_caret_line_back(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_caret_line_back(PyObject *self, PyObject *args) {
    int back;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_caret_line_back", &PyGtk_Type, &sci, &back))
        return NULL;
    gtk_scintilla_set_caret_line_back(GTK_SCINTILLA(PyGtk_Get(sci)), back);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_style_set_changeable(PyObject *self, PyObject *args) {
    int style, changeable;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_style_set_changeable", &PyGtk_Type, &sci, &style, &changeable))
        return NULL;
    gtk_scintilla_style_set_changeable(GTK_SCINTILLA(PyGtk_Get(sci)), style, changeable);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_show(PyObject *self, PyObject *args) {
    int len_entered;
    char *item_list;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_autoc_show", &PyGtk_Type, &sci, &len_entered, &item_list))
        return NULL;
    gtk_scintilla_autoc_show(GTK_SCINTILLA(PyGtk_Get(sci)), len_entered, item_list);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_cancel(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_cancel", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_autoc_cancel(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_active(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_active", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_active(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_pos_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_pos_start", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_pos_start(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_complete(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_complete", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_autoc_complete(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_stops(PyObject *self, PyObject *args) {
    char *character_set;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_autoc_stops", &PyGtk_Type, &sci, &character_set))
        return NULL;
    gtk_scintilla_autoc_stops(GTK_SCINTILLA(PyGtk_Get(sci)), character_set);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_set_separator(PyObject *self, PyObject *args) {
    int separator_character;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_separator", &PyGtk_Type, &sci, &separator_character))
        return NULL;
    gtk_scintilla_autoc_set_separator(GTK_SCINTILLA(PyGtk_Get(sci)), separator_character);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_separator(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_separator", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_separator(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_select(PyObject *self, PyObject *args) {
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_autoc_select", &PyGtk_Type, &sci, &text))
        return NULL;
    gtk_scintilla_autoc_select(GTK_SCINTILLA(PyGtk_Get(sci)), text);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_set_cancel_at_start(PyObject *self, PyObject *args) {
    int cancel;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_cancel_at_start", &PyGtk_Type, &sci, &cancel))
        return NULL;
    gtk_scintilla_autoc_set_cancel_at_start(GTK_SCINTILLA(PyGtk_Get(sci)), cancel);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_cancel_at_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_cancel_at_start", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_cancel_at_start(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_set_fill_ups(PyObject *self, PyObject *args) {
    char *character_set;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_autoc_set_fill_ups", &PyGtk_Type, &sci, &character_set))
        return NULL;
    gtk_scintilla_autoc_set_fill_ups(GTK_SCINTILLA(PyGtk_Get(sci)), character_set);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_set_choose_single(PyObject *self, PyObject *args) {
    int choose_single;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_choose_single", &PyGtk_Type, &sci, &choose_single))
        return NULL;
    gtk_scintilla_autoc_set_choose_single(GTK_SCINTILLA(PyGtk_Get(sci)), choose_single);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_choose_single(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_choose_single", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_choose_single(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_set_ignore_case(PyObject *self, PyObject *args) {
    int ignore_case;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_ignore_case", &PyGtk_Type, &sci, &ignore_case))
        return NULL;
    gtk_scintilla_autoc_set_ignore_case(GTK_SCINTILLA(PyGtk_Get(sci)), ignore_case);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_ignore_case(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_ignore_case", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_ignore_case(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_user_list_show(PyObject *self, PyObject *args) {
    int list_type;
    char *item_list;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_user_list_show", &PyGtk_Type, &sci, &list_type, &item_list))
        return NULL;
    gtk_scintilla_user_list_show(GTK_SCINTILLA(PyGtk_Get(sci)), list_type, item_list);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_set_auto_hide(PyObject *self, PyObject *args) {
    int auto_hide;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_auto_hide", &PyGtk_Type, &sci, &auto_hide))
        return NULL;
    gtk_scintilla_autoc_set_auto_hide(GTK_SCINTILLA(PyGtk_Get(sci)), auto_hide);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_auto_hide(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_auto_hide", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_auto_hide(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_autoc_set_drop_rest_of_word(PyObject *self, PyObject *args) {
    int drop_rest_of_word;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_autoc_set_drop_rest_of_word", &PyGtk_Type, &sci, &drop_rest_of_word))
        return NULL;
    gtk_scintilla_autoc_set_drop_rest_of_word(GTK_SCINTILLA(PyGtk_Get(sci)), drop_rest_of_word);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_autoc_get_drop_rest_of_word(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_autoc_get_drop_rest_of_word", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_autoc_get_drop_rest_of_word(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_indent(PyObject *self, PyObject *args) {
    int indent_size;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_indent", &PyGtk_Type, &sci, &indent_size))
        return NULL;
    gtk_scintilla_set_indent(GTK_SCINTILLA(PyGtk_Get(sci)), indent_size);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_indent(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_indent", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_indent(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_use_tabs(PyObject *self, PyObject *args) {
    int use_tabs;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_use_tabs", &PyGtk_Type, &sci, &use_tabs))
        return NULL;
    gtk_scintilla_set_use_tabs(GTK_SCINTILLA(PyGtk_Get(sci)), use_tabs);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_use_tabs(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_use_tabs", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_use_tabs(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_line_indentation(PyObject *self, PyObject *args) {
    int line, indent_size;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_line_indentation", &PyGtk_Type, &sci, &line, &indent_size))
        return NULL;
    gtk_scintilla_set_line_indentation(GTK_SCINTILLA(PyGtk_Get(sci)), line, indent_size);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_line_indentation(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_line_indentation", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_indentation(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_get_line_indent_position(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_line_indent_position", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_indent_position(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_get_column(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_column", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_column(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_set_h_scroll_bar(PyObject *self, PyObject *args) {
    int show;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_h_scroll_bar", &PyGtk_Type, &sci, &show))
        return NULL;
    gtk_scintilla_set_h_scroll_bar(GTK_SCINTILLA(PyGtk_Get(sci)), show);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_h_scroll_bar(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_h_scroll_bar", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_h_scroll_bar(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_indentation_guides(PyObject *self, PyObject *args) {
    int show;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_indentation_guides", &PyGtk_Type, &sci, &show))
        return NULL;
    gtk_scintilla_set_indentation_guides(GTK_SCINTILLA(PyGtk_Get(sci)), show);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_indentation_guides(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_indentation_guides", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_indentation_guides(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_highlight_guide(PyObject *self, PyObject *args) {
    int column;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_highlight_guide", &PyGtk_Type, &sci, &column))
        return NULL;
    gtk_scintilla_set_highlight_guide(GTK_SCINTILLA(PyGtk_Get(sci)), column);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_highlight_guide(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_highlight_guide", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_highlight_guide(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_line_end_position(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_line_end_position", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_end_position(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_get_code_page(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_code_page", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_code_page(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_caret_fore(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_caret_fore", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_caret_fore(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_use_palette(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_use_palette", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_use_palette(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_read_only(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_read_only", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_read_only(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_current_pos(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_current_pos", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_set_current_pos(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_selection_start(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_selection_start", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_set_selection_start(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_selection_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_selection_start", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_selection_start(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_selection_end(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_selection_end", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_set_selection_end(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_selection_end(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_selection_end", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_selection_end(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_print_magnification(PyObject *self, PyObject *args) {
    int magnification;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_print_magnification", &PyGtk_Type, &sci, &magnification))
        return NULL;
    gtk_scintilla_set_print_magnification(GTK_SCINTILLA(PyGtk_Get(sci)), magnification);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_print_magnification(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_print_magnification", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_print_magnification(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_print_colour_mode(PyObject *self, PyObject *args) {
    int mode;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_print_colour_mode", &PyGtk_Type, &sci, &mode))
        return NULL;
    gtk_scintilla_set_print_colour_mode(GTK_SCINTILLA(PyGtk_Get(sci)), mode);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_print_colour_mode(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_print_colour_mode", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_print_colour_mode(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_first_visible_line(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_first_visible_line", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_first_visible_line(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_line_count(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_line_count", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_count(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_margin_left(PyObject *self, PyObject *args) {
    int pixel_width;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_margin_left", &PyGtk_Type, &sci, &pixel_width))
        return NULL;
    gtk_scintilla_set_margin_left(GTK_SCINTILLA(PyGtk_Get(sci)), pixel_width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_margin_left", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_left(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_margin_right(PyObject *self, PyObject *args) {
    int pixel_width;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_margin_right", &PyGtk_Type, &sci, &pixel_width))
        return NULL;
    gtk_scintilla_set_margin_right(GTK_SCINTILLA(PyGtk_Get(sci)), pixel_width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_margin_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_margin_right", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_margin_right(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_modify(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_modify", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_modify(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_sel(PyObject *self, PyObject *args) {
    int start, end;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_sel", &PyGtk_Type, &sci, &start, &end))
        return NULL;
    gtk_scintilla_set_sel(GTK_SCINTILLA(PyGtk_Get(sci)), start, end);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_hide_selection(PyObject *self, PyObject *args) {
    int normal;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_hide_selection", &PyGtk_Type, &sci, &normal))
        return NULL;
    gtk_scintilla_hide_selection(GTK_SCINTILLA(PyGtk_Get(sci)), normal);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_point_x_from_position(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_point_x_from_position", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_point_x_from_position(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_point_y_from_position(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_point_y_from_position", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_point_y_from_position(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_line_from_position(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_line_from_position", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_line_from_position(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_position_from_line(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_position_from_line", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_position_from_line(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_line_scroll(PyObject *self, PyObject *args) {
    int columns, lines;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_line_scroll", &PyGtk_Type, &sci, &columns, &lines))
        return NULL;
    gtk_scintilla_line_scroll(GTK_SCINTILLA(PyGtk_Get(sci)), columns, lines);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_scroll_caret(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_scroll_caret", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_scroll_caret(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_replace_sel(PyObject *self, PyObject *args) {
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_replace_sel", &PyGtk_Type, &sci, &text))
        return NULL;
    gtk_scintilla_replace_sel(GTK_SCINTILLA(PyGtk_Get(sci)), text);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_read_only(PyObject *self, PyObject *args) {
    int read_only;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_read_only", &PyGtk_Type, &sci, &read_only))
        return NULL;
    gtk_scintilla_set_read_only(GTK_SCINTILLA(PyGtk_Get(sci)), read_only);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_null(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_null", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_null(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_can_paste(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_can_paste", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_can_paste(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_can_undo(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_can_undo", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_can_undo(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_empty_undo_buffer(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_empty_undo_buffer", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_empty_undo_buffer(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_undo(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_undo", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_undo(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_cut(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_cut", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_cut(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_copy(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_copy", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_copy(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_paste(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_paste", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_paste(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_clear(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_clear", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_clear(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_text_length(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_text_length", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_text_length(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_direct_function(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_direct_function", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_direct_function(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_get_direct_pointer(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_direct_pointer", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_direct_pointer(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_overtype(PyObject *self, PyObject *args) {
    int overtype;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_overtype", &PyGtk_Type, &sci, &overtype))
        return NULL;
    gtk_scintilla_set_overtype(GTK_SCINTILLA(PyGtk_Get(sci)), overtype);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_overtype(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_overtype", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_overtype(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_caret_width(PyObject *self, PyObject *args) {
    int pixel_width;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_caret_width", &PyGtk_Type, &sci, &pixel_width))
        return NULL;
    gtk_scintilla_set_caret_width(GTK_SCINTILLA(PyGtk_Get(sci)), pixel_width);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_caret_width(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_caret_width", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_caret_width(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_target_start(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_target_start", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_set_target_start(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_target_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_target_start", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_target_start(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_target_end(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_target_end", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_set_target_end(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_target_end(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_target_end", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_target_end(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_replace_target(PyObject *self, PyObject *args) {
    int length;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_replace_target", &PyGtk_Type, &sci, &length, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_replace_target(GTK_SCINTILLA(PyGtk_Get(sci)), length, text));
}

static PyObject *_wrap_gtk_scintilla_replace_target_re(PyObject *self, PyObject *args) {
    int length;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_replace_target_re", &PyGtk_Type, &sci, &length, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_replace_target_re(GTK_SCINTILLA(PyGtk_Get(sci)), length, text));
}

static PyObject *_wrap_gtk_scintilla_search_in_target(PyObject *self, PyObject *args) {
    int length;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_search_in_target", &PyGtk_Type, &sci, &length, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_search_in_target(GTK_SCINTILLA(PyGtk_Get(sci)), length, text));
}

static PyObject *_wrap_gtk_scintilla_set_search_flags(PyObject *self, PyObject *args) {
    int flags;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_search_flags", &PyGtk_Type, &sci, &flags))
        return NULL;
    gtk_scintilla_set_search_flags(GTK_SCINTILLA(PyGtk_Get(sci)), flags);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_search_flags(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_search_flags", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_search_flags(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_call_tip_show(PyObject *self, PyObject *args) {
    int pos;
    char *definition;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_call_tip_show", &PyGtk_Type, &sci, &pos, &definition))
        return NULL;
    gtk_scintilla_call_tip_show(GTK_SCINTILLA(PyGtk_Get(sci)), pos, definition);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_call_tip_cancel(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_call_tip_cancel", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_call_tip_cancel(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_call_tip_active(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_call_tip_active", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_call_tip_active(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_call_tip_pos_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_call_tip_pos_start", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_call_tip_pos_start(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_call_tip_set_hlt(PyObject *self, PyObject *args) {
    int start, end;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_call_tip_set_hlt", &PyGtk_Type, &sci, &start, &end))
        return NULL;
    gtk_scintilla_call_tip_set_hlt(GTK_SCINTILLA(PyGtk_Get(sci)), start, end);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_call_tip_set_back(PyObject *self, PyObject *args) {
    int back;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_call_tip_set_back", &PyGtk_Type, &sci, &back))
        return NULL;
    gtk_scintilla_call_tip_set_back(GTK_SCINTILLA(PyGtk_Get(sci)), back);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_visible_from_doc_line(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_visible_from_doc_line", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_visible_from_doc_line(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_doc_line_from_visible(PyObject *self, PyObject *args) {
    int line_display;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_doc_line_from_visible", &PyGtk_Type, &sci, &line_display))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_doc_line_from_visible(GTK_SCINTILLA(PyGtk_Get(sci)), line_display));
}

static PyObject *_wrap_gtk_scintilla_set_fold_level(PyObject *self, PyObject *args) {
    int line, level;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_fold_level", &PyGtk_Type, &sci, &line, &level))
        return NULL;
    gtk_scintilla_set_fold_level(GTK_SCINTILLA(PyGtk_Get(sci)), line, level);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_fold_level(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_fold_level", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_fold_level(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_get_last_child(PyObject *self, PyObject *args) {
    int line, level;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_get_last_child", &PyGtk_Type, &sci, &line, &level))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_last_child(GTK_SCINTILLA(PyGtk_Get(sci)), line, level));
}

static PyObject *_wrap_gtk_scintilla_get_fold_parent(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_fold_parent", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_fold_parent(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_show_lines(PyObject *self, PyObject *args) {
    int line_start, line_end;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_show_lines", &PyGtk_Type, &sci, &line_start, &line_end))
        return NULL;
    gtk_scintilla_show_lines(GTK_SCINTILLA(PyGtk_Get(sci)), line_start, line_end);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_hide_lines(PyObject *self, PyObject *args) {
    int line_start, line_end;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_hide_lines", &PyGtk_Type, &sci, &line_start, &line_end))
        return NULL;
    gtk_scintilla_hide_lines(GTK_SCINTILLA(PyGtk_Get(sci)), line_start, line_end);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_line_visible(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_line_visible", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_line_visible(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_set_fold_expanded(PyObject *self, PyObject *args) {
    int line, expanded;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_fold_expanded", &PyGtk_Type, &sci, &line, &expanded))
        return NULL;
    gtk_scintilla_set_fold_expanded(GTK_SCINTILLA(PyGtk_Get(sci)), line, expanded);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_fold_expanded(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_get_fold_expanded", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_fold_expanded(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_toggle_fold(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_toggle_fold", &PyGtk_Type, &sci, &line))
        return NULL;
    gtk_scintilla_toggle_fold(GTK_SCINTILLA(PyGtk_Get(sci)), line);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_ensure_visible(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_ensure_visible", &PyGtk_Type, &sci, &line))
        return NULL;
    gtk_scintilla_ensure_visible(GTK_SCINTILLA(PyGtk_Get(sci)), line);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_fold_flags(PyObject *self, PyObject *args) {
    int flags;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_fold_flags", &PyGtk_Type, &sci, &flags))
        return NULL;
    gtk_scintilla_set_fold_flags(GTK_SCINTILLA(PyGtk_Get(sci)), flags);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_ensure_visible_enforce_policy(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_ensure_visible_enforce_policy", &PyGtk_Type, &sci, &line))
        return NULL;
    gtk_scintilla_ensure_visible_enforce_policy(GTK_SCINTILLA(PyGtk_Get(sci)), line);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_tab_indents(PyObject *self, PyObject *args) {
    int tab_indents;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_tab_indents", &PyGtk_Type, &sci, &tab_indents))
        return NULL;
    gtk_scintilla_set_tab_indents(GTK_SCINTILLA(PyGtk_Get(sci)), tab_indents);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_tab_indents(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_tab_indents", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_tab_indents(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_backspace_unindents(PyObject *self, PyObject *args) {
    int bs_unindents;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_backspace_unindents", &PyGtk_Type, &sci, &bs_unindents))
        return NULL;
    gtk_scintilla_set_backspace_unindents(GTK_SCINTILLA(PyGtk_Get(sci)), bs_unindents);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_backspace_unindents(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_backspace_unindents", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_backspace_unindents(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_mouse_dwell_time(PyObject *self, PyObject *args) {
    int period_milliseconds;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_mouse_dwell_time", &PyGtk_Type, &sci, &period_milliseconds))
        return NULL;
    gtk_scintilla_set_mouse_dwell_time(GTK_SCINTILLA(PyGtk_Get(sci)), period_milliseconds);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_mouse_dwell_time(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_mouse_dwell_time", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_mouse_dwell_time(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_word_start_position(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_word_start_position", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_word_start_position(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_word_end_position(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_word_end_position", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_word_end_position(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_set_wrap_mode(PyObject *self, PyObject *args) {
    int mode;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_wrap_mode", &PyGtk_Type, &sci, &mode))
        return NULL;
    gtk_scintilla_set_wrap_mode(GTK_SCINTILLA(PyGtk_Get(sci)), mode);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_wrap_mode(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_wrap_mode", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_wrap_mode(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_line_down(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_down", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_down(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_down_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_down_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_down_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_up(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_up", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_up(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_up_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_up_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_up_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_char_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_char_left", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_char_left(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_char_left_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_char_left_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_char_left_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_char_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_char_right", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_char_right(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_char_right_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_char_right_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_char_right_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_left", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_left(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_left_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_left_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_left_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_right", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_right(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_right_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_right_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_right_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_home(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_home", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_home(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_home_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_home_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_home_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_end(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_end", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_end(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_end_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_end_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_end_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_document_start(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_document_start", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_document_start(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_document_start_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_document_start_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_document_start_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_document_end(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_document_end", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_document_end(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_document_end_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_document_end_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_document_end_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_page_up(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_page_up", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_page_up(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_page_up_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_page_up_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_page_up_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_page_down(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_page_down", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_page_down(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_page_down_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_page_down_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_page_down_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_edit_toggle_overtype(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_edit_toggle_overtype", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_edit_toggle_overtype(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_cancel(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_cancel", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_cancel(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_delete_back(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_delete_back", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_delete_back(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_tab(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_tab", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_tab(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_back_tab(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_back_tab", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_back_tab(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_new_line(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_new_line", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_new_line(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_form_feed(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_form_feed", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_form_feed(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_v_c_home(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_v_c_home", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_v_c_home(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_v_c_home_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_v_c_home_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_v_c_home_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_zoom_in(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_zoom_in", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_zoom_in(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_zoom_out(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_zoom_out", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_zoom_out(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_del_word_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_del_word_left", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_del_word_left(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_del_word_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_del_word_right", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_del_word_right(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_cut(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_cut", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_cut(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_delete(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_delete", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_delete(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_transpose(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_transpose", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_transpose(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_lower_case(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_lower_case", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_lower_case(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_upper_case(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_upper_case", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_upper_case(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_scroll_down(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_scroll_down", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_scroll_down(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_scroll_up(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_line_scroll_up", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_line_scroll_up(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_delete_back_not_line(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_delete_back_not_line", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_delete_back_not_line(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_move_caret_inside_view(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_move_caret_inside_view", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_move_caret_inside_view(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_line_length(PyObject *self, PyObject *args) {
    int line;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_line_length", &PyGtk_Type, &sci, &line))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_line_length(GTK_SCINTILLA(PyGtk_Get(sci)), line));
}

static PyObject *_wrap_gtk_scintilla_brace_highlight(PyObject *self, PyObject *args) {
    int pos1, pos2;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_brace_highlight", &PyGtk_Type, &sci, &pos1, &pos2))
        return NULL;
    gtk_scintilla_brace_highlight(GTK_SCINTILLA(PyGtk_Get(sci)), pos1, pos2);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_brace_bad_light(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_brace_bad_light", &PyGtk_Type, &sci, &pos))
        return NULL;
    gtk_scintilla_brace_bad_light(GTK_SCINTILLA(PyGtk_Get(sci)), pos);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_brace_match(PyObject *self, PyObject *args) {
    int pos;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_brace_match", &PyGtk_Type, &sci, &pos))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_brace_match(GTK_SCINTILLA(PyGtk_Get(sci)), pos));
}

static PyObject *_wrap_gtk_scintilla_get_view_eol(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_view_eol", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_view_eol(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_view_eol(PyObject *self, PyObject *args) {
    int visible;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_view_eol", &PyGtk_Type, &sci, &visible))
        return NULL;
    gtk_scintilla_set_view_eol(GTK_SCINTILLA(PyGtk_Get(sci)), visible);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_doc_pointer(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_doc_pointer", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_doc_pointer(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_doc_pointer(PyObject *self, PyObject *args) {
    int pointer;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_doc_pointer", &PyGtk_Type, &sci, &pointer))
        return NULL;
    gtk_scintilla_set_doc_pointer(GTK_SCINTILLA(PyGtk_Get(sci)), pointer);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_mod_event_mask(PyObject *self, PyObject *args) {
    int mask;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_mod_event_mask", &PyGtk_Type, &sci, &mask))
        return NULL;
    gtk_scintilla_set_mod_event_mask(GTK_SCINTILLA(PyGtk_Get(sci)), mask);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_edge_column(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_edge_column", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_edge_column(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_edge_column(PyObject *self, PyObject *args) {
    int column;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_edge_column", &PyGtk_Type, &sci, &column))
        return NULL;
    gtk_scintilla_set_edge_column(GTK_SCINTILLA(PyGtk_Get(sci)), column);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_edge_mode(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_edge_mode", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_edge_mode(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_edge_mode(PyObject *self, PyObject *args) {
    int mode;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_edge_mode", &PyGtk_Type, &sci, &mode))
        return NULL;
    gtk_scintilla_set_edge_mode(GTK_SCINTILLA(PyGtk_Get(sci)), mode);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_edge_colour(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_edge_colour", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_edge_colour(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_edge_colour(PyObject *self, PyObject *args) {
    int edge_colour;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_edge_colour", &PyGtk_Type, &sci, &edge_colour))
        return NULL;
    gtk_scintilla_set_edge_colour(GTK_SCINTILLA(PyGtk_Get(sci)), edge_colour);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_search_anchor(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_search_anchor", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_search_anchor(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_search_next(PyObject *self, PyObject *args) {
    int flags;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_search_next", &PyGtk_Type, &sci, &flags, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_search_next(GTK_SCINTILLA(PyGtk_Get(sci)), flags, text));
}

static PyObject *_wrap_gtk_scintilla_search_prev(PyObject *self, PyObject *args) {
    int flags;
    char *text;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_search_prev", &PyGtk_Type, &sci, &flags, &text))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_search_prev(GTK_SCINTILLA(PyGtk_Get(sci)), flags, text));
}

static PyObject *_wrap_gtk_scintilla_set_caret_policy(PyObject *self, PyObject *args) {
    int caret_policy, caret_slop;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_caret_policy", &PyGtk_Type, &sci, &caret_policy, &caret_slop))
        return NULL;
    gtk_scintilla_set_caret_policy(GTK_SCINTILLA(PyGtk_Get(sci)), caret_policy, caret_slop);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_lines_on_screen(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_lines_on_screen", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_lines_on_screen(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_use_pop_up(PyObject *self, PyObject *args) {
    int allow_pop_up;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_use_pop_up", &PyGtk_Type, &sci, &allow_pop_up))
        return NULL;
    gtk_scintilla_use_pop_up(GTK_SCINTILLA(PyGtk_Get(sci)), allow_pop_up);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_selection_is_rectangle(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_selection_is_rectangle", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_selection_is_rectangle(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_zoom(PyObject *self, PyObject *args) {
    int zoom;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_zoom", &PyGtk_Type, &sci, &zoom))
        return NULL;
    gtk_scintilla_set_zoom(GTK_SCINTILLA(PyGtk_Get(sci)), zoom);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_zoom(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_zoom", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_zoom(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_create_document(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_create_document", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_create_document(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_add_ref_document(PyObject *self, PyObject *args) {
    int doc;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_add_ref_document", &PyGtk_Type, &sci, &doc))
        return NULL;
    gtk_scintilla_add_ref_document(GTK_SCINTILLA(PyGtk_Get(sci)), doc);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_release_document(PyObject *self, PyObject *args) {
    int doc;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_release_document", &PyGtk_Type, &sci, &doc))
        return NULL;
    gtk_scintilla_release_document(GTK_SCINTILLA(PyGtk_Get(sci)), doc);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_mod_event_mask(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_mod_event_mask", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_mod_event_mask(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_focus(PyObject *self, PyObject *args) {
    int focus;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_focus", &PyGtk_Type, &sci, &focus))
        return NULL;
    gtk_scintilla_set_focus(GTK_SCINTILLA(PyGtk_Get(sci)), focus);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_focus(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_focus", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_focus(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_status(PyObject *self, PyObject *args) {
    int status_code;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_status", &PyGtk_Type, &sci, &status_code))
        return NULL;
    gtk_scintilla_set_status(GTK_SCINTILLA(PyGtk_Get(sci)), status_code);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_status(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_status", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_status(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_mouse_down_captures(PyObject *self, PyObject *args) {
    int captures;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_mouse_down_captures", &PyGtk_Type, &sci, &captures))
        return NULL;
    gtk_scintilla_set_mouse_down_captures(GTK_SCINTILLA(PyGtk_Get(sci)), captures);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_mouse_down_captures(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_mouse_down_captures", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_mouse_down_captures(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_cursor(PyObject *self, PyObject *args) {
    int cursor_type;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_cursor", &PyGtk_Type, &sci, &cursor_type))
        return NULL;
    gtk_scintilla_set_cursor(GTK_SCINTILLA(PyGtk_Get(sci)), cursor_type);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_cursor(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_cursor", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_cursor(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_set_control_char_symbol(PyObject *self, PyObject *args) {
    int symbol;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_control_char_symbol", &PyGtk_Type, &sci, &symbol))
        return NULL;
    gtk_scintilla_set_control_char_symbol(GTK_SCINTILLA(PyGtk_Get(sci)), symbol);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_control_char_symbol(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_control_char_symbol", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_control_char_symbol(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_word_part_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_part_left", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_part_left(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_part_left_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_part_left_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_part_left_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_part_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_part_right", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_part_right(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_word_part_right_extend(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_word_part_right_extend", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_word_part_right_extend(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_visible_policy(PyObject *self, PyObject *args) {
    int visible_policy, visible_slop;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_set_visible_policy", &PyGtk_Type, &sci, &visible_policy, &visible_slop))
        return NULL;
    gtk_scintilla_set_visible_policy(GTK_SCINTILLA(PyGtk_Get(sci)), visible_policy, visible_slop);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_del_line_left(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_del_line_left", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_del_line_left(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_del_line_right(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_del_line_right", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_del_line_right(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_x_offset(PyObject *self, PyObject *args) {
    int new_offset;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_x_offset", &PyGtk_Type, &sci, &new_offset))
        return NULL;
    gtk_scintilla_set_x_offset(GTK_SCINTILLA(PyGtk_Get(sci)), new_offset);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_x_offset(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_x_offset", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_x_offset(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_grab_focus(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_grab_focus", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_grab_focus(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_start_record(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_start_record", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_start_record(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_stop_record(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_stop_record", &PyGtk_Type, &sci))
        return NULL;
    gtk_scintilla_stop_record(GTK_SCINTILLA(PyGtk_Get(sci)));
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_lexer(PyObject *self, PyObject *args) {
    int lexer;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!i:gtk_scintilla_set_lexer", &PyGtk_Type, &sci, &lexer))
        return NULL;
    gtk_scintilla_set_lexer(GTK_SCINTILLA(PyGtk_Get(sci)), lexer);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_get_lexer(PyObject *self, PyObject *args) {
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!:gtk_scintilla_get_lexer", &PyGtk_Type, &sci))
        return NULL;
    return PyInt_FromLong(gtk_scintilla_get_lexer(GTK_SCINTILLA(PyGtk_Get(sci))));
}

static PyObject *_wrap_gtk_scintilla_colourise(PyObject *self, PyObject *args) {
    int start, end;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ii:gtk_scintilla_colourise", &PyGtk_Type, &sci, &start, &end))
        return NULL;
    gtk_scintilla_colourise(GTK_SCINTILLA(PyGtk_Get(sci)), start, end);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_property(PyObject *self, PyObject *args) {
    char *key, *value;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!ss:gtk_scintilla_set_property", &PyGtk_Type, &sci, &key, &value))
        return NULL;
    gtk_scintilla_set_property(GTK_SCINTILLA(PyGtk_Get(sci)), key, value);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_keywords(PyObject *self, PyObject *args) {
    int keyword_set;
    char *key_words;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!is:gtk_scintilla_set_keywords", &PyGtk_Type, &sci, &keyword_set, &key_words))
        return NULL;
    gtk_scintilla_set_keywords(GTK_SCINTILLA(PyGtk_Get(sci)), keyword_set, key_words);
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *_wrap_gtk_scintilla_set_lexer_language(PyObject *self, PyObject *args) {
    char *language;
    PyObject *sci;

    if (!PyArg_ParseTuple(args, "O!s:gtk_scintilla_set_lexer_language", &PyGtk_Type, &sci, &language))
        return NULL;
    gtk_scintilla_set_lexer_language(GTK_SCINTILLA(PyGtk_Get(sci)), language);
    Py_INCREF(Py_None);
    return Py_None;
}

