1 files changed, 527 insertions, 0 deletions
diff --git a/src/eom-python-module.c b/src/eom-python-module.c
new file mode 100644
index 0000000..d0e05a5
--- /dev/null
+++ b/src/eom-python-module.c
@@ -0,0 +1,527 @@
+/*
+ * eom-python-module.c
+ * This file is part of eom
+ *
+ * Copyright (C) 2005 Raphael Slinckx
+ *
+ * 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., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* This needs to be included before any standard header
+ * see http://docs.python.org/c-api/intro.html#include-files */
+#include <Python.h>
+
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+#include <signal.h>
+
+#include <gmodule.h>
+
+#include "eom-python-module.h"
+#include "eom-python-plugin.h"
+#include "eom-debug.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 EOM_PYTHON_MODULE_GET_PRIVATE(object) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EOM_TYPE_PYTHON_MODULE, EomPythonModulePrivate))
+
+struct _EomPythonModulePrivate {
+ gchar *module;
+ gchar *path;
+ GType type;
+};
+
+enum {
+ PROP_0,
+ PROP_PATH,
+ PROP_MODULE
+};
+
+void pyeom_register_classes (PyObject *d);
+void pyeom_add_constants (PyObject *module, const gchar *strip_prefix);
+extern PyMethodDef pyeom_functions[];
+
+static PyTypeObject *PyEomPlugin_Type;
+
+G_DEFINE_TYPE (EomPythonModule, eom_python_module, G_TYPE_TYPE_MODULE)
+
+static gboolean
+eom_python_module_load (GTypeModule *gmodule)
+{
+ EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (gmodule);
+ PyObject *main_module, *main_locals, *locals, *key, *value;
+ PyObject *module, *fromlist;
+ Py_ssize_t pos = 0;
+
+ g_return_val_if_fail (Py_IsInitialized (), FALSE);
+
+ main_module = PyImport_AddModule ("__main__");
+
+ if (main_module == NULL) {
+ g_warning ("Could not get __main__.");
+ return FALSE;
+ }
+
+ /* If we have a special path, we register it */
+ if (priv->path != NULL) {
+ PyObject *sys_path = PySys_GetObject ("path");
+ PyObject *path = PyString_FromString (priv->path);
+
+ if (PySequence_Contains(sys_path, path) == 0)
+ PyList_Insert (sys_path, 0, path);
+
+ Py_DECREF(path);
+ }
+
+ 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 = PyImport_ImportModuleEx (priv->module, main_locals, main_locals, fromlist);
+
+ Py_DECREF(fromlist);
+
+ if (!module) {
+ PyErr_Print ();
+ return FALSE;
+ }
+
+ locals = PyModule_GetDict (module);
+
+ while (PyDict_Next (locals, &pos, &key, &value)) {
+ if (!PyType_Check(value))
+ continue;
+
+ if (PyObject_IsSubclass (value, (PyObject*) PyEomPlugin_Type)) {
+ priv->type = eom_python_plugin_get_type (gmodule, value);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static void
+eom_python_module_unload (GTypeModule *module)
+{
+ EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (module);
+
+ eom_debug_message (DEBUG_PLUGINS, "Unloading Python module");
+
+ priv->type = 0;
+}
+
+GObject *
+eom_python_module_new_object (EomPythonModule *module)
+{
+ EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (module);
+
+ eom_debug_message (DEBUG_PLUGINS, "Creating object of type %s", g_type_name (priv->type));
+
+ if (priv->type == 0)
+ return NULL;
+
+ return g_object_new (priv->type, NULL);
+}
+
+static void
+eom_python_module_init (EomPythonModule *module)
+{
+ eom_debug_message (DEBUG_PLUGINS, "Init of Python module");
+}
+
+static void
+eom_python_module_finalize (GObject *object)
+{
+ EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (object);
+
+ eom_debug_message (DEBUG_PLUGINS, "Finalizing Python module %s", g_type_name (priv->type));
+
+ g_free (priv->module);
+ g_free (priv->path);
+
+ G_OBJECT_CLASS (eom_python_module_parent_class)->finalize (object);
+}
+
+static void
+eom_python_module_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ g_return_if_reached ();
+}
+
+static void
+eom_python_module_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EomPythonModule *mod = EOM_PYTHON_MODULE (object);
+
+ switch (prop_id) {
+ case PROP_MODULE:
+ EOM_PYTHON_MODULE_GET_PRIVATE (mod)->module = g_value_dup_string (value);
+ break;
+
+ case PROP_PATH:
+ EOM_PYTHON_MODULE_GET_PRIVATE (mod)->path = g_value_dup_string (value);
+ break;
+
+ default:
+ g_return_if_reached ();
+ }
+}
+
+static void
+eom_python_module_class_init (EomPythonModuleClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+ GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class);
+
+ object_class->finalize = eom_python_module_finalize;
+ object_class->get_property = eom_python_module_get_property;
+ object_class->set_property = eom_python_module_set_property;
+
+ g_object_class_install_property
+ (object_class,
+ PROP_MODULE,
+ g_param_spec_string ("module",
+ "Module Name",
+ "The Python module to load for this plugin",
+ NULL,
+ G_PARAM_WRITABLE | G_PARAM_READABLE | G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property
+ (object_class,
+ PROP_PATH,
+ g_param_spec_string ("path",
+ "Path",
+ "The Python path to use when loading this module",
+ NULL,
+ G_PARAM_WRITABLE | G_PARAM_READABLE | G_PARAM_CONSTRUCT_ONLY));
+
+ g_type_class_add_private (object_class, sizeof (EomPythonModulePrivate));
+
+ module_class->load = eom_python_module_load;
+ module_class->unload = eom_python_module_unload;
+}
+
+EomPythonModule *
+eom_python_module_new (const gchar *path,
+ const gchar *module)
+{
+ EomPythonModule *result;
+
+ if (module == NULL || module[0] == '\0')
+ return NULL;
+
+ result = g_object_new (EOM_TYPE_PYTHON_MODULE,
+ "module", module,
+ "path", path,
+ NULL);
+
+ g_type_module_set_name (G_TYPE_MODULE (result), module);
+
+ return result;
+}
+
+
+static gint idle_garbage_collect_id = 0;
+
+/* C equivalent of
+ * import pygtk
+ * pygtk.require ("2.0")
+ */
+static gboolean
+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
+eom_init_pygobject (void)
+{
+ init_pygobject_check (2, 11, 5); /* FIXME: get from config */
+}
+
+static void
+eom_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);
+}
+
+gboolean
+eom_python_init (void)
+{
+ PyObject *mdict, *path, *tuple;
+ PyObject *sys_path, *eom;
+ PyObject *gettext, *install, *gettext_args;
+ struct sigaction old_sigint;
+ gint res;
+ /* Workaround for python bug. See #569228. */
+ char *argv[] = { "/dev/null/python/is/buggy/eom", NULL };
+
+ static gboolean init_failed = FALSE;
+
+ if (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 */
+ 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) */
+
+ /* 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)", strerror (errno));
+
+ return FALSE;
+ }
+
+ /* Python initialization */
+ Py_Initialize ();
+
+ /* 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).", strerror (errno));
+
+ goto python_init_error;
+ }
+
+ PySys_SetArgv (1, argv);
+
+ /* Sanitize sys.path */
+ PyRun_SimpleString("import sys; sys.path = filter(None, sys.path)");
+
+ if (!check_pygtk2 ()) {
+ /* Warning message already printed in check_pygtk2 */
+ goto python_init_error;
+ }
+
+ /* import gobject */
+ eom_init_pygobject ();
+
+ if (PyErr_Occurred ()) {
+ g_warning ("Error initializing Python interpreter: could not import pygobject.");
+
+ goto python_init_error;
+ }
+
+ /* import gtk */
+ eom_init_pygtk ();
+
+ if (PyErr_Occurred ()) {
+ g_warning ("Error initializing Python interpreter: could not import pygtk.");
+
+ goto python_init_error;
+ }
+
+ /* sys.path.insert(0, ...) for system-wide plugins */
+ sys_path = PySys_GetObject ("path");
+ path = PyString_FromString (EOM_PLUGIN_DIR "/");
+ PyList_Insert (sys_path, 0, path);
+ Py_DECREF(path);
+
+ /* import eom */
+ eom = Py_InitModule ("eom", pyeom_functions);
+ mdict = PyModule_GetDict (eom);
+
+ pyeom_register_classes (mdict);
+ pyeom_add_constants (eom, "EOM_");
+
+ /* eom version */
+ tuple = Py_BuildValue("(iii)",
+ EOM_MAJOR_VERSION,
+ EOM_MINOR_VERSION,
+ EOM_MICRO_VERSION);
+ PyDict_SetItemString(mdict, "version", tuple);
+ Py_DECREF(tuple);
+
+ /* Retrieve the Python type for eom.Plugin */
+ PyEomPlugin_Type = (PyTypeObject *) PyDict_GetItemString (mdict, "Plugin");
+
+ if (PyEomPlugin_Type == NULL) {
+ PyErr_Print ();
+
+ goto python_init_error;
+ }
+
+ /* 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, EOM_LOCALE_DIR);
+ PyObject_CallObject (install, gettext_args);
+ Py_DECREF (gettext_args);
+
+ /* Python has been successfully initialized */
+ init_failed = FALSE;
+
+ return TRUE;
+
+python_init_error:
+
+ g_warning ("Please check the installation of all the Python related packages required "
+ "by eom and try again.");
+
+ PyErr_Clear ();
+
+ eom_python_shutdown ();
+
+ return FALSE;
+}
+
+void
+eom_python_shutdown (void)
+{
+ if (Py_IsInitialized ()) {
+ if (idle_garbage_collect_id != 0) {
+ g_source_remove (idle_garbage_collect_id);
+ idle_garbage_collect_id = 0;
+ }
+
+ while (PyGC_Collect ())
+ ;
+
+ Py_Finalize ();
+ }
+}
+
+static gboolean
+run_gc (gpointer data)
+{
+ while (PyGC_Collect ())
+ ;
+
+ idle_garbage_collect_id = 0;
+
+ return FALSE;
+}
+
+void
+eom_python_garbage_collect (void)
+{
+ if (Py_IsInitialized()) {
+ /*
+ * We both run the GC right now and we schedule
+ * a further collection in the main loop.
+ */
+
+ while (PyGC_Collect ())
+ ;
+
+ if (idle_garbage_collect_id == 0)
+ idle_garbage_collect_id = g_idle_add (run_gc, NULL);
+ }
+}
+