static void
gplp_func_exec_action (GOPluginService *service,
GnmAction const *action,
WorkbookControl *wbc,
GOErrorInfo **ret_error)
{
ServiceLoaderDataUI *loader_data;
PyObject *fn, *ret;
g_return_if_fail (_PyGObject_API != NULL);
GO_INIT_RET_ERROR_INFO (ret_error);
loader_data = g_object_get_data (G_OBJECT (service), "loader_data");
SWITCH_TO_PLUGIN (go_plugin_service_get_plugin (service));
fn = PyDict_GetItemString (loader_data->ui_actions, action->id);
if (fn == NULL) {
*ret_error = go_error_info_new_printf (_("Unknown action: %s"),
action->id);
return;
} else if (!PyCallable_Check (fn)) {
*ret_error = go_error_info_new_printf (
_("Not a valid function for action: %s"), action->id);
return;
}
ret = PyObject_CallFunction (fn, (char *) "N",
py_new_Gui_object (WBC_GTK (wbc)));
if (ret == NULL) {
*ret_error = go_error_info_new_str (py_exc_to_string ());
PyErr_Clear ();
} else {
Py_DECREF (ret);
}
}
static void
gplp_load_service_file_opener (GOPluginLoader *loader,
GOPluginService *service,
GOErrorInfo **ret_error)
{
printf("gplp_load_service_file_opener(start)\n");
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar *func_name_file_probe, *func_name_file_open;
PyObject *python_func_file_probe, *python_func_file_open;
g_return_if_fail (GO_IS_PLUGIN_SERVICE_FILE_OPENER (service));
GO_INIT_RET_ERROR_INFO (ret_error);
gnm_py_interpreter_switch_to (loader_python->py_interpreter_info);
gnm_py_interpreter_load(loader_python->py_interpreter_info);
func_name_file_probe = g_strconcat (
go_plugin_service_get_id (service), "_file_probe", NULL);
python_func_file_probe = PyDict_GetItemString (loader_python->main_module_dict,
func_name_file_probe);
gnm_python_clear_error_if_needed (loader_python->py_object);
func_name_file_open = g_strconcat (
go_plugin_service_get_id (service), "_file_open", NULL);
python_func_file_open = PyDict_GetItemString (loader_python->main_module_dict,
func_name_file_open);
gnm_python_clear_error_if_needed (loader_python->py_object);
if (python_func_file_open != NULL) {
GOPluginServiceFileOpenerCallbacks *cbs;
ServiceLoaderDataFileOpener *loader_data;
cbs = go_plugin_service_get_cbs (service);
cbs->plugin_func_file_probe = gplp_func_file_probe;
cbs->plugin_func_file_open = gplp_func_file_open;
loader_data = g_new (ServiceLoaderDataFileOpener, 1);
loader_data->python_func_file_probe = python_func_file_probe;
loader_data->python_func_file_open = python_func_file_open;
if (python_func_file_probe != NULL)
Py_INCREF (loader_data->python_func_file_probe);
Py_INCREF (loader_data->python_func_file_open);
g_object_set_data_full
(G_OBJECT (service), "loader_data", loader_data,
(GDestroyNotify) gplp_loader_data_opener_free);
} else {
*ret_error = go_error_info_new_printf (
_("Python file \"%s\" has invalid format."),
loader_python->module_name);
go_error_info_add_details (*ret_error,
go_error_info_new_printf (
_("File doesn't contain \"%s\" function."),
func_name_file_open));
}
g_free (func_name_file_probe);
g_free (func_name_file_open);
gnm_py_interpreter_save(loader_python->py_interpreter_info);
}
static void
go_plugin_service_file_opener_deactivate (GOPluginService *service,
GOErrorInfo **ret_error)
{
GOPluginServiceFileOpener *service_file_opener = GO_PLUGIN_SERVICE_FILE_OPENER (service);
GO_INIT_RET_ERROR_INFO (ret_error);
go_file_opener_unregister (service_file_opener->opener);
service->is_active = FALSE;
}
static void
gplp_load_service_function_group (GOPluginLoader *loader,
GOPluginService *service,
GOErrorInfo **ret_error)
{
printf("gplp_load_service_function_group(start)\n");
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar *fn_info_dict_name;
PyObject *python_fn_info_dict;
g_return_if_fail (IS_GNM_PLUGIN_SERVICE_FUNCTION_GROUP (service));
GO_INIT_RET_ERROR_INFO (ret_error);
gnm_py_interpreter_switch_to (loader_python->py_interpreter_info);
gnm_py_interpreter_load(loader_python->py_interpreter_info);
fn_info_dict_name = g_strconcat (
go_plugin_service_get_id (service), "_functions", NULL);
python_fn_info_dict = PyDict_GetItemString (loader_python->main_module_dict,
fn_info_dict_name);
gnm_python_clear_error_if_needed (loader_python->py_object);
if (python_fn_info_dict != NULL && PyDict_Check (python_fn_info_dict)) {
PluginServiceFunctionGroupCallbacks *cbs;
ServiceLoaderDataFunctionGroup *loader_data;
cbs = go_plugin_service_get_cbs (service);
cbs->func_desc_load = &gplp_func_desc_load;
loader_data = g_new (ServiceLoaderDataFunctionGroup, 1);
loader_data->python_fn_info_dict = (PyObject *) python_fn_info_dict;
Py_INCREF (loader_data->python_fn_info_dict);
g_object_set_data_full
(G_OBJECT (service), "loader_data", loader_data,
(GDestroyNotify) gplp_loader_data_fngroup_free);
} else {
*ret_error = go_error_info_new_printf (
_("Python file \"%s\" has invalid format."),
loader_python->module_name);
if (python_fn_info_dict == NULL) {
go_error_info_add_details (*ret_error,
go_error_info_new_printf (
_("File doesn't contain \"%s\" dictionary."),
fn_info_dict_name));
} else if (!PyDict_Check (python_fn_info_dict)) {
go_error_info_add_details (*ret_error,
go_error_info_new_printf (
_("Object \"%s\" is not a dictionary."),
fn_info_dict_name));
}
}
g_free (fn_info_dict_name);
gnm_py_interpreter_save(loader_python->py_interpreter_info);
printf("gplp_load_service_function_group(end)\n");
}
static void
go_plugin_service_file_opener_activate (GOPluginService *service,
GOErrorInfo **ret_error)
{
GOPluginServiceFileOpener *service_file_opener = GO_PLUGIN_SERVICE_FILE_OPENER (service);
GO_INIT_RET_ERROR_INFO (ret_error);
service_file_opener->opener = GO_FILE_OPENER (go_plugin_file_opener_new (service));
go_file_opener_register (service_file_opener->opener,
service_file_opener->priority);
service->is_active = TRUE;
}
static void
gplp_unload_base (GOPluginLoader *loader, GOErrorInfo **ret_error)
{
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
GOPlugin *plugin = go_plugin_loader_get_plugin (loader);
GO_INIT_RET_ERROR_INFO (ret_error);
g_object_steal_data (G_OBJECT (plugin), "python-loader");
gnm_python_destroy_interpreter (
loader_python->py_object, loader_python->py_interpreter_info);
g_object_unref (loader_python->py_object);
}
static void
go_plugin_service_file_saver_deactivate (GOPluginService *service, GOErrorInfo **ret_error)
{
GOPluginServiceFileSaver *service_file_saver = GO_PLUGIN_SERVICE_FILE_SAVER (service);
GHashTable *file_savers_hash;
GO_INIT_RET_ERROR_INFO (ret_error);
file_savers_hash = get_plugin_file_savers_hash (service->plugin);
g_hash_table_remove (file_savers_hash, service->id);
go_file_saver_unregister (service_file_saver->saver);
service->is_active = FALSE;
}
static void
gplp_load_service_ui (GOPluginLoader *loader,
GOPluginService *service,
GOErrorInfo **ret_error)
{
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar *ui_action_names;
PyObject *ui_actions;
g_return_if_fail (IS_GNM_PLUGIN_SERVICE_UI (service));
GO_INIT_RET_ERROR_INFO (ret_error);
gnm_py_interpreter_switch_to (loader_python->py_interpreter_info);
gnm_py_interpreter_load(loader_python->py_interpreter_info);
ui_action_names = g_strconcat (go_plugin_service_get_id (service),
"_ui_actions", NULL);
ui_actions = PyDict_GetItemString (loader_python->main_module_dict,
ui_action_names);
gnm_python_clear_error_if_needed (loader_python->py_object);
if (ui_actions != NULL && PyDict_Check (ui_actions)) {
PluginServiceUICallbacks *cbs;
ServiceLoaderDataUI *loader_data;
cbs = go_plugin_service_get_cbs (service);
cbs->plugin_func_exec_action = gplp_func_exec_action;
loader_data = g_new (ServiceLoaderDataUI, 1);
loader_data->ui_actions = ui_actions;
Py_INCREF (loader_data->ui_actions);
g_object_set_data_full
(G_OBJECT (service), "loader_data", loader_data,
(GDestroyNotify) gplp_loader_data_ui_free);
} else {
*ret_error = go_error_info_new_printf (
_("Python file \"%s\" has invalid format."),
loader_python->module_name);
if (ui_actions == NULL) {
go_error_info_add_details (*ret_error,
go_error_info_new_printf (
_("File doesn't contain \"%s\" dictionary."),
ui_action_names));
} else if (!PyDict_Check (ui_actions)) {
go_error_info_add_details (*ret_error,
go_error_info_new_printf (
_("Object \"%s\" is not a dictionary."),
ui_action_names));
}
}
g_free (ui_action_names);
gnm_py_interpreter_save(loader_python->py_interpreter_info);
}
void
go_plugin_service_load (GOPluginService *service, GOErrorInfo **ret_error)
{
g_return_if_fail (GO_IS_PLUGIN_SERVICE (service));
GO_INIT_RET_ERROR_INFO (ret_error);
if (service->is_loaded)
return;
go_plugin_load_service (service->plugin, service, ret_error);
if (*ret_error == NULL)
service->is_loaded = TRUE;
}
static void
go_plugin_service_plugin_loader_deactivate (GOPluginService *service,
GOErrorInfo **ret_error)
{
gchar *full_id;
GO_INIT_RET_ERROR_INFO (ret_error);
full_id = g_strconcat (
go_plugin_get_id (service->plugin), ":", service->id, NULL);
go_plugins_unregister_loader (full_id);
g_free (full_id);
service->is_active = FALSE;
}
static void
gplp_load_service_function_group (GOPluginLoader *loader,
GOPluginService *service,
GOErrorInfo **ret_error)
{
GnmPluginServiceFunctionGroupCallbacks *cbs;
g_return_if_fail (GNM_IS_PLUGIN_SERVICE_FUNCTION_GROUP (service));
GO_INIT_RET_ERROR_INFO (ret_error);
cbs = go_plugin_service_get_cbs (service);
cbs->load_stub = &gplp_func_load_stub;
}
static void
go_plugin_service_file_saver_read_xml (GOPluginService *service, xmlNode *tree, GOErrorInfo **ret_error)
{
xmlNode *information_node;
gchar *description;
GO_INIT_RET_ERROR_INFO (ret_error);
information_node = go_xml_get_child_by_name (tree, "information");
if (information_node != NULL) {
xmlNode *node = go_xml_get_child_by_name_by_lang
(information_node, "description");
description = node ? xml2c (xmlNodeGetContent (node)) : NULL;
} else {
description = NULL;
}
if (description != NULL) {
int scope = GO_FILE_SAVE_WORKBOOK;
int level = GO_FILE_FL_WRITE_ONLY;
GOPluginServiceFileSaver *psfs =
GO_PLUGIN_SERVICE_FILE_SAVER (service);
psfs->file_extension =
xml2c (go_xml_node_get_cstr (tree, "file_extension"));
psfs->mime_type =
xml2c (go_xml_node_get_cstr (tree, "mime_type"));
psfs->description = description;
(void)go_xml_node_get_enum
(tree, "format_level",
GO_TYPE_FILE_FORMAT_LEVEL, &level);
psfs->format_level = (GOFileFormatLevel)level;
if (!go_xml_node_get_int (tree, "default_saver_priority", &(psfs->default_saver_priority)))
psfs->default_saver_priority = -1;
(void)go_xml_node_get_enum
(tree, "save_scope",
GO_TYPE_FILE_SAVE_SCOPE, &scope);
psfs->save_scope = (GOFileSaveScope)scope;
if (!go_xml_node_get_bool (tree, "overwrite_files", &(psfs->overwrite_files)))
psfs->overwrite_files = TRUE;
} else {
*ret_error = go_error_info_new_str (_("File saver has no description"));
}
}
static void
gplp_set_attributes (GOPluginLoader *loader, GHashTable *attrs, GOErrorInfo **ret_error)
{
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar *module_name = NULL;
GO_INIT_RET_ERROR_INFO (ret_error);
module_name = g_hash_table_lookup (attrs, "module_name");
if (module_name != NULL) {
loader_python->module_name = g_strdup (module_name);
} else {
*ret_error = go_error_info_new_str (
_("Python module name not given."));
}
}
static void
gplp_unload_service_function_group (GOPluginLoader *loader,
GOPluginService *service,
GOErrorInfo **ret_error)
{
ServiceLoaderDataFunctionGroup *loader_data;
g_return_if_fail (GNM_IS_PYTHON_PLUGIN_LOADER (loader));
g_return_if_fail (GNM_IS_PLUGIN_SERVICE_FUNCTION_GROUP (service));
GO_INIT_RET_ERROR_INFO (ret_error);
loader_data = g_object_get_data (G_OBJECT (service), "loader_data");
SWITCH_TO_PLUGIN (go_plugin_service_get_plugin (service));
Py_DECREF (loader_data->python_fn_info_dict);
}
static void
go_plugin_service_resource_read_xml (GOPluginService *service, xmlNode *tree, GOErrorInfo **ret_error)
{
GOPluginServiceResource *sr = GO_PLUGIN_SERVICE_RESOURCE (service);
char *data = NULL;
gsize length;
xmlChar *file;
GO_INIT_RET_ERROR_INFO (ret_error);
sr->id = xml2c (go_xml_node_get_cstr (tree, "id"));
if (!sr->id)
goto error;
file = go_xml_node_get_cstr (tree, "file");
if (file) {
char *absfile;
gboolean ok;
if (!g_path_is_absolute (CXML2C (file))) {
char const *dir = go_plugin_get_dir_name
(go_plugin_service_get_plugin (service));
absfile = g_build_filename (dir, CXML2C (file), NULL);
} else
absfile = g_strdup (CXML2C (file));
xmlFree (file);
ok = g_file_get_contents (absfile, &data, &length, NULL);
g_free (absfile);
if (!ok)
goto error;
} else {
data = xml2c (go_xml_node_get_cstr (tree, "data"));
length = strlen (data);
}
if (!data)
goto error;
/* No encoding case */
sr->value = g_string_sized_new (length);
g_string_append_len (sr->value, data, length);
g_free (data);
return;
error:
*ret_error = go_error_info_new_str (_("Invalid resource service"));
g_free (data);
}
static void
go_plugin_service_general_deactivate (GOPluginService *service, GOErrorInfo **ret_error)
{
GOPluginServiceGeneral *service_general = GO_PLUGIN_SERVICE_GENERAL (service);
GOErrorInfo *error = NULL;
GO_INIT_RET_ERROR_INFO (ret_error);
g_return_if_fail (service_general->cbs.plugin_func_cleanup != NULL);
service_general->cbs.plugin_func_cleanup (service, &error);
if (error != NULL) {
*ret_error = go_error_info_new_str_with_details (
_("Cleanup function inside plugin returned error."),
error);
return;
}
service->is_active = FALSE;
}
GOPluginService *
go_plugin_service_new (GOPlugin *plugin, xmlNode *tree, GOErrorInfo **ret_error)
{
GOPluginService *service = NULL;
char *type_str;
GOErrorInfo *service_error = NULL;
GOPluginServiceCreate ctor;
g_return_val_if_fail (GO_IS_PLUGIN (plugin), NULL);
g_return_val_if_fail (tree != NULL, NULL);
g_return_val_if_fail (strcmp (tree->name, "service") == 0, NULL);
GO_INIT_RET_ERROR_INFO (ret_error);
type_str = go_xml_node_get_cstr (tree, "type");
if (type_str == NULL) {
*ret_error = go_error_info_new_str (_("No \"type\" attribute on \"service\" element."));
return NULL;
}
ctor = g_hash_table_lookup (services, type_str);
if (ctor == NULL) {
*ret_error = go_error_info_new_printf (_("Unknown service type: %s."), type_str);
xmlFree (type_str);
return NULL;
}
xmlFree (type_str);
service = g_object_new (ctor(), NULL);
service->plugin = plugin;
service->id = xml2c (go_xml_node_get_cstr (tree, "id"));
if (service->id == NULL)
service->id = xmlStrdup ("default");
if (GO_PLUGIN_SERVICE_GET_CLASS (service)->read_xml != NULL) {
GO_PLUGIN_SERVICE_GET_CLASS (service)->read_xml (service, tree, &service_error);
if (service_error != NULL) {
*ret_error = go_error_info_new_str_with_details (
_("Error reading service information."), service_error);
g_object_unref (service);
service = NULL;
}
}
return service;
}
void
go_plugin_service_unload (GOPluginService *service, GOErrorInfo **ret_error)
{
GOErrorInfo *error = NULL;
g_return_if_fail (GO_IS_PLUGIN_SERVICE (service));
GO_INIT_RET_ERROR_INFO (ret_error);
if (!service->is_loaded) {
return;
}
go_plugin_unload_service (service->plugin, service, &error);
if (error == NULL) {
service->is_loaded = FALSE;
} else {
*ret_error = error;
}
}
static void
go_plugin_service_file_saver_activate (GOPluginService *service, GOErrorInfo **ret_error)
{
GOPluginServiceFileSaver *service_file_saver = GO_PLUGIN_SERVICE_FILE_SAVER (service);
GHashTable *file_savers_hash;
GO_INIT_RET_ERROR_INFO (ret_error);
service_file_saver->saver = GO_FILE_SAVER (go_plugin_file_saver_new (service));
if (service_file_saver->default_saver_priority < 0) {
go_file_saver_register (service_file_saver->saver);
} else {
go_file_saver_register_as_default (service_file_saver->saver,
service_file_saver->default_saver_priority);
}
file_savers_hash = get_plugin_file_savers_hash (service->plugin);
g_assert (g_hash_table_lookup (file_savers_hash, service->id) == NULL);
g_hash_table_insert (file_savers_hash, g_strdup (service->id), service_file_saver->saver);
service->is_active = TRUE;
}
void
go_plugin_service_deactivate (GOPluginService *service, GOErrorInfo **ret_error)
{
g_return_if_fail (GO_IS_PLUGIN_SERVICE (service));
GO_INIT_RET_ERROR_INFO (ret_error);
if (!service->is_active) {
return;
}
GO_PLUGIN_SERVICE_GET_CLASS (service)->deactivate (service, ret_error);
if (*ret_error == NULL) {
GOErrorInfo *ignored_error = NULL;
service->is_active = FALSE;
/* FIXME */
go_plugin_service_unload (service, &ignored_error);
go_error_info_free (ignored_error);
}
}
GType
go_plugin_service_plugin_loader_generate_type (GOPluginService *service,
GOErrorInfo **ret_error)
{
GOPluginServicePluginLoader *service_plugin_loader = GO_PLUGIN_SERVICE_PLUGIN_LOADER (service);
GOErrorInfo *error = NULL;
GType loader_type;
GO_INIT_RET_ERROR_INFO (ret_error);
go_plugin_service_load (service, &error);
if (error == NULL) {
loader_type = service_plugin_loader->cbs.plugin_func_get_loader_type (
service, &error);
if (error == NULL)
return loader_type;
*ret_error = error;
} else {
*ret_error = go_error_info_new_str_with_details (
_("Error while loading plugin service."),
error);
}
return G_TYPE_NONE;
}
static void
go_plugin_service_general_activate (GOPluginService *service, GOErrorInfo **ret_error)
{
GOPluginServiceGeneral *service_general = GO_PLUGIN_SERVICE_GENERAL (service);
GOErrorInfo *error = NULL;
GO_INIT_RET_ERROR_INFO (ret_error);
go_plugin_service_load (service, &error);
if (error != NULL) {
*ret_error = go_error_info_new_str_with_details (
_("Error while loading plugin service."),
error);
return;
}
g_return_if_fail (service_general->cbs.plugin_func_init != NULL);
service_general->cbs.plugin_func_init (service, &error);
if (error != NULL) {
*ret_error = go_error_info_new_str_with_details (
_("Initializing function inside plugin returned error."),
error);
return;
}
service->is_active = TRUE;
}
void
go_plugin_service_activate (GOPluginService *service, GOErrorInfo **ret_error)
{
g_return_if_fail (GO_IS_PLUGIN_SERVICE (service));
GO_INIT_RET_ERROR_INFO (ret_error);
if (service->is_active) {
return;
}
#ifdef PLUGIN_ALWAYS_LOAD
{
GOErrorInfo *load_error = NULL;
go_plugin_service_load (service, &load_error);
if (load_error != NULL) {
*ret_error = go_error_info_new_str_with_details (
_("We must load service before activating it (PLUGIN_ALWAYS_LOAD is set) "
"but loading failed."), load_error);
return;
}
}
#endif
GO_PLUGIN_SERVICE_GET_CLASS (service)->activate (service, ret_error);
}
G_MODULE_EXPORT GType
python_get_loader_type (GOErrorInfo **ret_error)
{
GO_INIT_RET_ERROR_INFO (ret_error);
return TYPE_GNM_PYTHON_PLUGIN_LOADER;
}
static void
gplp_load_base (GOPluginLoader *loader, GOErrorInfo **ret_error)
{
static gchar const *python_file_extensions[] = {"py", "pyc", "pyo", NULL};
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar const **file_ext;
GnmPython *py_object;
GnmPyInterpreter *py_interpreter_info;
gchar *full_module_file_name = NULL;
FILE *f;
GOPlugin *plugin = go_plugin_loader_get_plugin (loader);
GOErrorInfo *open_error = NULL;
PyObject *modules, *main_module, *main_module_dict;
GO_INIT_RET_ERROR_INFO (ret_error);
g_object_set_data (G_OBJECT (plugin), "python-loader", loader);
py_object = gnm_python_object_get (ret_error);
if (py_object == NULL)
return; /* gnm_python_object_get sets ret_error */
py_interpreter_info = gnm_python_new_interpreter (py_object, plugin);
if (py_interpreter_info == NULL) {
*ret_error = go_error_info_new_str (_("Cannot create new Python interpreter."));
gnm_python_clear_error_if_needed (py_object);
g_object_unref (py_object);
return;
}
for (file_ext = python_file_extensions; *file_ext != NULL; file_ext++) {
gchar *file_name = g_strconcat (
loader_python->module_name, ".", *file_ext, NULL);
gchar *path = g_build_filename (
go_plugin_get_dir_name (plugin),
file_name, NULL);
g_free (file_name);
if (g_file_test (path, G_FILE_TEST_EXISTS)) {
full_module_file_name = path;
break;
} else
g_free (path);
}
if (full_module_file_name == NULL) {
*ret_error = go_error_info_new_printf (
_("Module \"%s\" doesn't exist."),
loader_python->module_name);
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
f = gnumeric_fopen_error_info (full_module_file_name, "r", &open_error);
g_free (full_module_file_name);
if (f == NULL) {
*ret_error = open_error;
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
if (PyRun_SimpleFile (f, loader_python->module_name) != 0) {
(void) fclose (f);
*ret_error = go_error_info_new_printf (
_("Execution of module \"%s\" failed."),
loader_python->module_name);
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
(void) fclose (f);
modules = PyImport_GetModuleDict ();
g_return_if_fail (modules != NULL);
main_module = PyDict_GetItemString (modules, (char *) "__main__");
g_return_if_fail (main_module != NULL);
main_module_dict = PyModule_GetDict (main_module);
g_return_if_fail (main_module_dict != NULL);
loader_python->py_object = py_object;
loader_python->py_interpreter_info = py_interpreter_info;
loader_python->main_module = main_module;
loader_python->main_module_dict = main_module_dict;
}
static void
go_plugin_service_file_opener_read_xml (GOPluginService *service, xmlNode *tree, GOErrorInfo **ret_error)
{
int priority;
gboolean has_probe;
gboolean encoding_dependent;
xmlNode *information_node;
gchar *description;
GO_INIT_RET_ERROR_INFO (ret_error);
if (go_xml_node_get_int (tree, "priority", &priority))
priority = CLAMP (priority, 0, 100);
else
priority = 50;
if (!go_xml_node_get_bool (tree, "probe", &has_probe))
has_probe = TRUE;
if (!go_xml_node_get_bool (tree, "encoding_dependent", &encoding_dependent))
encoding_dependent = FALSE;
information_node = go_xml_get_child_by_name (tree, "information");
if (information_node != NULL) {
xmlNode *node = go_xml_get_child_by_name_by_lang
(information_node, "description");
description = node ? xml2c (xmlNodeGetContent (node)) : NULL;
} else {
description = NULL;
}
if (description != NULL) {
GSList *suffixes = NULL, *mimes = NULL;
xmlNode *list, *node;
GOPluginServiceFileOpener *service_file_opener = GO_PLUGIN_SERVICE_FILE_OPENER (service);
list = go_xml_get_child_by_name (tree, "suffixes");
if (list != NULL) {
for (node = list->xmlChildrenNode; node != NULL; node = node->next) {
char *tmp;
if (strcmp (node->name, "suffix"))
continue;
tmp = xml2c (xmlNodeGetContent (node));
if (!tmp)
continue;
GO_SLIST_PREPEND (suffixes, tmp);
}
}
GO_SLIST_REVERSE (suffixes);
list = go_xml_get_child_by_name (tree, "mime-types");
if (list != NULL) {
for (node = list->xmlChildrenNode; node != NULL; node = node->next) {
char *tmp;
if (strcmp (node->name, "mime-type"))
continue;
tmp = xml2c (xmlNodeGetContent (node));
if (!tmp)
continue;
GO_SLIST_PREPEND (mimes, tmp);
}
}
GO_SLIST_REVERSE (mimes);
service_file_opener->priority = priority;
service_file_opener->has_probe = has_probe;
service_file_opener->encoding_dependent = encoding_dependent;
service_file_opener->description = description;
service_file_opener->suffixes = suffixes;
service_file_opener->mimes = mimes;
} else {
*ret_error = go_error_info_new_str (_("File opener has no description"));
}
}
