wp/xed
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

plugins: Drop support for old style python plugins

Browse Source 
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)
This commit is contained in:
JosephMcc
2016-12-25 14:24:00 -08:00
parent 6893642b16
commit cab79801ca
22 changed files with 9 additions and 4502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
autogen.sh
View File

@@ -24,7 +24,6 @@ which yelp-build || {
} }
REQUIRED_AUTOMAKE_VERSION=1.9 REQUIRED_AUTOMAKE_VERSION=1.9
REQUIRED_MACROS=python.m4
GNOME_DATADIR="$gnome_datadir" GNOME_DATADIR="$gnome_datadir"
USE_COMMON_DOC_BUILD=yes USE_COMMON_DOC_BUILD=yes

120
configure.ac
View File

@@ -178,123 +178,6 @@ dnl ================================================================
GLIB_GSETTINGS 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 ================================================================
dnl Misc dnl Misc
dnl ================================================================ dnl ================================================================
@@ -355,8 +238,6 @@ help/Makefile
pixmaps/Makefile pixmaps/Makefile
plugin-loaders/Makefile plugin-loaders/Makefile
plugin-loaders/c/Makefile plugin-loaders/c/Makefile
plugin-loaders/python/Makefile
plugin-loaders/python/bindings/Makefile
plugins/Makefile plugins/Makefile
plugins/changecase/Makefile plugins/changecase/Makefile
plugins/docinfo/Makefile plugins/docinfo/Makefile
@@ -382,7 +263,6 @@ Configuration:
Source code location: ${srcdir} Source code location: ${srcdir}
Compiler: ${CC} Compiler: ${CC}
Python Plugins Support: $enable_python
Spell Plugin enabled: $enable_enchant Spell Plugin enabled: $enable_enchant
Gvfs metadata enabled: $enable_gvfs_metadata Gvfs metadata enabled: $enable_gvfs_metadata
Tests enabled: $enable_tests Tests enabled: $enable_tests

23
data/xed-bugreport.sh.in
View File

