Browse Source

plugins: Drop support for old style python plugins

All the the old python plugins have already been removed. Remove a bunch of the
other related cruft since we want to port the plugin system to libpeas

Taken from 65371f53db (diff-2bbd410468516599f21e84fecb500348)
tags/1.4.0
JosephMcc 4 years ago
parent
commit
cab79801ca
22 changed files with 9 additions and 4502 deletions
  1. +0
    -1
      autogen.sh
  2. +2
    -122
      configure.ac
  3. +1
    -22
      data/xed-bugreport.sh.in
  4. +1
    -11
      docs/reference/Makefile.am
  5. +0
    -62
      m4/python.m4
  6. +0
    -4
      plugin-loaders/Makefile.am
  7. +0
    -36
      plugin-loaders/python/Makefile.am
  8. +0
    -115
      plugin-loaders/python/bindings/Makefile.am
  9. +0
    -1442
      plugin-loaders/python/bindings/xed.defs
  10. +0
    -461
      plugin-loaders/python/bindings/xed.override
  11. +0
    -45
      plugin-loaders/python/bindings/xedcommands.defs
  12. +0
    -122
      plugin-loaders/python/bindings/xedcommands.override
  13. +0
    -556
      plugin-loaders/python/bindings/xedmessage.override
  14. +0
    -193
      plugin-loaders/python/bindings/xedplugin.override
  15. +0
    -67
      plugin-loaders/python/bindings/xedutils.defs
  16. +0
    -85
      plugin-loaders/python/bindings/xedutils.override
  17. +0
    -719
      plugin-loaders/python/xed-plugin-loader-python.c
  18. +0
    -61
      plugin-loaders/python/xed-plugin-loader-python.h
  19. +0
    -281
      plugin-loaders/python/xed-plugin-python.c
  20. +0
    -88
      plugin-loaders/python/xed-plugin-python.h
  21. +0
    -3
      tools/plugin_template/xed-plugin.desktop.in
  22. +5
    -6
      xed/xed-plugin-info-priv.h

+ 0
- 1
autogen.sh View File

@@ -24,7 +24,6 @@ which yelp-build || {
}

REQUIRED_AUTOMAKE_VERSION=1.9
REQUIRED_MACROS=python.m4
GNOME_DATADIR="$gnome_datadir"
USE_COMMON_DOC_BUILD=yes



+ 2
- 122
configure.ac View File

@@ -178,123 +178,6 @@ dnl ================================================================

GLIB_GSETTINGS

dnl ================================================================
dnl Python
dnl ================================================================

AC_MSG_CHECKING([whether Python support is requested])
AC_ARG_ENABLE([python],
AS_HELP_STRING([--enable-python],[Enable python support]),
[enable_python=$enableval have_python=$enableval],
[enable_python=autodetect have_python=yes])
AC_MSG_RESULT([$enable_python])

if test "x$have_python" != "xno"; then
AM_PATH_PYTHON([2.5],[],[no])
if test "x$PYTHON" = "x:"; then
have_python=no
fi
fi

if test "x$have_python" != "xno"; then
AM_CHECK_PYTHON_HEADERS([],[have_python=no])
fi

if test "x$have_python" != "xno"; then
PY_EXEC_PREFIX=`$PYTHON -c 'import sys ; print sys.exec_prefix'`
PYTHON_LIBS="-lpython$PYTHON_VERSION"

PY_PREFIX=`$PYTHON -c 'import sys ; print sys.prefix'`
PYTHON_LIB_LOC="-L$libdir/python$PYTHON_VERSION/config"
PYTHON_CFLAGS="-I$PY_PREFIX/include/python$PYTHON_VERSION"
PYTHON_MAKEFILE="$libdir/python$PYTHON_VERSION/config/Makefile"
PYTHON_BASEMODLIBS=`sed -n -e 's/^BASEMODLIBS=\(.*\)/\1/p' $PYTHON_MAKEFILE`
PYTHON_OTHER_LIBS=`sed -n -e 's/^LIBS=\(.*\)/\1/p' $PYTHON_MAKEFILE`
PYTHON_EXTRA_LIBS="$PYTHON_BASEMODLIBS $PYTHON_OTHER_LIBS"

AC_SUBST([PYTHON_LIBS])
AC_SUBST([PYTHON_LIB_LOC])
AC_SUBST([PYTHON_CFLAGS])
AC_SUBST([PYTHON_EXTRA_LIBS])
fi

if test "x$have_python" != "xyes"; then
if test "x$enable_python" = "xyes"; then
AC_MSG_ERROR([Python not found])
elif test "x$enable_python" = "xautodetect"; then
enable_python=no
AC_MSG_WARN([Python not found, disabling python support])
fi
fi

if test "x$have_python" != "xno"; then
PYGOBJECT_REQUIRED=2.15.4
PYGTK_REQUIRED=2.12.0
PYGTKSOURCEVIEW_REQUIRED=2.9.2

PKG_CHECK_MODULES([PYGTK], [
pygobject-2.0 >= $PYGOBJECT_REQUIRED
pygtk-2.0 >= $PYGTK_REQUIRED
pygtksourceview-2.0 >= $PYGTKSOURCEVIEW_REQUIRED],
[],
[
have_python=no
if test "x$enable_python" = "xyes"; then
AC_MSG_ERROR([$PYGTK_PKG_ERRORS])
elif test "x$enable_python" = "xautodetect"; then
enable_python=no
AC_MSG_WARN([$PYGTK_PKG_ERRORS])
AC_MSG_WARN([Disabling python support])
fi
])
fi

if test "x$have_python" != "xno"; then
AC_MSG_CHECKING([for pygtk defs])
PYGTK_DEFSDIR=`$PKG_CONFIG --variable=defsdir pygtk-2.0`
AC_MSG_RESULT([$PYGTK_DEFSDIR])

AC_MSG_CHECKING([for pygobject defs])
PYGOBJECT_DEFSDIR=`$PKG_CONFIG --variable=defsdir pygobject-2.0`
AC_MSG_RESULT([$PYGOBJECT_DEFSDIR])

AC_MSG_CHECKING([for pygtk codegen])
PYGTK_CODEGEN="$PYTHON `$PKG_CONFIG --variable=codegendir pygtk-2.0`/codegen.py"
AC_MSG_RESULT([$PYGTK_CODEGEN])

AC_MSG_CHECKING([for pygtk h2def])
PYGTK_H2DEF="$PYTHON `$PKG_CONFIG --variable=codegendir pygtk-2.0`/h2def.py"
AC_MSG_RESULT([$PYGTK_H2DEF])

AC_SUBST([PYGTK_DEFSDIR])
AC_SUBST([PYGOBJECT_DEFSDIR])
AC_SUBST([PYGTK_CODEGEN])
AC_SUBST([PYGTK_H2DEF])

dnl Check for -fno-strict-aliasing
FLAGS="-fno-strict-aliasing"
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $FLAGS"
AC_MSG_CHECKING([whether [$]CC understands $FLAGS])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[compiler_has_option=yes],[compiler_has_option=no])
CFLAGS="$save_CFLAGS"
AC_MSG_RESULT($compiler_has_option)
if test $compiler_has_option = yes; then
NO_STRICT_ALIASING_CFLAGS="$FLAGS"
fi
AC_SUBST([NO_STRICT_ALIASING_CFLAGS])
fi

if test "x$have_python" != "xno" -a "x$enable_python" != "xno"; then
enable_python=yes
AC_DEFINE([ENABLE_PYTHON],[1],[Define to compile with python support])
fi

AM_CONDITIONAL([ENABLE_PYTHON],[test "x$enable_python" = "xyes"])

dnl This allows the bug-report script to know whether python has been enabled
AC_SUBST(enable_python)

dnl ================================================================
dnl Misc
dnl ================================================================
@@ -355,8 +238,6 @@ help/Makefile
pixmaps/Makefile
plugin-loaders/Makefile
plugin-loaders/c/Makefile
plugin-loaders/python/Makefile
plugin-loaders/python/bindings/Makefile
plugins/Makefile
plugins/changecase/Makefile
plugins/docinfo/Makefile
@@ -381,9 +262,8 @@ echo "
Configuration:

