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)
This commit is contained in:
parent
6893642b16
commit
cab79801ca
|
@ -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
|
||||
|
||||
|
|
124
configure.ac
124
configure.ac
|
@ -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,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
|
||||
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
62
m4/python.m4
62
m4/python.m4
|
@ -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"
|
||||
])
|
|
@ -1,7 +1,3 @@
|
|||
SUBDIRS = c
|
||||
|
||||
if ENABLE_PYTHON
|
||||
SUBDIRS += python
|
||||
endif
|
||||
|
||||
-include $(top_srcdir)/git.mk
|
||||
|
|
|
@ -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
|
|
@ -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
|
File diff suppressed because it is too large
Load Diff
|
@ -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;
|
||||
}
|
||||
%%
|
|
@ -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")
|
||||
)
|
||||
)
|
|
@ -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;
|
||||
}
|
|
@ -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;
|
||||
}
|
||||
}
|
|
@ -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);
|
||||
}
|
|
@ -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")
|
||||
)
|
||||
)
|
|
@ -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;
|
||||
}
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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__ */
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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__ */
|
||||
|
|
@ -1,7 +1,4 @@
|
|||
[Xed Plugin]
|
||||
##ifdef WITH_PYTHON
|
||||
Loader=python
|
||||
##endif
|
||||
Module=##(PLUGIN_MODULE)
|
||||
IAge=2
|
||||
_Name=##(PLUGIN_NAME)
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
* xed-plugin-info-priv.h
|
||||
* This file is part of xed
|
||||
*
|
||||
* Copyright (C) 2002-2005 - Paolo Maggi
|
||||
* Copyright (C) 2002-2005 - Paolo Maggi
|
||||
* Copyright (C) 2007 - Paolo Maggi, Steve Frécinaux
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
|
@ -17,10 +17,10 @@
|
|||
*
|
||||
* 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.
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
* Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Modified by the xed Team, 2002-2007. See the AUTHORS file for a
|
||||
* list of people on the xed Team.
|
||||
|
@ -55,8 +55,7 @@ struct _XedPluginInfo
|
|||
gchar *version;
|
||||
|
||||
/* 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
|
||||
when the interpreter has not been correctly initializated) */
|
||||
due to an error loading the plugin module */
|
||||
gint available : 1;
|
||||
};
|
||||
|
||||
|
|
Loading…
Reference in New Issue