@@ -1,10 +1,7 @@
#!/bin/sh #!/bin/sh
ENABLE_PYTHON=@enable_python@
PKG_CONFIG_MODULES="glib-2.0 gtk+-2.0 gtksourceview-2.0 \ PKG_CONFIG_MODULES="glib-2.0 gtk+-2.0 gtksourceview-2.0 \
pygobject-2.0 pygtk-2.0 \ enchant iso-codes"
pygtksourceview-2.0 enchant iso-codes"
echo_padded () echo_padded ()
{ {
@@ -53,21 +50,3 @@ else
echo " pkg-config unavailable" echo " pkg-config unavailable"
fi fi
echo 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

10
docs/reference/Makefile.am
View File

@@ -96,16 +96,6 @@ GTKDOC_LIBS= \
$(top_builddir)/xed/libxed.la \ $(top_builddir)/xed/libxed.la \
$(XED_LIBS) $(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. # This includes the standard gtk-doc make rules, copied by gtkdocize.
include $(top_srcdir)/gtk-doc.make include $(top_srcdir)/gtk-doc.make

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"
])

4
plugin-loaders/Makefile.am
View File

@@ -1,7 +1,3 @@
SUBDIRS = c SUBDIRS = c
if ENABLE_PYTHON
SUBDIRS += python
endif
-include $(top_srcdir)/git.mk -include $(top_srcdir)/git.mk

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

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

1442
plugin-loaders/python/bindings/xed.defs
View File

File diff suppressed because it is too large Load Diff

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;
}
%%

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")
)
)

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;
}

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;
}
}

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);
}

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")
)
)

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;
}

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;
}
pygobject = (PyGObject *)pyobject;
if (pygobject->obj != NULL)
{
Py_DECREF (pyobject);
g_error ("Could not create instance for %s (GObject already initialized).", xed_plugin_info_get_name (info));
return NULL;
}
pygobject_construct (pygobject,
"install-dir", pyinfo->path,
"data-dir-name", xed_plugin_info_get_module_name (info),
NULL);
if (pygobject->obj == NULL)
{
g_error ("Could not create instance for %s (GObject not constructed).", xed_plugin_info_get_name (info));
Py_DECREF (pyobject);
return NULL;
}
/* now call tp_init manually */
if (PyType_IsSubtype (pyobject->ob_type, pytype) &&
pyobject->ob_type->tp_init != NULL)
{
emptyarg = PyTuple_New(0);
pyobject->ob_type->tp_init (pyobject, emptyarg, NULL);
Py_DECREF (emptyarg);
}
instance = XED_PLUGIN (pygobject->obj);
pyinfo->instance = (PyObject *)pygobject;
/* make sure to register the python instance for the XedPluginPython
object to it can wrap the virtual xed plugin funcs back to python */
_xed_plugin_python_set_instance (XED_PLUGIN_PYTHON (instance), (PyObject *)pygobject);
/* we return a reference here because the other is owned by python */
return XED_PLUGIN (g_object_ref (instance));
}
static XedPlugin *
add_python_info (XedPluginLoaderPython *loader,
XedPluginInfo *info,
PyObject *module,
const gchar *path,
PyObject *type)
{
PythonInfo *pyinfo;
pyinfo = g_new (PythonInfo, 1);
pyinfo->path = g_strdup (path);
pyinfo->type = type;
Py_INCREF (pyinfo->type);
g_hash_table_insert (loader->priv->loaded_plugins, info, pyinfo);
return new_plugin_from_info (loader, info);
}
static const gchar *
xed_plugin_loader_iface_get_id (void)
{
return "Python";
}
static XedPlugin *
xed_plugin_loader_iface_load (XedPluginLoader *loader,
XedPluginInfo *info,
const gchar *path)
{
XedPluginLoaderPython *pyloader = XED_PLUGIN_LOADER_PYTHON (loader);
PyObject *main_module, *main_locals, *pytype;
PyObject *pymodule, *fromlist;
gchar *module_name;
XedPlugin *result;
if (pyloader->priv->init_failed)
{
g_warning ("Cannot load python plugin Python '%s' since xed was"
"not able to initialize the Python interpreter.",
xed_plugin_info_get_name (info));
return NULL;
}
/* see if py definition for the plugin is already loaded */
result = new_plugin_from_info (pyloader, info);
if (result != NULL)
return result;
main_module = PyImport_AddModule ("xed.plugins");
if (main_module == NULL)
{
g_warning ("Could not get xed.plugins.");
return NULL;
}
/* If we have a special path, we register it */
if (path != NULL)
{
PyObject *sys_path = PySys_GetObject ("path");
PyObject *pypath = PyString_FromString (path);
if (PySequence_Contains (sys_path, pypath) == 0)
PyList_Insert (sys_path, 0, pypath);
Py_DECREF (pypath);
}
main_locals = PyModule_GetDict (main_module);
/* we need a fromlist to be able to import modules with a '.' in the
name. */
fromlist = PyTuple_New(0);
module_name = g_strdup (xed_plugin_info_get_module_name (info));
pymodule = PyImport_ImportModuleEx (module_name,
main_locals,
main_locals,
fromlist);
Py_DECREF(fromlist);
if (!pymodule)
{
g_free (module_name);
PyErr_Print ();
return NULL;
}
PyDict_SetItemString (main_locals, module_name, pymodule);
g_free (module_name);
pytype = find_python_plugin_type (info, pymodule);
if (pytype)
return add_python_info (pyloader, info, pymodule, path, pytype);
return NULL;
}
static void
xed_plugin_loader_iface_unload (XedPluginLoader *loader,
XedPluginInfo *info)
{
XedPluginLoaderPython *pyloader = XED_PLUGIN_LOADER_PYTHON (loader);
PythonInfo *pyinfo;
PyGILState_STATE state;
pyinfo = (PythonInfo *)g_hash_table_lookup (pyloader->priv->loaded_plugins, info);
if (!pyinfo)
return;
state = pyg_gil_state_ensure ();
Py_XDECREF (pyinfo->instance);
pyg_gil_state_release (state);
pyinfo->instance = NULL;
}
static gboolean
run_gc (XedPluginLoaderPython *loader)
{
while (PyGC_Collect ())
;
loader->priv->idle_gc = 0;
return FALSE;
}
static void
xed_plugin_loader_iface_garbage_collect (XedPluginLoader *loader)
{
XedPluginLoaderPython *pyloader;
if (!Py_IsInitialized())
return;
pyloader = XED_PLUGIN_LOADER_PYTHON (loader);
/*
* We both run the GC right now and we schedule
* a further collection in the main loop.
*/
while (PyGC_Collect ())
;
if (pyloader->priv->idle_gc == 0)
pyloader->priv->idle_gc = g_idle_add ((GSourceFunc)run_gc, pyloader);
}
static void
xed_plugin_loader_iface_init (gpointer g_iface,
gpointer iface_data)
{
XedPluginLoaderInterface *iface = (XedPluginLoaderInterface *)g_iface;
iface->get_id = xed_plugin_loader_iface_get_id;
iface->load = xed_plugin_loader_iface_load;
iface->unload = xed_plugin_loader_iface_unload;
iface->garbage_collect = xed_plugin_loader_iface_garbage_collect;
}
static void
xed_python_shutdown (XedPluginLoaderPython *loader)
{
if (!Py_IsInitialized ())
return;
if (loader->priv->idle_gc != 0)
{
g_source_remove (loader->priv->idle_gc);
loader->priv->idle_gc = 0;
}
while (PyGC_Collect ())
;
Py_Finalize ();
}
/* C equivalent of
* import pygtk
* pygtk.require ("2.0")
*/
static gboolean
xed_check_pygtk2 (void)
{
PyObject *pygtk, *mdict, *require;
/* pygtk.require("2.0") */
pygtk = PyImport_ImportModule ("pygtk");
if (pygtk == NULL)
{
g_warning ("Error initializing Python interpreter: could not import pygtk.");
return FALSE;
}
mdict = PyModule_GetDict (pygtk);
require = PyDict_GetItemString (mdict, "require");
PyObject_CallObject (require,
Py_BuildValue ("(S)", PyString_FromString ("2.0")));
if (PyErr_Occurred())
{
g_warning ("Error initializing Python interpreter: pygtk 2 is required.");
return FALSE;
}
return TRUE;
}
/* Note: the following two functions are needed because
* init_pyobject and init_pygtk which are *macros* which in case
* case of error set the PyErr and then make the calling
* function return behind our back.
* It's up to the caller to check the result with PyErr_Occurred()
*/
static void
xed_init_pygobject (void)
{
init_pygobject_check (2, 11, 5); /* FIXME: get from config */
}
static void
xed_init_pygtk (void)
{
PyObject *gtk, *mdict, *version, *required_version;
init_pygtk ();
/* there isn't init_pygtk_check(), do the version
* check ourselves */
gtk = PyImport_ImportModule("gtk");
mdict = PyModule_GetDict(gtk);
version = PyDict_GetItemString (mdict, "pygtk_version");
if (!version)
{
PyErr_SetString (PyExc_ImportError,
"PyGObject version too old");
return;
}
required_version = Py_BuildValue ("(iii)", 2, 4, 0); /* FIXME */
if (PyObject_Compare (version, required_version) == -1)
{
PyErr_SetString (PyExc_ImportError,
"PyGObject version too old");
Py_DECREF (required_version);
return;
}
Py_DECREF (required_version);
}
static void
old_gtksourceview_init (void)
{
PyErr_SetString(PyExc_ImportError,
"gtksourceview module not allowed, use gtksourceview2");
}
static void
xed_init_pygtksourceview (void)
{
PyObject *gtksourceview, *mdict, *version, *required_version;
gtksourceview = PyImport_ImportModule("gtksourceview2");
if (gtksourceview == NULL)
{
PyErr_SetString (PyExc_ImportError,
"could not import gtksourceview");
return;
}
mdict = PyModule_GetDict (gtksourceview);
version = PyDict_GetItemString (mdict, "pygtksourceview2_version");
if (!version)
{
PyErr_SetString (PyExc_ImportError,
"PyGtkSourceView version too old");
return;
}
required_version = Py_BuildValue ("(iii)", 0, 8, 0); /* FIXME */
if (PyObject_Compare (version, required_version) == -1)
{
PyErr_SetString (PyExc_ImportError,
"PyGtkSourceView version too old");
Py_DECREF (required_version);
return;
}
Py_DECREF (required_version);
/* Create a dummy 'gtksourceview' module to prevent
* loading of the old 'gtksourceview' modules that
* has conflicting symbols with the gtksourceview2 module.
* Raise an exception when trying to import it.
*/
PyImport_AppendInittab ("gtksourceview", old_gtksourceview_init);
}
static gboolean
xed_python_init (XedPluginLoaderPython *loader)
{
PyObject *mdict, *tuple;
PyObject *xed, *xedutils, *xedcommands, *xedplugins;
PyObject *gettext, *install, *gettext_args;
//char *argv[] = { "xed", NULL };
char *argv[] = { XED_PLUGINS_LIBS_DIR, NULL };
#ifdef HAVE_SIGACTION
gint res;
struct sigaction old_sigint;
#endif
if (loader->priv->init_failed)
{
/* We already failed to initialized Python, don't need to
* retry again */
return FALSE;
}
if (Py_IsInitialized ())
{
/* Python has already been successfully initialized */
return TRUE;
}
/* We are trying to initialize Python for the first time,
set init_failed to FALSE only if the entire initialization process
ends with success */
loader->priv->init_failed = TRUE;
/* Hack to make python not overwrite SIGINT: this is needed to avoid
* the crash reported on bug #326191 */
/* CHECK: can't we use Py_InitializeEx instead of Py_Initialize in order
to avoid to manage signal handlers ? - Paolo (Dec. 31, 2006) */
#ifdef HAVE_SIGACTION
/* Save old handler */
res = sigaction (SIGINT, NULL, &old_sigint);
if (res != 0)
{
g_warning ("Error initializing Python interpreter: cannot get "
"handler to SIGINT signal (%s)",
g_strerror (errno));
return FALSE;
}
#endif
/* Python initialization */
Py_Initialize ();
#ifdef HAVE_SIGACTION
/* Restore old handler */
res = sigaction (SIGINT, &old_sigint, NULL);
if (res != 0)
{
g_warning ("Error initializing Python interpreter: cannot restore "
"handler to SIGINT signal (%s).",
g_strerror (errno));
goto python_init_error;
}
#endif
PySys_SetArgv (1, argv);
if (!xed_check_pygtk2 ())
{
/* Warning message already printed in check_pygtk2 */
goto python_init_error;
}
/* import gobject */
xed_init_pygobject ();
if (PyErr_Occurred ())
{
g_warning ("Error initializing Python interpreter: could not import pygobject.");
goto python_init_error;
}
/* import gtk */
xed_init_pygtk ();
if (PyErr_Occurred ())
{
g_warning ("Error initializing Python interpreter: could not import pygtk.");
goto python_init_error;
}
/* import gtksourceview */
xed_init_pygtksourceview ();
if (PyErr_Occurred ())
{
PyErr_Print ();
g_warning ("Error initializing Python interpreter: could not import pygtksourceview.");
goto python_init_error;
}
/* import xed */
xed = Py_InitModule ("xed", pyxed_functions);
mdict = PyModule_GetDict (xed);
pyxed_register_classes (mdict);
pyxed_add_constants (xed, "XED_");
/* xed version */
tuple = Py_BuildValue("(iii)",
XED_MAJOR_VERSION,
XED_MINOR_VERSION,
XED_MICRO_VERSION);
PyDict_SetItemString(mdict, "version", tuple);
Py_DECREF(tuple);
/* Retrieve the Python type for xed.Plugin */
PyXedPlugin_Type = (PyTypeObject *) PyDict_GetItemString (mdict, "Plugin");
if (PyXedPlugin_Type == NULL)
{
PyErr_Print ();
goto python_init_error;
}
/* import xed.utils */
xedutils = Py_InitModule ("xed.utils", pyxedutils_functions);
PyDict_SetItemString (mdict, "utils", xedutils);
/* import xed.commands */
xedcommands = Py_InitModule ("xed.commands", pyxedcommands_functions);
PyDict_SetItemString (mdict, "commands", xedcommands);
/* initialize empty xed.plugins module */
xedplugins = Py_InitModule ("xed.plugins", NULL);
PyDict_SetItemString (mdict, "plugins", xedplugins);
mdict = PyModule_GetDict (xedutils);
pyxedutils_register_classes (mdict);
mdict = PyModule_GetDict (xedcommands);
pyxedcommands_register_classes (mdict);
/* i18n support */
gettext = PyImport_ImportModule ("gettext");
if (gettext == NULL)
{
g_warning ("Error initializing Python interpreter: could not import gettext.");
goto python_init_error;
}
mdict = PyModule_GetDict (gettext);
install = PyDict_GetItemString (mdict, "install");
gettext_args = Py_BuildValue ("ss", GETTEXT_PACKAGE, XED_LOCALEDIR);
PyObject_CallObject (install, gettext_args);
Py_DECREF (gettext_args);
/* Python has been successfully initialized */
loader->priv->init_failed = FALSE;
return TRUE;
python_init_error:
g_warning ("Please check the installation of all the Python related packages required "
"by xed and try again.");
PyErr_Clear ();
xed_python_shutdown (loader);
return FALSE;
}
static void
xed_plugin_loader_python_finalize (GObject *object)
{
XedPluginLoaderPython *pyloader = XED_PLUGIN_LOADER_PYTHON (object);
g_hash_table_destroy (pyloader->priv->loaded_plugins);
xed_python_shutdown (pyloader);
G_OBJECT_CLASS (xed_plugin_loader_python_parent_class)->finalize (object);
}
static void
xed_plugin_loader_python_class_init (XedPluginLoaderPythonClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = xed_plugin_loader_python_finalize;
g_type_class_add_private (object_class, sizeof (XedPluginLoaderPythonPrivate));
}
static void
xed_plugin_loader_python_class_finalize (XedPluginLoaderPythonClass *klass)
{
}
static void
destroy_python_info (PythonInfo *info)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
Py_XDECREF (info->type);
pyg_gil_state_release (state);
g_free (info->path);
g_free (info);
}
static void
xed_plugin_loader_python_init (XedPluginLoaderPython *self)
{
self->priv = XED_PLUGIN_LOADER_PYTHON_GET_PRIVATE (self);
/* initialize python interpreter */
xed_python_init (self);
/* loaded_plugins maps XedPluginInfo to a PythonInfo */
self->priv->loaded_plugins = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)destroy_python_info);
}
XedPluginLoaderPython *
xed_plugin_loader_python_new ()
{
GObject *loader = g_object_new (XED_TYPE_PLUGIN_LOADER_PYTHON, NULL);
return XED_PLUGIN_LOADER_PYTHON (loader);
}