Source code location: ${srcdir}
Compiler: ${CC}
Python Plugins Support: $enable_python
Compiler: ${CC}
Spell Plugin enabled: $enable_enchant
Gvfs metadata enabled: $enable_gvfs_metadata
Tests enabled: $enable_tests
Tests enabled: $enable_tests
"

+ 1
- 22
data/xed-bugreport.sh.in View File

@@ -1,10 +1,7 @@
#!/bin/sh

ENABLE_PYTHON=@enable_python@

PKG_CONFIG_MODULES="glib-2.0 gtk+-2.0 gtksourceview-2.0 \
pygobject-2.0 pygtk-2.0 \
pygtksourceview-2.0 enchant iso-codes"
enchant iso-codes"

echo_padded ()
{
@@ -53,21 +50,3 @@ else
echo " pkg-config unavailable"
fi
echo

echo "Python module versions:"
if test "$ENABLE_PYTHON" = "yes"
then
echo_padded "python"
python -V 2>&1 | cut -c8-

echo_padded "pygtk"
python -c "import gtk, sys; \
sys.stdout.write('%d.%d.%d ' % gtk.pygtk_version); \
sys.stdout.write('(GTK+ %d.%d.%d)' % gtk.gtk_version)" \
2>/dev/null
echo
else
echo " Python support was not enabled at compile time."
fi
echo


+ 1
- 11
docs/reference/Makefile.am View File

@@ -20,7 +20,7 @@ DOC_SOURCE_DIR=../../xed
SCANGOBJ_OPTIONS=

# Extra options to supply to gtkdoc-scan.
# e.g. SCAN_OPTIONS=--deprecated-guards="GTK_DISABLE_DEPRECATED"
# e.g. SCAN_OPTIONS=--deprecated-guards="GTK_DISABLE_DEPRECATED"
SCAN_OPTIONS=

# Extra options to supply to gtkdoc-mkdb.
@@ -96,16 +96,6 @@ GTKDOC_LIBS= \
$(top_builddir)/xed/libxed.la \
$(XED_LIBS)

if ENABLE_PYTHON
GTKDOC_CFLAGS += \
$(NO_STRICT_ALIASING_CFLAGS) \
$(PYGTK_CFLAGS) \
$(PYTHON_CFLAGS) \
$(AM_CFLAGS)
GTKDOC_LIBS += \
$(top_builddir)/plugin-loaders/python/bindings/xed.la
endif

# This includes the standard gtk-doc make rules, copied by gtkdocize.
include $(top_srcdir)/gtk-doc.make



+ 0
- 62
m4/python.m4 View File

@@ -1,62 +0,0 @@
## this one is commonly used with AM_PATH_PYTHONDIR ...
dnl AM_CHECK_PYMOD(MODNAME [,SYMBOL [,ACTION-IF-FOUND [,ACTION-IF-NOT-FOUND]]])
dnl Check if a module containing a given symbol is visible to python.
AC_DEFUN([AM_CHECK_PYMOD],
[AC_REQUIRE([AM_PATH_PYTHON])
py_mod_var=`echo $1['_']$2 | sed 'y%./+-%__p_%'`
AC_MSG_CHECKING(for ifelse([$2],[],,[$2 in ])python module $1)
AC_CACHE_VAL(py_cv_mod_$py_mod_var, [
ifelse([$2],[], [prog="
import sys
try:
import $1
except ImportError:
sys.exit(1)
except:
sys.exit(0)
sys.exit(0)"], [prog="
import $1
$1.$2"])
if $PYTHON -c "$prog" 1>&AC_FD_CC 2>&AC_FD_CC
then
eval "py_cv_mod_$py_mod_var=yes"
else
eval "py_cv_mod_$py_mod_var=no"
fi
])
py_val=`eval "echo \`echo '$py_cv_mod_'$py_mod_var\`"`
if test "x$py_val" != xno; then
AC_MSG_RESULT(yes)
ifelse([$3], [],, [$3
])dnl
else
AC_MSG_RESULT(no)
ifelse([$4], [],, [$4
])dnl
fi
])

dnl a macro to check for ability to create python extensions
dnl AM_CHECK_PYTHON_HEADERS([ACTION-IF-POSSIBLE], [ACTION-IF-NOT-POSSIBLE])
dnl function also defines PYTHON_INCLUDES
AC_DEFUN([AM_CHECK_PYTHON_HEADERS],
[AC_REQUIRE([AM_PATH_PYTHON])
AC_MSG_CHECKING(for headers required to compile python extensions)
dnl deduce PYTHON_INCLUDES
py_prefix=`$PYTHON -c "import sys; print sys.prefix"`
py_exec_prefix=`$PYTHON -c "import sys; print sys.exec_prefix"`
PYTHON_INCLUDES="-I${py_prefix}/include/python${PYTHON_VERSION}"
if test "$py_prefix" != "$py_exec_prefix"; then
PYTHON_INCLUDES="$PYTHON_INCLUDES -I${py_exec_prefix}/include/python${PYTHON_VERSION}"
fi
AC_SUBST(PYTHON_INCLUDES)
dnl check if the headers exist:
save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS $PYTHON_INCLUDES"
AC_TRY_CPP([#include <Python.h>],dnl
[AC_MSG_RESULT(found)
$1],dnl
[AC_MSG_RESULT(not found)
$2])
CPPFLAGS="$save_CPPFLAGS"
])

+ 0
- 4
plugin-loaders/Makefile.am View File

@@ -1,7 +1,3 @@
SUBDIRS = c

if ENABLE_PYTHON
SUBDIRS += python
endif

-include $(top_srcdir)/git.mk

+ 0
- 36
plugin-loaders/python/Makefile.am View File

@@ -1,36 +0,0 @@
# C plugin loader

SUBDIRS = bindings
loaderdir = $(libdir)/xed/plugin-loaders

AM_CPPFLAGS = \
-I$(top_srcdir) \
-I$(top_builddir) \
-I$(top_srcdir)/xed \
-I$(top_builddir)/xed \
$(XED_CFLAGS) \
$(WARN_CFLAGS) \
$(DISABLE_DEPRECATED_CFLAGS) \
$(PYGTK_CFLAGS) \
$(PYTHON_CFLAGS) \
-DXED_PLUGINS_LIBS_DIR=\"$(XED_PLUGINS_LIBS_DIR)\" \
-DXED_LOCALEDIR=\""$(prefix)/$(DATADIRNAME)/locale"\"

loader_LTLIBRARIES = libpythonloader.la


NOINST_H_FILES = \
xed-plugin-loader-python.h \
xed-plugin-python.h

libpythonloader_la_SOURCES = \
xed-plugin-loader-python.c \
xed-plugin-python.c \
$(NOINST_H_FILES)

libpythonloader_la_LDFLAGS = $(LOADER_LIBTOOL_FLAGS)
libpythonloader_la_LIBADD = \
$(XED_LIBS) \
bindings/xed.la

-include $(top_srcdir)/git.mk

+ 0
- 115
plugin-loaders/python/bindings/Makefile.am View File

@@ -1,115 +0,0 @@
## Process this file with automake to produce Makefile.in

noinst_LTLIBRARIES = \
xed.la

nodist_xed_la_SOURCES = \
xed.c \
xedutils.c \
xedcommands.c

xed_la_LDFLAGS = \
-module -avoid-version

xed_la_LIBADD = \
$(PYTHON_LIB_LOC) \
$(PYTHON_LIBS) \
$(PYTHON_EXTRA_LIBS) \
$(PYGTK_LIBS)

xed_la_CFLAGS = \
-I$(top_srcdir) \
-I$(top_builddir) \
-I$(top_srcdir)/xed \
-I$(top_builddir)/xed \
-I$(top_srcdir)/plugin-loaders/python \
-I$(top_builddir)/plugin-loaders/python \
$(XED_CFLAGS) \
$(NO_STRICT_ALIASING_CFLAGS) \
$(PYGTK_CFLAGS) \
$(PYTHON_CFLAGS) \
$(AM_CFLAGS)

$(top_builddir)/xed/xed-enum-types.h:
cd $(top_builddir)/xed && $(MAKE) xed-enum-types.h

xed.c: xed.defs xed.override xedplugin.override xedmessage.override $(top_builddir)/xed/xed-enum-types.h
( cd $(srcdir) && $(PYGTK_CODEGEN) \
--register $(PYGTK_DEFSDIR)/pango-types.defs \
--register $(PYGTK_DEFSDIR)/gdk-types.defs \
--register $(PYGTK_DEFSDIR)/gtk-types.defs \
--register $(PYGTK_DEFSDIR)/gtksourceview2.defs \
--register $(PYGOBJECT_DEFSDIR)/gio-types.defs \
--override $*.override \
--prefix py$* $(<F) ) > $@

xedutils.c: xedutils.defs xedutils.override
( cd $(srcdir) && $(PYGTK_CODEGEN) \
--override $*.override \
--prefix py$* $(<F) ) > $@

xedcommands.c: xedcommands.defs xedcommands.override xed.defs
( cd $(srcdir) && $(PYGTK_CODEGEN) \
--register xed.defs \
--register $(PYGTK_DEFSDIR)/gtk-types.defs \
--override $*.override \
--prefix py$* $(<F) ) > $@

BINDING_XED_HEADERS_SRCDIR_IN = \
xed/xed-app.h \
xed/xed-document.h \
xed/xed-encodings.h \
xed/xed-plugin.h \
plugin-loaders/python/xed-plugin-python.h \
xed/xed-view.h \
xed/xed-statusbar.h \
xed/xed-tab.h \
xed/xed-panel.h \
xed/xed-window.h \
xed/xed-help.h \
xed/xed-debug.h \
xed/xed-message-type.h \
xed/xed-message.h \
xed/xed-message-bus.h \
xed/xed-language-manager.h

BINDING_UTILS_HEADERS_SRCDIR_IN = \
xed/xed-utils.h

BINDING_COMMANDS_HEADERS_SRCDIR_IN = \
xed/xed-commands.h

BINDING_HEADERS_BUILDDIR_IN =

BINDING_XED_HEADERS_SRCDIR := $(addprefix $(top_srcdir)/,$(BINDING_XED_HEADERS_SRCDIR_IN))
BINDING_UTILS_HEADERS_SRCDIR := $(addprefix $(top_srcdir)/,$(BINDING_UTILS_HEADERS_SRCDIR_IN))
BINDING_COMMANDS_HEADERS_SRCDIR := $(addprefix $(top_srcdir)/,$(BINDING_COMMANDS_HEADERS_SRCDIR_IN))

BINDING_HEADERS_BUILDDIR := $(addprefix $(top_builddir)/,$(BINDING_HEADERS_BUILDDIR_IN))

regenerate-python-binding:
$(PYGTK_H2DEF) $(sort $(BINDING_XED_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > xed.defs.new
$(PYGTK_H2DEF) $(sort $(BINDING_UTILS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > xedutils.defs.new
$(PYGTK_H2DEF) $(sort $(BINDING_COMMANDS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > xedcommands.defs.new

BUILT_SOURCES = \
xed.c \
xedutils.c \
xedcommands.c

EXTRA_DIST = \
xed.override \
xed.defs \
xedutils.override \
xedutils.defs \
xedcommands.override \
xedcommands.defs \
xedmessage.override \
xedplugin.override

CLEANFILES = $(BUILT_SOURCES)

dist-hook:
cd $(distdir); rm -f $(BUILT_SOURCES)

-include $(top_srcdir)/git.mk

+ 0
- 1442
plugin-loaders/python/bindings/xed.defs
File diff suppressed because it is too large
View File


+ 0
- 461
plugin-loaders/python/bindings/xed.override View File

@@ -1,461 +0,0 @@
%%
headers
#include <pygobject.h>
#include <pygtk/pygtk.h>

#include <xed/xed-language-manager.h>
#include <xed/xed-plugin.h>
#include <xed/xed-app.h>
#include <xed/xed-encodings.h>
#include <xed/xed-enum-types.h>
#include <xed/xed-statusbar.h>
#include <xed/xed-debug.h>
#include <xed/xed-help.h>

#include "xed-plugin-python.h"

void pyxed_register_classes (PyObject *d);
void pyxed_add_constants (PyObject *module, const gchar *strip_prefix);

static PyObject *
_helper_wrap_gobject_glist (const GList *list)
{
PyObject *py_list;
const GList *tmp;

if ((py_list = PyList_New(0)) == NULL) {
return NULL;
}
for (tmp = list; tmp != NULL; tmp = tmp->next) {
PyObject *py_obj = pygobject_new(G_OBJECT(tmp->data));

if (py_obj == NULL) {
Py_DECREF(py_list);
return NULL;
}
PyList_Append(py_list, py_obj);
Py_DECREF(py_obj);
}
return py_list;
}

static PyObject *
_helper_wrap_gobject_gslist (const GSList *list)
{
PyObject *py_list;
const GSList *tmp;

if ((py_list = PyList_New(0)) == NULL) {
return NULL;
}
for (tmp = list; tmp != NULL; tmp = tmp->next) {
PyObject *py_obj = pygobject_new(G_OBJECT(tmp->data));

if (py_obj == NULL) {
Py_DECREF(py_list);
return NULL;
}
PyList_Append(py_list, py_obj);
Py_DECREF(py_obj);
}
return py_list;
}
%%
include
xedplugin.override
xedmessage.override
%%
modulename xed
%%
import gtk.Widget as PyGtkWidget_Type
import gobject.GObject as PyGObject_Type
import gtk.gdk.Screen as PyGdkScreen_Type
import gtk.VBox as PyGtkVBox_Type
import gtk.Window as PyGtkWindow_Type
import gtk.Image as PyGtkImage_Type
import gtk.Statusbar as PyGtkStatusbar_Type
import gtksourceview2.Buffer as PyGtkSourceBuffer_Type
import gtksourceview2.View as PyGtkSourceView_Type
import gtksourceview2.Language as PyGtkSourceLanguage_Type
import gtksourceview2.LanguageManager as PyGtkSourceLanguageManager_Type
%%
ignore-glob
*_get_type
xed_document_error_quark
xed_panel_add_item_with_stock_icon
%%
override xed_app_create_window kwargs
static PyObject *
_wrap_xed_app_create_window(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "screen", NULL};
PyGObject *screen = NULL;
XedWindow *ret;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"|O!", kwlist,
&PyGdkScreen_Type, &screen))
return NULL;

ret = xed_app_create_window(XED_APP(self->obj),
screen ? GDK_SCREEN(screen->obj) : NULL);

/* pygobject_new handles NULL checking */
return pygobject_new((GObject *)ret);
}
%%
override xed_app_get_windows
static PyObject *
_wrap_xed_app_get_windows(PyGObject *self)
{
const GList *list;
PyObject *py_list;

list = xed_app_get_windows (XED_APP (self->obj));

py_list = _helper_wrap_gobject_glist (list);

return py_list;
}
%%
override xed_app_get_views
static PyObject *
_wrap_xed_app_get_views(PyGObject *self)
{
GList *list;
PyObject *py_list;

list = xed_app_get_views (XED_APP (self->obj));

py_list = _helper_wrap_gobject_glist (list);

g_list_free (list);

return py_list;
}
%%
override xed_app_get_documents
static PyObject *
_wrap_xed_app_get_documents(PyGObject *self)
{
GList *list;
PyObject *py_list;

list = xed_app_get_documents (XED_APP (self->obj));

py_list = _helper_wrap_gobject_glist (list);

g_list_free (list);

return py_list;
}
%%
override xed_window_get_documents
static PyObject *
_wrap_xed_window_get_documents(PyGObject *self)
{
GList *list;
PyObject *py_list;

list = xed_window_get_documents (XED_WINDOW (self->obj));

py_list = _helper_wrap_gobject_glist (list);

g_list_free(list);

return py_list;
}
%%
override xed_window_get_unsaved_documents
static PyObject *
_wrap_xed_window_get_unsaved_documents(PyGObject *self)
{
GList *list;
PyObject *py_list;

list = xed_window_get_unsaved_documents (XED_WINDOW (self->obj));

py_list = _helper_wrap_gobject_glist (list);

g_list_free(list);

return py_list;
}
%%
override xed_window_get_views
static PyObject *
_wrap_xed_window_get_views(PyGObject *self)
{
GList *list;
PyObject *py_list;

list = xed_window_get_views (XED_WINDOW (self->obj));

py_list = _helper_wrap_gobject_glist (list);

g_list_free(list);

return py_list;
}
%%
override xed_window_close_tabs kwargs
static PyObject *
_wrap_xed_window_close_tabs (PyGObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "tabs", NULL };
PyObject *list, *item;
GList *glist = NULL;
int len, i;

if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O:XedWindow.close_tabs", kwlist,
&list))
return NULL;

if (!PySequence_Check (list))
{
PyErr_SetString (PyExc_TypeError,
"first argument must be a sequence");
return NULL;
}

len = PySequence_Length (list);

for (i = 0; i < len; i++)
{
item = PySequence_GetItem (list, i);
Py_DECREF(item);

if (!pygobject_check (item, &PyXedTab_Type))
{
PyErr_SetString (PyExc_TypeError,
"sequence item not a Gtkwidget object");
g_list_free (glist);
return NULL;
}

glist = g_list_append (glist, pygobject_get (item));
}

xed_window_close_tabs (XED_WINDOW (self->obj), glist);

g_list_free (glist);
Py_INCREF (Py_None);
return Py_None;
}
%%
override xed_document_get_search_text
static PyObject *
_wrap_xed_document_get_search_text(PyGObject *self)
{
PyObject *tuple, *string;
guint flags;
gchar *ret;

ret = xed_document_get_search_text (XED_DOCUMENT (self->obj), &flags);

tuple = PyTuple_New(2);
if (ret) {
string = PyString_FromString(ret);
PyTuple_SetItem(tuple, 0, string);
} else {
Py_INCREF(Py_None);
PyTuple_SetItem(tuple, 0, Py_None);
}
PyTuple_SetItem(tuple, 1, PyInt_FromLong(flags));

g_free(ret);

return tuple;
}
%%
override xed_panel_add_item kwargs
static PyObject *
_wrap_xed_panel_add_item(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist1[] = { "item", "name", "image", NULL };
static char *kwlist2[] = { "item", "name", "stock_id", NULL };
PyGObject *item, *image;
char *name = NULL;
char *stock_id = NULL;

if (PyArg_ParseTupleAndKeywords(args, kwargs, "O!sO!:XedPanel.add_item", kwlist1, &PyGtkWidget_Type, &item, &name, &PyGtkImage_Type, &image)) {
xed_panel_add_item(XED_PANEL(self->obj), GTK_WIDGET(item->obj), name, GTK_WIDGET(image->obj));
Py_INCREF(Py_None);
return Py_None;
}

PyErr_Clear();

if (PyArg_ParseTupleAndKeywords(args, kwargs, "O!ss:XedPanel.add_item", kwlist2, &PyGtkWidget_Type, &item, &name, &stock_id)) {
xed_panel_add_item_with_stock_icon(XED_PANEL(self->obj), GTK_WIDGET(item->obj), name, stock_id);
Py_INCREF(Py_None);
return Py_None;
}

PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "the last arg should be either a gtk.Image or a stock_id string");
return NULL;
}
%%
override xed_app_get_default_deprecated
/* deprecated wrappers */
static PyObject *
_wrap_xed_app_get_default_deprecated(PyObject *self)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.app_get_default instead") < 0)
return NULL;
return _wrap_xed_app_get_default(self);
}
%%
override xed_encoding_get_from_charset_deprecated kwargs
static PyObject *
_wrap_xed_encoding_get_from_charset_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.encoding_get_from_charset instead") < 0)
return NULL;
return _wrap_xed_encoding_get_from_charset(self, args, kwargs);
}
%%
override xed_encoding_get_from_index_deprecated kwargs
static PyObject *
_wrap_xed_encoding_get_from_index_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.encoding_get_from_index instead") < 0)
return NULL;
return _wrap_xed_encoding_get_from_index(self, args, kwargs);
}
%%
override xed_encoding_get_utf8_deprecated
static PyObject *
_wrap_xed_encoding_get_utf8_deprecated(PyObject *self)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.encoding_get_utf8 instead") < 0)
return NULL;
return _wrap_xed_encoding_get_utf8(self);
}
%%
override xed_encoding_get_current_deprecated
static PyObject *
_wrap_xed_encoding_get_current_deprecated(PyObject *self)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.encoding_get_current instead") < 0)
return NULL;
return _wrap_xed_encoding_get_current(self);
}
%%
override xed_tab_get_from_document_deprecated kwargs
static PyObject *
_wrap_xed_tab_get_from_document_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
{
if (PyErr_Warn(PyExc_DeprecationWarning, "use xed.tab_get_from_document instead") < 0)
return NULL;
return _wrap_xed_tab_get_from_document(self, args, kwargs);
}
%%
override xed_language_manager_list_languages_sorted kwargs
static PyObject *
_wrap_xed_language_manager_list_languages_sorted(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "lm", "include_hidden", NULL };
PyGObject *lm;
int include_hidden;
PyObject *py_list;
GSList *list;

if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O!i:language_manager_list_languages_sorted",
kwlist, &PyGtkSourceLanguageManager_Type, &lm,
&include_hidden))
return NULL;

list = xed_language_manager_list_languages_sorted (GTK_SOURCE_LANGUAGE_MANAGER (lm->obj),
include_hidden);

py_list = _helper_wrap_gobject_gslist (list);

g_slist_free (list);

return py_list;
}
%%
override xed_debug kwargs
static PyObject *
_wrap_xed_debug(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "message", NULL };
PyObject *traceback_module, *mdict, *func, *traceback, *tuple;
PyObject *filename, *lineno, *funcname;
char *message = NULL;

if (g_getenv ("XED_DEBUG_PLUGINS") == NULL)
{
Py_INCREF (Py_None);
return Py_None;
}

if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|s", kwlist, &message))
return NULL;

traceback_module = PyImport_ImportModule ("traceback");
if (traceback_module == NULL)
{
g_warning ("traceback module cannot be imported");
Py_INCREF (Py_None);
return Py_None;
}

mdict = PyModule_GetDict (traceback_module);
func = PyDict_GetItemString (mdict, "extract_stack");
traceback = PyObject_CallFunction (func, "zi", NULL, 1);
tuple = PyList_GetItem (traceback, 0);