61
plugin-loaders/python/xed-plugin-loader-python.h
View File

@@ -1,61 +0,0 @@
/*
* xed-plugin-loader-python.h
* 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.
*/
#ifndef __XED_PLUGIN_LOADER_PYTHON_H__
#define __XED_PLUGIN_LOADER_PYTHON_H__
#include <xed/xed-plugin-loader.h>
G_BEGIN_DECLS
#define XED_TYPE_PLUGIN_LOADER_PYTHON (xed_plugin_loader_python_get_type ())
#define XED_PLUGIN_LOADER_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XED_TYPE_PLUGIN_LOADER_PYTHON, XedPluginLoaderPython))
#define XED_PLUGIN_LOADER_PYTHON_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XED_TYPE_PLUGIN_LOADER_PYTHON, XedPluginLoaderPython const))
#define XED_PLUGIN_LOADER_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), XED_TYPE_PLUGIN_LOADER_PYTHON, XedPluginLoaderPythonClass))
#define XED_IS_PLUGIN_LOADER_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XED_TYPE_PLUGIN_LOADER_PYTHON))
#define XED_IS_PLUGIN_LOADER_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), XED_TYPE_PLUGIN_LOADER_PYTHON))
#define XED_PLUGIN_LOADER_PYTHON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), XED_TYPE_PLUGIN_LOADER_PYTHON, XedPluginLoaderPythonClass))
typedef struct _XedPluginLoaderPython XedPluginLoaderPython;
typedef struct _XedPluginLoaderPythonClass XedPluginLoaderPythonClass;
typedef struct _XedPluginLoaderPythonPrivate XedPluginLoaderPythonPrivate;
struct _XedPluginLoaderPython {
GObject parent;
XedPluginLoaderPythonPrivate *priv;
};
struct _XedPluginLoaderPythonClass {
GObjectClass parent_class;
};
GType xed_plugin_loader_python_get_type (void) G_GNUC_CONST;
XedPluginLoaderPython *xed_plugin_loader_python_new(void);
/* All the loaders must implement this function */
G_MODULE_EXPORT GType register_xed_plugin_loader (GTypeModule * module);
G_END_DECLS
#endif /* __XED_PLUGIN_LOADER_PYTHON_H__ */