if (tuple == NULL || !PyTuple_Check (tuple))
{
g_warning ("traceback tuple is null!");
}
else
{
filename = PyTuple_GetItem (tuple, 0);
lineno = PyTuple_GetItem (tuple, 1);
funcname = PyTuple_GetItem (tuple, 2);

if (message == NULL)
xed_debug (XED_DEBUG_PLUGINS,
PyString_AsString (filename),
PyInt_AsLong (lineno),
PyString_AsString (funcname));
else
xed_debug_message (XED_DEBUG_PLUGINS,
PyString_AsString (filename),
PyInt_AsLong (lineno),
PyString_AsString (funcname),
"%s",
message);
}
Py_DECREF (traceback);
Py_DECREF (traceback_module);

Py_INCREF (Py_None);
return Py_None;
}
%%
override xed_statusbar_flash_message kwargs
static PyObject *
_wrap_xed_statusbar_flash_message(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "context_id", "message", NULL };
int context_id;
char *message;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,"is:XedStatusbar.flash_message", kwlist, &context_id, &message))
return NULL;
xed_statusbar_flash_message(XED_STATUSBAR(self->obj), context_id, "%s", message);

Py_INCREF(Py_None);
return Py_None;
}
%%

+ 0
- 45
plugin-loaders/python/bindings/xedcommands.defs View File

@@ -1,45 +0,0 @@
;; -*- scheme -*-
; object definitions ...
;; Enumerations and flags ...


;; From ../../xed/xed-commands.h

(define-function load_uri
(c-name "xed_commands_load_uri")
(return-type "none")
(parameters
'("XedWindow*" "window")
'("const-gchar*" "uri")
'("const-XedEncoding*" "encoding")
'("gint" "line_pos")
)
)

(define-function load_uris
(c-name "xed_commands_load_uris")
(return-type "gint")
(parameters
'("XedWindow*" "window")
'("const-GSList*" "uris")
'("const-XedEncoding*" "encoding")
'("gint" "line_pos")
)
)

(define-function save_document
(c-name "xed_commands_save_document")
(return-type "none")
(parameters
'("XedWindow*" "window")
'("XedDocument*" "document")
)
)

(define-function save_all_documents
(c-name "xed_commands_save_all_documents")
(return-type "none")
(parameters
'("XedWindow*" "window")
)
)

+ 0
- 122
plugin-loaders/python/bindings/xedcommands.override View File

@@ -1,122 +0,0 @@
%%
headers
#define NO_IMPORT_PYGOBJECT
#define NO_IMPORT_PYGTK
#include <pygobject.h>
#include <pygtk/pygtk.h>

#include "xed-commands.h"
#include "xed-window.h"

void pyxedcommands_register_classes (PyObject *d);
void pyxedcommands_add_constants (PyObject *module, const gchar *strip_prefix);

%%
modulename xed.commands
%%
import xed.Window as PyXedWindow_Type
import xed.Document as PyXedDocument_Type
%%
ignore-glob
_*
%%
override xed_commands_load_uri kwargs
static PyObject *
_wrap_xed_commands_load_uri (PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "window", "uri", "encoding", "line_pos", NULL };
PyGObject *window;
char *uri;
int line_pos = 0;
PyObject *py_encoding = NULL;
XedEncoding *encoding = NULL;

if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!s|Oi:load_uri",
kwlist, &PyXedWindow_Type,
&window, &uri, &py_encoding,
&line_pos))
return NULL;
if (py_encoding != NULL && py_encoding != Py_None)
{
if (pyg_boxed_check (py_encoding, XED_TYPE_ENCODING))
encoding = pyg_boxed_get (py_encoding, XedEncoding);
else
{
PyErr_SetString (PyExc_TypeError,
"encoding should be a XedEncoding");
return NULL;
}
}

xed_commands_load_uri (XED_WINDOW (window->obj), uri, encoding,
line_pos);
Py_INCREF (Py_None);
return Py_None;
}
%%
override xed_commands_load_uris kwargs
static PyObject *
_wrap_xed_commands_load_uris (PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "window", "uris", "encoding", "line_pos", NULL };
PyGObject *window;
GSList *uris = NULL;
int line_pos = 0;
PyObject *py_encoding = NULL;
PyObject *list;
PyObject *item;
XedEncoding *encoding = NULL;
int len;
int i;

if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!O|Oi:load_uri",
kwlist, &PyXedWindow_Type,
&window, &list, &py_encoding,
&line_pos))
return NULL;
if (py_encoding != NULL && py_encoding != Py_None)
{
if (pyg_boxed_check (py_encoding, XED_TYPE_ENCODING))
encoding = pyg_boxed_get (py_encoding, XedEncoding);
else {
PyErr_SetString (PyExc_TypeError,
"encoding should be a XedEncoding");
return NULL;
}
}

if (!PySequence_Check (list))
{
PyErr_SetString (PyExc_TypeError,
"second argument must be a sequence");
return NULL;
}

len = PySequence_Length (list);

for (i = 0; i < len; i++)
{
item = PySequence_GetItem (list, i);
Py_DECREF (item);

if (!PyString_Check (item))
{
PyErr_SetString (PyExc_TypeError,
"sequence item not a string");
g_slist_free (uris);
return NULL;
}

uris = g_slist_prepend (uris, PyString_AsString (item));
}

uris = g_slist_reverse (uris);
xed_commands_load_uris (XED_WINDOW (window->obj), uris,
encoding, line_pos);
g_slist_free (uris);

Py_INCREF (Py_None);
return Py_None;
}

+ 0
- 556
plugin-loaders/python/bindings/xedmessage.override View File

@@ -1,556 +0,0 @@
%%
headers

#include <xed/xed-message-bus.h>
#include <xed/xed-message.h>

static GType
_helper_wrap_get_gtype_from_pytype (PyObject *pytype)
{
PyTypeObject *type = (PyTypeObject *)pytype;
if (type == &PyList_Type || type == &PyTuple_Type)
return G_TYPE_STRV;

return pyg_type_from_object (pytype);
}

static gchar *
_helper_wrap_get_string (PyObject *obj)
{
PyObject *str;
gchar *result;
str = PyObject_Str (obj);
if (!str)
return NULL;
result = g_strdup (PyString_AsString (str));
Py_DECREF (str);
return result;
}

static int
_helper_wrap_list_to_gvalue (GValue *gvalue, PyObject *pyvalue)
{
int num;
gchar **lst;
gint i;
num = PySequence_Size (pyvalue);
lst = g_new0 (gchar *, num + 1);
for (i = 0; i < num; i++)
{
lst[i] = _helper_wrap_get_string (PySequence_GetItem (pyvalue, i));
if (lst[i] == NULL)
{
g_strfreev (lst);
return 1;
}
}
g_value_set_boxed (gvalue, lst);
g_strfreev (lst);
return 0;
}

static int
_helper_wrap_get_gvalue_from_pyobject (GValue *gvalue, PyObject *pyvalue)
{
if (pyvalue->ob_type == &PyList_Type || pyvalue->ob_type == &PyTuple_Type)
return _helper_wrap_list_to_gvalue (gvalue, pyvalue);

return pyg_value_from_pyobject(gvalue, pyvalue);
}

static int
_helper_wrap_message_set_value(XedMessage *message, PyObject *pykey, PyObject *pyvalue)
{
gchar *key;
GType gtype;
GValue value = {0,};

key = _helper_wrap_get_string(pykey);
if (key == NULL)
return 0;

gtype = xed_message_get_key_type(message, key);
if (gtype == 0) {
PyErr_SetString(PyExc_TypeError, "invalid key");
g_free (key);
return 0;
}

g_value_init(&value, gtype);
if (_helper_wrap_get_gvalue_from_pyobject (&value, pyvalue)) {
PyErr_SetString(PyExc_TypeError,
"value is of the wrong type for this key");
g_free (key);
return 0;
}

xed_message_set_value(message, key, &value);
g_value_unset(&value);
g_free (key);
return 1;
}

typedef void (*ParsePairFunc)(PyObject *key, PyObject *value, gpointer user_data);

static void
_helper_parse_pairs_dict (PyObject *dict, ParsePairFunc func, gpointer user_data)
{
if (!dict)
return;
PyObject *key, *value;
Py_ssize_t i = 0;
while (PyDict_Next(dict, &i, &key, &value))
{
func(key, value, user_data);
}
}

static void
_helper_parse_pairs(PyObject *args, PyObject *kwargs, ParsePairFunc func, gpointer user_data)
{
guint len;
guint i;
len = PyTuple_Size(args);
for (i = 0; i < len; ++i)
{
PyObject *d = PyTuple_GetItem(args, i);
if (PyDict_Check(d))
_helper_parse_pairs_dict(d, func, user_data);
}
_helper_parse_pairs_dict(kwargs, func, user_data);
}

static void
_helper_message_set(PyObject *key, PyObject *value, XedMessage *message)
{
_helper_wrap_message_set_value(message, key, value);
}

static void
_helper_message_set_values(XedMessage *message, PyObject *args, PyObject *kwargs)
{
_helper_parse_pairs(args, kwargs, (ParsePairFunc)_helper_message_set, message);
}