281
plugin-loaders/python/xed-plugin-python.c
View File

@@ -1,281 +0,0 @@
/*
* xed-plugin-python.c
* This file is part of xed
*
* Copyright (C) 2005 Raphael Slinckx
* 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 <config.h>
#include "xed-plugin-python.h"
#include <xed/xed-plugin.h>
#include <xed/xed-debug.h>
#include <pygobject.h>
#include <string.h>
#define XED_PLUGIN_PYTHON_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), XED_TYPE_PLUGIN_PYTHON, XedPluginPythonPrivate))
static GObjectClass *parent_class;
struct _XedPluginPythonPrivate
{
PyObject *instance;
};
static void xed_plugin_python_class_init (XedPluginPythonClass *klass);
static void xed_plugin_python_init (XedPluginPython *plugin);
G_DEFINE_TYPE (XedPluginPython, xed_plugin_python, XED_TYPE_PLUGIN)
static PyObject *
call_python_method (XedPluginPythonPrivate *priv,
XedWindow *window,
gchar *method)
{
PyObject *py_ret = NULL;
g_return_val_if_fail (PyObject_HasAttrString (priv->instance, method), NULL);
if (window == NULL)
{
py_ret = PyObject_CallMethod (priv->instance,
method,
NULL);
}
else
{
py_ret = PyObject_CallMethod (priv->instance,
method,
"(N)",
pygobject_new (G_OBJECT (window)));
}
if (!py_ret)
PyErr_Print ();
return py_ret;
}
static gboolean
check_py_object_is_gtk_widget (PyObject *py_obj)
{
static PyTypeObject *_PyGtkWidget_Type = NULL;
if (_PyGtkWidget_Type == NULL)
{
PyObject *module;
if ((module = PyImport_ImportModule ("gtk")))
{
PyObject *moddict = PyModule_GetDict (module);
_PyGtkWidget_Type = (PyTypeObject *) PyDict_GetItemString (moddict, "Widget");
}
if (_PyGtkWidget_Type == NULL)
{
PyErr_SetString(PyExc_TypeError, "could not find Python gtk widget type");
PyErr_Print();
return FALSE;
}
}
return PyObject_TypeCheck (py_obj, _PyGtkWidget_Type) ? TRUE : FALSE;
}
static void
impl_update_ui (XedPlugin *plugin,
XedWindow *window)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
XedPluginPythonPrivate *priv = XED_PLUGIN_PYTHON(plugin)->priv;
if (PyObject_HasAttrString (priv->instance, "update_ui"))
{
PyObject *py_ret = call_python_method (priv, window, "update_ui");
if (py_ret)
{
Py_XDECREF (py_ret);
}
}
else
XED_PLUGIN_CLASS (parent_class)->update_ui (plugin, window);
pyg_gil_state_release (state);
}
static void
impl_deactivate (XedPlugin *plugin,
XedWindow *window)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
XedPluginPythonPrivate *priv = XED_PLUGIN_PYTHON(plugin)->priv;
if (PyObject_HasAttrString (priv->instance, "deactivate"))
{
PyObject *py_ret = call_python_method (priv, window, "deactivate");
if (py_ret)
{
Py_XDECREF (py_ret);
}
}
else
XED_PLUGIN_CLASS (parent_class)->deactivate (plugin, window);
pyg_gil_state_release (state);
}
static void
impl_activate (XedPlugin *plugin,
XedWindow *window)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
XedPluginPythonPrivate *priv = XED_PLUGIN_PYTHON(plugin)->priv;
if (PyObject_HasAttrString (priv->instance, "activate"))
{
PyObject *py_ret = call_python_method (priv, window, "activate");
if (py_ret)
{
Py_XDECREF (py_ret);
}
}
else
XED_PLUGIN_CLASS (parent_class)->activate (plugin, window);
pyg_gil_state_release (state);
}
static GtkWidget *
impl_create_configure_dialog (XedPlugin *plugin)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
XedPluginPythonPrivate *priv = XED_PLUGIN_PYTHON(plugin)->priv;
GtkWidget *ret = NULL;
if (PyObject_HasAttrString (priv->instance, "create_configure_dialog"))
{
PyObject *py_ret = call_python_method (priv, NULL, "create_configure_dialog");
if (py_ret)
{
if (check_py_object_is_gtk_widget (py_ret))
{
ret = GTK_WIDGET (pygobject_get (py_ret));
g_object_ref (ret);
}
else
{
PyErr_SetString(PyExc_TypeError, "return value for create_configure_dialog is not a GtkWidget");
PyErr_Print();
}
Py_DECREF (py_ret);
}
}
else
ret = XED_PLUGIN_CLASS (parent_class)->create_configure_dialog (plugin);
pyg_gil_state_release (state);
return ret;
}
static gboolean
impl_is_configurable (XedPlugin *plugin)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
XedPluginPythonPrivate *priv = XED_PLUGIN_PYTHON(plugin)->priv;
PyObject *dict = priv->instance->ob_type->tp_dict;
gboolean result;
if (dict == NULL)
result = FALSE;
else if (!PyDict_Check(dict))
result = FALSE;
else
result = PyDict_GetItemString(dict, "create_configure_dialog") != NULL;
pyg_gil_state_release (state);
return result;
}
void
_xed_plugin_python_set_instance (XedPluginPython *plugin,
PyObject *instance)
{
PyGILState_STATE state = pyg_gil_state_ensure ();
/* we don't increment the instance here because we are the instance,
when it dies, we also die */
plugin->priv->instance = instance;
pyg_gil_state_release (state);
}
PyObject *
_xed_plugin_python_get_instance (XedPluginPython *plugin)
{
return plugin->priv->instance;
}
static void
xed_plugin_python_init (XedPluginPython *plugin)
{
plugin->priv = XED_PLUGIN_PYTHON_GET_PRIVATE(plugin);
xed_debug_message (DEBUG_PLUGINS, "Creating Python plugin instance");
plugin->priv->instance = 0;
}
static void
xed_plugin_python_finalize (GObject *object)
{
PyGILState_STATE state;
xed_debug_message (DEBUG_PLUGINS, "Finalizing Python plugin instance");
state = pyg_gil_state_ensure ();
Py_XDECREF (XED_PLUGIN_PYTHON(object)->priv->instance);
pyg_gil_state_release (state);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
xed_plugin_python_class_init (XedPluginPythonClass *klass)
{
XedPluginClass *plugin_class = XED_PLUGIN_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
g_type_class_add_private (klass, sizeof (XedPluginPythonPrivate));
G_OBJECT_CLASS (klass)->finalize = xed_plugin_python_finalize;
plugin_class->activate = impl_activate;
plugin_class->deactivate = impl_deactivate;
plugin_class->update_ui = impl_update_ui;
plugin_class->create_configure_dialog = impl_create_configure_dialog;
plugin_class->is_configurable = impl_is_configurable;
}

88
plugin-loaders/python/xed-plugin-python.h
View File

@@ -1,88 +0,0 @@
/*
* xed-plugin-python.h
* This file is part of xed
*
* Copyright (C) 2005 - Raphael Slinckx
* 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.
*/
#ifndef __XED_PLUGIN_PYTHON_H__
#define __XED_PLUGIN_PYTHON_H__
#define NO_IMPORT_PYGOBJECT
#include <glib-object.h>
#include <pygobject.h>
#include <xed/xed-plugin.h>
G_BEGIN_DECLS
/*
* Type checking and casting macros
*/
#define XED_TYPE_PLUGIN_PYTHON (xed_plugin_python_get_type())
#define XED_PLUGIN_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), XED_TYPE_PLUGIN_PYTHON, XedPluginPython))
#define XED_PLUGIN_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), XED_TYPE_PLUGIN_PYTHON, XedPluginPythonClass))
#define XED_IS_PLUGIN_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), XED_TYPE_PLUGIN_PYTHON))
#define XED_IS_PLUGIN_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), XED_TYPE_PLUGIN_PYTHON))
#define XED_PLUGIN_PYTHON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), XED_TYPE_PLUGIN_PYTHON, XedPluginPythonClass))
/* Private structure type */
typedef struct _XedPluginPythonPrivate XedPluginPythonPrivate;
/*
* Main object structure
*/
typedef struct _XedPluginPython XedPluginPython;
struct _XedPluginPython
{
XedPlugin parent;
/*< private > */
XedPluginPythonPrivate *priv;
};
/*
* Class definition
*/
typedef struct _XedPluginPythonClass XedPluginPythonClass;
struct _XedPluginPythonClass
{
XedPluginClass parent_class;
};
/*
* Public methods
*/
GType xed_plugin_python_get_type (void) G_GNUC_CONST;
/*
* Private methods
*/
void _xed_plugin_python_set_instance (XedPluginPython *plugin,
PyObject *instance);
PyObject *_xed_plugin_python_get_instance (XedPluginPython *plugin);
G_END_DECLS
#endif /* __XED_PLUGIN_PYTHON_H__ */

3
tools/plugin_template/xed-plugin.desktop.in
View File

@@ -1,7 +1,4 @@
[Xed Plugin] [Xed Plugin]
##ifdef WITH_PYTHON
Loader=python
##endif
Module=##(PLUGIN_MODULE) Module=##(PLUGIN_MODULE)
IAge=2 IAge=2
_Name=##(PLUGIN_NAME) _Name=##(PLUGIN_NAME)

3
xed/xed-plugin-info-priv.h
View File

@@ -55,8 +55,7 @@ struct _XedPluginInfo
gchar *version; gchar *version;
/* A plugin is unavailable if it is not possible to activate it /* A plugin is unavailable if it is not possible to activate it
due to an error loading the plugin module (e.g. for Python plugins due to an error loading the plugin module */
when the interpreter has not been correctly initializated) */
gint available : 1; gint available : 1;
}; };