static XedMessage *
_helper_wrap_create_message(XedMessageBus *bus, PyObject *args, PyObject *kwargs)
{
PyObject *pypath, *pymethod, *pydict;
if (!PyArg_ParseTuple(args, "OO|O:XedMessage.create", &pypath, &pymethod, &pydict))
return NULL;
gchar *object_path = _helper_wrap_get_string(pypath);
gchar *method = _helper_wrap_get_string(pymethod);
XedMessageType *message_type = xed_message_bus_lookup (bus, object_path, method);
XedMessage *message;
if (message_type)
{
message = xed_message_type_instantiate(message_type, NULL);
_helper_message_set_values(message, args, kwargs);
}
else
{
PyErr_SetString(PyExc_StandardError, "Message type does not exist");
message = NULL;
}
g_free(object_path);
g_free(method);
return message;
}

typedef struct {
PyObject *func;
PyObject *data;
} PyXedCustomNotify;

static void
pyxed_custom_destroy_notify(gpointer user_data)
{
PyXedCustomNotify *cunote = user_data;
PyGILState_STATE state;
g_return_if_fail(user_data);
state = pyg_gil_state_ensure();
Py_XDECREF(cunote->func);
Py_XDECREF(cunote->data);
pyg_gil_state_release(state);
g_free(cunote);
}
%%
ignore-glob
*_get_type
xed_message_type_foreach
xed_message_type_instantiate_valist
xed_message_type_new_valist
xed_message_get_valist
xed_message_set_valist
xed_message_set_valuesv
xed_message_bus_disconnect_by_func
xed_message_bus_block_by_func
xed_message_bus_unblock_by_func
%%
override xed_message_type_new kwargs

typedef struct
{
XedMessageType *message_type;
PyObject *optional;
} MessageTypeSetInfo;

static void
_message_type_set(PyObject *key, PyObject *value, MessageTypeSetInfo *info)
{
GType gtype;
gchar *k = _helper_wrap_get_string(key);

if (!k)
return;

gtype = _helper_wrap_get_gtype_from_pytype(value);
gboolean optional = info->optional && PySequence_Contains(info->optional, key);
xed_message_type_set(info->message_type, optional, k, gtype, NULL);
g_free(k);
}

static int
_wrap_xed_message_type_new(PyGObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *pypath, *pymethod, *optional = NULL, *pydict;
if (!PyArg_ParseTuple(args, "OO|OO:XedMessageType.new", &pypath, &pymethod, &optional, &pydict))
return -1;
XedMessageType *message_type = XED_MESSAGE_TYPE(g_object_new(pyg_type_from_object((PyObject *) self), NULL));
MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL};
_helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info);
self->obj = (GObject *)message_type;
pygobject_register_wrapper((PyObject *) self);
return 0;
}
%%
override xed_message_type_instantiate kwargs
static PyObject *
_wrap_xed_message_type_instantiate(PyGObject *self, PyObject *args, PyObject *kwargs)
{
XedMessageType *message_type = XED_MESSAGE_TYPE (self->obj);
XedMessage *message = xed_message_type_instantiate(message_type, NULL);
_helper_message_set_values(message, args, kwargs);
return pygobject_new((GObject *)message);
}
%%
override xed_message_get args
static PyObject *
_wrap_xed_message_get(PyGObject *self, PyObject *args)
{
guint len, i;
PyObject *ret;

len = PyTuple_Size(args);
ret = PyTuple_New(len);
for (i = 0; i < len; i++) {
GValue value = { 0, };
PyObject *py_key = PyTuple_GetItem(args, i);
gchar *key = _helper_wrap_get_string(py_key);
if (!key) {
PyErr_SetString(PyExc_TypeError, "keys must be strings");
Py_DECREF(ret);
return NULL;
}
xed_message_get_value (XED_MESSAGE (self->obj), key, &value);
g_free (key);

PyTuple_SetItem(ret, i, pyg_value_as_pyobject(&value, TRUE));
g_value_unset(&value);
}
return ret;
}
%%
override xed_message_get_value kwargs
static PyObject *
_wrap_xed_message_get_value(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "key", NULL };
const gchar *key;
PyObject *ret;
GValue value = { 0, };
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:XedMessage.get_value", kwlist, &key))
return NULL;

xed_message_get_value(XED_MESSAGE(self->obj), key, &value);
ret = pyg_value_as_pyobject(&value, TRUE);
g_value_unset(&value);
return ret;
}
%%
override xed_message_set_value kwargs
static PyObject *
_wrap_xed_message_set_value(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "key", "value", NULL };
PyObject *pykey, *pyvalue;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:XedMessage.set_value", kwlist, &pykey, &pyvalue))
return NULL;
if (!_helper_wrap_message_set_value(XED_MESSAGE(self->obj), pykey, pyvalue))
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
%%
override xed_message_set kwargs
static PyObject *
_wrap_xed_message_set (PyGObject *self, PyObject *args, PyObject *kwargs) {
_helper_message_set_values(XED_MESSAGE(self->obj), args, kwargs);

Py_INCREF(Py_None);
return Py_None;
}
%%
override xed_message_bus_new
static int
_wrap_xed_message_bus_new(PyGObject *self)
{
pygobject_construct (self, NULL);
if (!self->obj) {
PyErr_SetString (PyExc_RuntimeError, "could not create xed.MessageBus object");
return -1;
}

return 0;
}
%%
new-constructor XED_TYPE_MESSAGE_BUS
%%
override xed_message_bus_register kwargs
static PyObject *
_wrap_xed_message_bus_register(PyGObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *pypath, *pymethod, *optional = NULL, *pydict;
XedMessageBus *bus = XED_MESSAGE_BUS(self->obj);

if (!PyArg_ParseTuple(args, "OO|OO:XedMessageBus.register", &pypath, &pymethod, &optional, &pydict))
return NULL;
gchar *object_path = _helper_wrap_get_string(pypath);
gchar *method = _helper_wrap_get_string(pymethod);
XedMessageType *message_type = xed_message_bus_register(bus, object_path, method, 0, NULL);
g_free(object_path);
g_free(method);
if (!message_type)
{
PyErr_SetString(PyExc_StandardError, "Message type already exists");
return NULL;
}
MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL};
_helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info);
return pyg_boxed_new(XED_TYPE_MESSAGE_TYPE, message_type, TRUE, TRUE);
}
%%
override xed_message_bus_connect kwargs
static void
pyxed_message_bus_connect_cb(XedMessageBus *bus, XedMessage *message, gpointer data)
{
PyGILState_STATE state;
PyXedCustomNotify *cunote = data;
PyObject *pybus, *pymessage, *retobj;

g_assert(cunote->func);

state = pyg_gil_state_ensure();

pybus = pygobject_new((GObject *)bus);
pymessage = pygobject_new((GObject *)message);

if (cunote->data) {
retobj = PyEval_CallFunction(cunote->func, "(NNO)", pybus, pymessage, cunote->data);
} else {
retobj = PyEval_CallFunction(cunote->func, "(NN)", pybus, pymessage);
}

if (PyErr_Occurred()) {
PyErr_Print();
}

Py_XDECREF(retobj);

pyg_gil_state_release(state);
}

static PyObject *
_wrap_xed_message_bus_connect(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "domain", "name", "func", "data", NULL };
PyObject *pyfunc, *pyarg = NULL;
const gchar *domain;
const gchar *name;
PyXedCustomNotify *cunote;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"ssO|O:XedMessageBus.connect",
kwlist, &domain, &name, &pyfunc, &pyarg))
return NULL;

if (!PyCallable_Check(pyfunc)) {
PyErr_SetString(PyExc_TypeError, "func must be a callable object");
return NULL;
}
cunote = g_new(PyXedCustomNotify, 1);
Py_INCREF(pyfunc);
cunote->func = pyfunc;
Py_XINCREF(pyarg);
cunote->data = pyarg;

guint id = xed_message_bus_connect(XED_MESSAGE_BUS(self->obj),
domain,
name,
pyxed_message_bus_connect_cb,
(gpointer)cunote,
pyxed_custom_destroy_notify);
return PyLong_FromUnsignedLong(id);
}
%%
override xed_message_bus_send kwargs
static PyObject *
_wrap_xed_message_bus_send(PyGObject *self, PyObject *args, PyObject *kwargs)
{
/* create a new message object */
XedMessage *message;
XedMessageBus *bus = XED_MESSAGE_BUS(self->obj);
message = _helper_wrap_create_message(bus, args, kwargs);
if (!message)
return NULL;
xed_message_bus_send_message(bus, message);
g_object_unref (message);
Py_INCREF(Py_None);
return Py_None;
}
%%
override xed_message_bus_send_sync kwargs
static PyObject *
_wrap_xed_message_bus_send_sync(PyGObject *self, PyObject *args, PyObject *kwargs)
{
/* create a new message object */
XedMessage *message;
XedMessageBus *bus = XED_MESSAGE_BUS(self->obj);
message = _helper_wrap_create_message(bus, args, kwargs);
if (!message)
return NULL;
xed_message_bus_send_message_sync(bus, message);
return pygobject_new((GObject *)message);
}
%%
override-slot XedMessage.tp_getattro
static PyObject *
_wrap_xed_message_tp_getattro(PyObject *self, PyObject *attrname)
{
XedMessage *message = XED_MESSAGE(((PyGObject *)self)->obj);
XedMessageType *type;

gchar *name = _helper_wrap_get_string (attrname);
gboolean exists;
gboolean intype;
PyObject *ret;
if (name == NULL)
{
PyErr_SetString(PyExc_TypeError, "attr name somehow not a string");
return NULL;
}
g_object_get (message, "type", &type, NULL);
intype = xed_message_type_lookup (type, name) != G_TYPE_INVALID;
xed_message_type_unref (type);
exists = xed_message_has_key (message, name);
if (!intype)
{
ret = PyObject_GenericGetAttr(self, attrname);
}
else if (exists)
{
GValue value = { 0, };
xed_message_get_value (message, name, &value);
ret = pyg_value_as_pyobject(&value, TRUE);
g_value_unset (&value);
}
else
{
Py_INCREF(Py_None);
ret = Py_None;
}

g_free (name);
return ret;
}
%%
override-slot XedMessage.tp_setattro
static int
_wrap_xed_message_tp_setattro(PyObject *self, PyObject *attrname, PyObject *value)
{
XedMessage *message = XED_MESSAGE(((PyGObject *)self)->obj);

if (!_helper_wrap_message_set_value(message, attrname, value))
{
return PyObject_GenericSetAttr(self, attrname, value);
}
else
{
return 1;
}
}

+ 0
- 193
plugin-loaders/python/bindings/xedplugin.override View File

@@ -1,193 +0,0 @@
%%
headers
#include <xed/xed-plugin.h>
#include <xed/xed-window.h>
%%
override xed_plugin_activate kwargs
static PyObject *
_wrap_xed_plugin_activate(PyGObject *self, PyObject *args, PyObject *kwargs)
{
gpointer klass, klass2;
static char *kwlist[] = { "window", NULL };
PyGObject *window;
PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
if (!PyArg_ParseTupleAndKeywords (args,
kwargs,
"O!:XedPlugin.activate",
kwlist,
&PyXedWindow_Type,
&window))
return NULL;

klass = g_type_class_ref (pyg_type_from_object (cls));
if (XED_IS_PLUGIN_PYTHON_CLASS (klass))
{
klass2 = g_type_class_peek_parent (klass);
g_type_class_unref (klass);
klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
}

if (XED_PLUGIN_CLASS (klass)->activate)
XED_PLUGIN_CLASS (klass)->activate (XED_PLUGIN (self->obj),
XED_WINDOW (window->obj));
else {
PyErr_SetString (PyExc_NotImplementedError,
"virtual method XedPlugin.activate not implemented");
g_type_class_unref (klass);
return NULL;
}

g_type_class_unref (klass);
Py_INCREF(Py_None);
return Py_None;
}

%%
override xed_plugin_deactivate kwargs
static PyObject *
_wrap_xed_plugin_deactivate(PyGObject *self, PyObject *args, PyObject *kwargs)
{
gpointer klass, klass2;
static char *kwlist[] = {"window", NULL};
PyGObject *window;
PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);

if (!PyArg_ParseTupleAndKeywords (args,
kwargs,
"O!:XedPlugin.deactivate",
kwlist,
&PyXedWindow_Type,
&window))
return NULL;

klass = g_type_class_ref (pyg_type_from_object (cls));

if (XED_IS_PLUGIN_PYTHON_CLASS (klass))
{
klass2 = g_type_class_peek_parent (klass);
g_type_class_unref (klass);
klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
}
if (XED_PLUGIN_CLASS (klass)->deactivate)
XED_PLUGIN_CLASS (klass)->deactivate (XED_PLUGIN (self->obj),
XED_WINDOW (window->obj));
else {
PyErr_SetString (PyExc_NotImplementedError,
"virtual method XedPlugin.deactivate not implemented");
g_type_class_unref (klass);
return NULL;
}

g_type_class_unref (klass);
Py_INCREF(Py_None);
return Py_None;
}

%%
override xed_plugin_update_ui kwargs
static PyObject *
_wrap_xed_plugin_update_ui (PyGObject *self, PyObject *args, PyObject *kwargs)
{
gpointer klass, klass2;
static char *kwlist[] = {"window", NULL};
PyGObject *window;
PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);

if (!PyArg_ParseTupleAndKeywords (args,
kwargs,
"O!:XedPlugin.update_ui",
kwlist,
&PyXedWindow_Type,
&window))
return NULL;

klass = g_type_class_ref (pyg_type_from_object (cls));

if (XED_IS_PLUGIN_PYTHON_CLASS (klass))
{
klass2 = g_type_class_peek_parent (klass);
g_type_class_unref (klass);
klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
}
if (XED_PLUGIN_CLASS (klass)->update_ui)
XED_PLUGIN_CLASS (klass)->update_ui (XED_PLUGIN (self->obj),
XED_WINDOW (window->obj));
else {
PyErr_SetString (PyExc_NotImplementedError,
"virtual method XedPlugin.update_ui not implemented");
g_type_class_unref (klass);
return NULL;
}

g_type_class_unref (klass);
Py_INCREF(Py_None);
return Py_None;
}

%%
override xed_plugin_is_configurable
static PyObject *
_wrap_xed_plugin_is_configurable (PyGObject *self)
{
int ret;
gpointer klass, klass2;
PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);

klass = g_type_class_ref (pyg_type_from_object (cls));

if (XED_IS_PLUGIN_PYTHON_CLASS (klass))
{
klass2 = g_type_class_peek_parent (klass);
g_type_class_unref (klass);
klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
}
if (XED_PLUGIN_CLASS (klass)->is_configurable)
ret = XED_PLUGIN_CLASS (klass)->is_configurable (XED_PLUGIN (self->obj));
else {
PyErr_SetString (PyExc_NotImplementedError,
"virtual method XedPlugin.is_configurable not implemented");
g_type_class_unref (klass);
return NULL;
}

g_type_class_unref (klass);
return PyBool_FromLong (ret);
}

%%
override xed_plugin_configure_dialog
static PyObject *
_wrap_xed_plugin_create_configure_dialog (PyGObject *self)
{
GtkWidget *ret;
gpointer klass, klass2;
PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);

klass = g_type_class_ref(pyg_type_from_object (cls));

if (XED_IS_PLUGIN_PYTHON_CLASS (klass))
{
klass2 = g_type_class_peek_parent (klass);
g_type_class_unref (klass);
klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
}
if (XED_PLUGIN_CLASS (klass)->create_configure_dialog)
ret = XED_PLUGIN_CLASS (klass)->create_configure_dialog (XED_PLUGIN (self->obj));
else {
PyErr_SetString (PyExc_NotImplementedError,
"virtual method XedPlugin.create_configure_dialog not implemented");
g_type_class_unref (klass);
return NULL;
}

g_type_class_unref (klass);

/* pygobject_new handles NULL checking */
return pygobject_new ((GObject *)ret);
}

+ 0
- 67
plugin-loaders/python/bindings/xedutils.defs View File

@@ -1,67 +0,0 @@
;; -*- scheme -*-

;; From ../../xed/xed-utils.h

(define-function uri_has_writable_scheme
(c-name "xed_utils_uri_has_writable_scheme")
(return-type "gboolean")
(parameters
'("const-gchar*" "uri")
)
)

(define-function uri_has_file_scheme
(c-name "xed_utils_uri_has_file_scheme")
(return-type "gboolean")
(parameters
'("const-gchar*" "uri")
)
)

(define-function uri_exists
(c-name "xed_utils_uri_exists")
(return-type "gboolean")
(parameters
'("const-gchar*" "text_uri")
)
)

(define-function uri_is_valid
(c-name "xed_utils_is_valid_uri")
(return-type "gboolean")
(parameters
'("const-gchar*" "uri")
)
)

(define-function uri_get_dirname
(c-name "xed_utils_uri_get_dirname")
(return-type "gchar*")
(parameters
'("const-char*" "uri")
)
)

(define-function menu_position_under_widget
(c-name "xed_utils_menu_position_under_widget")
(return-type "none")
(parameters
'("GtkMenu*" "menu")
'("gint*" "x")
'("gint*" "y")
'("gboolean*" "push_in")
'("gpointer" "user_data")
)
)

(define-function menu_position_under_tree_view
(c-name "xed_utils_menu_position_under_tree_view")
(return-type "none")
(parameters
'("GtkMenu*" "menu")
'("gint*" "x")
'("gint*" "y")
'("gboolean*" "push_in")
'("gpointer" "user_data")
)
)

+ 0
- 85
plugin-loaders/python/bindings/xedutils.override View File

@@ -1,85 +0,0 @@
%%
headers
#define NO_IMPORT_PYGOBJECT
#define NO_IMPORT_PYGTK
#include <pygobject.h>
#include <pygtk/pygtk.h>

#include "xed-utils.h"

void pyxedutils_register_classes (PyObject *d);
void pyxedutils_add_constants (PyObject *module, const gchar *strip_prefix);

%%
modulename xed.utils
%%
import gtk.Widget as PyGtkWidget_Type
import gtk.TreeView as PyGtkTreeView_Type
import gtk.Menu as PyGtkMenu_Type
%%
ignore-glob
_*
%%
override xed_utils_menu_position_under_widget kwargs
static PyObject *
_wrap_xed_utils_menu_position_under_widget (PyObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "menu", "widget", NULL };
PyObject *py_menu, *py_widget;
GtkMenu *menu;
GtkWidget *widget;
gint x, y;
gboolean push_in;
PyObject *tuple;
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O!O!", kwlist,
&PyGtkMenu_Type, &py_menu,
&PyGtkWidget_Type, &py_widget))
return NULL;
menu = GTK_MENU (pygobject_get (py_menu));
widget = GTK_WIDGET (pygobject_get (py_widget));

xed_utils_menu_position_under_widget (menu, &x, &y, &push_in, widget);

tuple = PyTuple_New (3);
PyTuple_SetItem (tuple, 0, PyInt_FromLong (x));
PyTuple_SetItem (tuple, 1, PyInt_FromLong (y));
PyTuple_SetItem (tuple, 2, PyBool_FromLong (push_in));
return tuple;
}
%%
override xed_utils_menu_position_under_tree_view kwargs
static PyObject *
_wrap_xed_utils_menu_position_under_tree_view (PyObject *self,
PyObject *args,
PyObject *kwargs)
{
static char *kwlist[] = { "menu", "tree_view", NULL };
PyObject *py_menu, *py_view;
GtkMenu *menu;
GtkTreeView *view;
gint x, y;
gboolean push_in;
PyObject *tuple;
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O!O!", kwlist,
&PyGtkMenu_Type, &py_menu,
&PyGtkTreeView_Type, &py_view))
return NULL;
menu = GTK_MENU (pygobject_get (py_menu));
view = GTK_TREE_VIEW (pygobject_get (py_view));

xed_utils_menu_position_under_widget (menu, &x, &y, &push_in, view);

tuple = PyTuple_New (3);
PyTuple_SetItem (tuple, 0, PyInt_FromLong (x));
PyTuple_SetItem (tuple, 1, PyInt_FromLong (y));
PyTuple_SetItem (tuple, 2, PyBool_FromLong (push_in));
return tuple;
}

+ 0
- 719
plugin-loaders/python/xed-plugin-loader-python.c View File

@@ -1,719 +0,0 @@
/*
* xed-plugin-loader-python.c
* This file is part of xed
*
* Copyright (C) 2008 - Jesse van den Kieboom
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/

#include "xed-plugin-loader-python.h"
#include "xed-plugin-python.h"
#include <xed/xed-object-module.h>

#define NO_IMPORT_PYGOBJECT
#define NO_IMPORT_PYGTK

#include <Python.h>
#include <pygobject.h>
#include <pygtk/pygtk.h>
#include <signal.h>
#include "config.h"

#if PY_VERSION_HEX < 0x02050000
typedef int Py_ssize_t;
#define PY_SSIZE_T_MAX INT_MAX
#define PY_SSIZE_T_MIN INT_MIN
#endif

#define XED_PLUGIN_LOADER_PYTHON_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE((object), XED_TYPE_PLUGIN_LOADER_PYTHON, XedPluginLoaderPythonPrivate))

struct _XedPluginLoaderPythonPrivate
{
GHashTable *loaded_plugins;
guint idle_gc;
gboolean init_failed;
};

typedef struct
{
PyObject *type;
PyObject *instance;
gchar *path;
} PythonInfo;

static void xed_plugin_loader_iface_init (gpointer g_iface, gpointer iface_data);

/* Exported by pyxed module */
void pyxed_register_classes (PyObject *d);
void pyxed_add_constants (PyObject *module, const gchar *strip_prefix);
extern PyMethodDef pyxed_functions[];

/* Exported by pyxedutils module */
void pyxedutils_register_classes (PyObject *d);
extern PyMethodDef pyxedutils_functions[];

/* Exported by pyxedcommands module */
void pyxedcommands_register_classes (PyObject *d);
extern PyMethodDef pyxedcommands_functions[];

/* We retreive this to check for correct class hierarchy */
static PyTypeObject *PyXedPlugin_Type;

XED_PLUGIN_LOADER_REGISTER_TYPE (XedPluginLoaderPython, xed_plugin_loader_python, G_TYPE_OBJECT, xed_plugin_loader_iface_init);


static PyObject *
find_python_plugin_type (XedPluginInfo *info,
PyObject *pymodule)
{
PyObject *locals, *key, *value;
Py_ssize_t pos = 0;
locals = PyModule_GetDict (pymodule);

while (PyDict_Next (locals, &pos, &key, &value))
{
if (!PyType_Check(value))
continue;

if (PyObject_IsSubclass (value, (PyObject*) PyXedPlugin_Type))
return value;
}
g_warning ("No XedPlugin derivative found in Python plugin '%s'",
xed_plugin_info_get_name (info));
return NULL;
}

static XedPlugin *
new_plugin_from_info (XedPluginLoaderPython *loader,
XedPluginInfo *info)
{
PythonInfo *pyinfo;
PyTypeObject *pytype;
PyObject *pyobject;
PyGObject *pygobject;
XedPlugin *instance;
PyObject *emptyarg;

pyinfo = (PythonInfo *)g_hash_table_lookup (loader->priv->loaded_plugins, info);
if (pyinfo == NULL)
return NULL;
pytype = (PyTypeObject *)pyinfo->type;
if (pytype->tp_new == NULL)
return NULL;

emptyarg = PyTuple_New(0);
pyobject = pytype->tp_new (pytype, emptyarg, NULL);
Py_DECREF (emptyarg);
if (pyobject == NULL)
{
g_error ("Could not create instance for %s.", xed_plugin_info_get_name (info));
return NULL;
}