diff options
Diffstat (limited to 'plugin-loaders/python')
| -rwxr-xr-x | plugin-loaders/python/Makefile.am | 36 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/Makefile.am | 115 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/gedit.defs | 1461 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/gedit.override | 461 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditcommands.defs | 45 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditcommands.override | 122 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditmessage.override | 556 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditplugin.override | 193 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditutils.defs | 67 | ||||
| -rwxr-xr-x | plugin-loaders/python/bindings/geditutils.override | 85 | ||||
| -rwxr-xr-x | plugin-loaders/python/gedit-plugin-loader-python.c | 719 | ||||
| -rwxr-xr-x | plugin-loaders/python/gedit-plugin-loader-python.h | 61 | ||||
| -rwxr-xr-x | plugin-loaders/python/gedit-plugin-python.c | 281 | ||||
| -rwxr-xr-x | plugin-loaders/python/gedit-plugin-python.h | 88 |
14 files changed, 4290 insertions, 0 deletions
diff --git a/plugin-loaders/python/Makefile.am b/plugin-loaders/python/Makefile.am new file mode 100755 index 00000000..174d57dc --- /dev/null +++ b/plugin-loaders/python/Makefile.am @@ -0,0 +1,36 @@ +# C plugin loader + +SUBDIRS = bindings +loaderdir = $(libdir)/gedit-2/plugin-loaders + +INCLUDES = \ + -I$(top_srcdir) \ + -I$(top_builddir) \ + -I$(top_srcdir)/gedit \ + -I$(top_builddir)/gedit \ + $(GEDIT_CFLAGS) \ + $(WARN_CFLAGS) \ + $(DISABLE_DEPRECATED_CFLAGS) \ + $(PYGTK_CFLAGS) \ + $(PYTHON_CFLAGS) \ + -DGEDIT_PLUGINS_LIBS_DIR=\"$(GEDIT_PLUGINS_LIBS_DIR)\" \ + -DGEDIT_LOCALEDIR=\""$(prefix)/$(DATADIRNAME)/locale"\" + +loader_LTLIBRARIES = libpythonloader.la + + +NOINST_H_FILES = \ + gedit-plugin-loader-python.h \ + gedit-plugin-python.h + +libpythonloader_la_SOURCES = \ + gedit-plugin-loader-python.c \ + gedit-plugin-python.c \ + $(NOINST_H_FILES) + +libpythonloader_la_LDFLAGS = $(LOADER_LIBTOOL_FLAGS) +libpythonloader_la_LIBADD = \ + $(GEDIT_LIBS) \ + bindings/gedit.la + +-include $(top_srcdir)/git.mk diff --git a/plugin-loaders/python/bindings/Makefile.am b/plugin-loaders/python/bindings/Makefile.am new file mode 100755 index 00000000..47183a55 --- /dev/null +++ b/plugin-loaders/python/bindings/Makefile.am @@ -0,0 +1,115 @@ +## Process this file with automake to produce Makefile.in + +noinst_LTLIBRARIES = \ + gedit.la + +nodist_gedit_la_SOURCES = \ + gedit.c \ + geditutils.c \ + geditcommands.c + +gedit_la_LDFLAGS = \ + -module -avoid-version + +gedit_la_LIBADD = \ + $(PYTHON_LIB_LOC) \ + $(PYTHON_LIBS) \ + $(PYTHON_EXTRA_LIBS) \ + $(PYGTK_LIBS) + +gedit_la_CFLAGS = \ + -I$(top_srcdir) \ + -I$(top_builddir) \ + -I$(top_srcdir)/gedit \ + -I$(top_builddir)/gedit \ + -I$(top_srcdir)/plugin-loaders/python \ + -I$(top_builddir)/plugin-loaders/python \ + $(GEDIT_CFLAGS) \ + $(NO_STRICT_ALIASING_CFLAGS) \ + $(PYGTK_CFLAGS) \ + $(PYTHON_CFLAGS) \ + $(AM_CFLAGS) + +$(top_builddir)/gedit/gedit-enum-types.h: + cd $(top_builddir)/gedit && $(MAKE) gedit-enum-types.h + +gedit.c: gedit.defs gedit.override geditplugin.override geditmessage.override $(top_builddir)/gedit/gedit-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) ) > $@ + +geditutils.c: geditutils.defs geditutils.override + ( cd $(srcdir) && $(PYGTK_CODEGEN) \ + --override $*.override \ + --prefix py$* $(<F) ) > $@ + +geditcommands.c: geditcommands.defs geditcommands.override gedit.defs + ( cd $(srcdir) && $(PYGTK_CODEGEN) \ + --register gedit.defs \ + --register $(PYGTK_DEFSDIR)/gtk-types.defs \ + --override $*.override \ + --prefix py$* $(<F) ) > $@ + +BINDING_GEDIT_HEADERS_SRCDIR_IN = \ + gedit/gedit-app.h \ + gedit/gedit-document.h \ + gedit/gedit-encodings.h \ + gedit/gedit-plugin.h \ + plugin-loaders/python/gedit-plugin-python.h \ + gedit/gedit-view.h \ + gedit/gedit-statusbar.h \ + gedit/gedit-tab.h \ + gedit/gedit-panel.h \ + gedit/gedit-window.h \ + gedit/gedit-help.h \ + gedit/gedit-debug.h \ + gedit/gedit-message-type.h \ + gedit/gedit-message.h \ + gedit/gedit-message-bus.h \ + gedit/gedit-language-manager.h + +BINDING_UTILS_HEADERS_SRCDIR_IN = \ + gedit/gedit-utils.h + +BINDING_COMMANDS_HEADERS_SRCDIR_IN = \ + gedit/gedit-commands.h + +BINDING_HEADERS_BUILDDIR_IN = + +BINDING_GEDIT_HEADERS_SRCDIR := $(addprefix $(top_srcdir)/,$(BINDING_GEDIT_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_GEDIT_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > gedit.defs.new + $(PYGTK_H2DEF) $(sort $(BINDING_UTILS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > geditutils.defs.new + $(PYGTK_H2DEF) $(sort $(BINDING_COMMANDS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > geditcommands.defs.new + +BUILT_SOURCES = \ + gedit.c \ + geditutils.c \ + geditcommands.c + +EXTRA_DIST = \ + gedit.override \ + gedit.defs \ + geditutils.override \ + geditutils.defs \ + geditcommands.override \ + geditcommands.defs \ + geditmessage.override \ + geditplugin.override + +CLEANFILES = $(BUILT_SOURCES) + +dist-hook: + cd $(distdir); rm -f $(BUILT_SOURCES) + +-include $(top_srcdir)/git.mk diff --git a/plugin-loaders/python/bindings/gedit.defs b/plugin-loaders/python/bindings/gedit.defs new file mode 100755 index 00000000..1b116396 --- /dev/null +++ b/plugin-loaders/python/bindings/gedit.defs @@ -0,0 +1,1461 @@ +;; -*- scheme -*- +; object definitions ... +(define-object App + (in-module "Gedit") + (parent "GObject") + (c-name "GeditApp") + (gtype-id "GEDIT_TYPE_APP") +) + +(define-object Document + (in-module "Gedit") + (parent "GtkSourceBuffer") + (c-name "GeditDocument") + (gtype-id "GEDIT_TYPE_DOCUMENT") +) + +(define-object Message + (in-module "Gedit") + (parent "GObject") + (c-name "GeditMessage") + (gtype-id "GEDIT_TYPE_MESSAGE") +) + +(define-object MessageBus + (in-module "Gedit") + (parent "GObject") + (c-name "GeditMessageBus") + (gtype-id "GEDIT_TYPE_MESSAGE_BUS") +) + +(define-object Panel + (in-module "Gedit") + (parent "GtkVBox") + (c-name "GeditPanel") + (gtype-id "GEDIT_TYPE_PANEL") +) + +(define-object __Plugin + (in-module "Gedit") + (parent "GObject") + (c-name "GeditPlugin") + (gtype-id "GEDIT_TYPE_PLUGIN") +) + +(define-object Plugin + (in-module "Gedit") + (parent "GeditPlugin") + (c-name "GeditPluginPython") + (gtype-id "GEDIT_TYPE_PLUGIN_PYTHON") +) + +(define-object Statusbar + (in-module "Gedit") + (parent "GtkStatusbar") + (c-name "GeditStatusbar") + (gtype-id "GEDIT_TYPE_STATUSBAR") +) + +(define-object Tab + (in-module "Gedit") + (parent "GtkVBox") + (c-name "GeditTab") + (gtype-id "GEDIT_TYPE_TAB") +) + +(define-object View + (in-module "Gedit") + (parent "GtkSourceView") + (c-name "GeditView") + (gtype-id "GEDIT_TYPE_VIEW") +) + +(define-object Window + (in-module "Gedit") + (parent "GtkWindow") + (c-name "GeditWindow") + (gtype-id "GEDIT_TYPE_WINDOW") +) + +;; Enumerations and flags ... + +(define-flags LockdownMask + (in-module "Gedit") + (c-name "GeditLockdownMask") + (gtype-id "GEDIT_TYPE_LOCKDOWN_MASK") + (values + '("command-line" "GEDIT_LOCKDOWN_COMMAND_LINE") + '("printing" "GEDIT_LOCKDOWN_PRINTING") + '("print-setup" "GEDIT_LOCKDOWN_PRINT_SETUP") + '("save-to-disk" "GEDIT_LOCKDOWN_SAVE_TO_DISK") + '("all" "GEDIT_LOCKDOWN_ALL") + ) +) + +(define-flags SearchFlags + (in-module "Gedit") + (c-name "GeditSearchFlags") + (gtype-id "GEDIT_TYPE_SEARCH_FLAGS") + (values + '("dont-set-flags" "GEDIT_SEARCH_DONT_SET_FLAGS") + '("entire-word" "GEDIT_SEARCH_ENTIRE_WORD") + '("case-sensitive" "GEDIT_SEARCH_CASE_SENSITIVE") + ) +) + +(define-flags DocumentSaveFlags + (in-module "Gedit") + (c-name "GeditDocumentSaveFlags") + (gtype-id "GEDIT_TYPE_DOCUMENT_SAVE_FLAGS") + (values + '("ignore-mtime" "GEDIT_DOCUMENT_SAVE_IGNORE_MTIME") + '("ignore-backup" "GEDIT_DOCUMENT_SAVE_IGNORE_BACKUP") + '("preserve-backup" "GEDIT_DOCUMENT_SAVE_PRESERVE_BACKUP") + ) +) + +(define-enum TabState + (in-module "Gedit") + (c-name "GeditTabState") + (gtype-id "GEDIT_TYPE_TAB_STATE") + (values + '("normal" "GEDIT_TAB_STATE_NORMAL") + '("loading" "GEDIT_TAB_STATE_LOADING") + '("reverting" "GEDIT_TAB_STATE_REVERTING") + '("saving" "GEDIT_TAB_STATE_SAVING") + '("printing" "GEDIT_TAB_STATE_PRINTING") + '("print-previewing" "GEDIT_TAB_STATE_PRINT_PREVIEWING") + '("showing-print-preview" "GEDIT_TAB_STATE_SHOWING_PRINT_PREVIEW") + '("generic-not-editable" "GEDIT_TAB_STATE_GENERIC_NOT_EDITABLE") + '("loading-error" "GEDIT_TAB_STATE_LOADING_ERROR") + '("reverting-error" "GEDIT_TAB_STATE_REVERTING_ERROR") + '("saving-error" "GEDIT_TAB_STATE_SAVING_ERROR") + '("generic-error" "GEDIT_TAB_STATE_GENERIC_ERROR") + '("closing" "GEDIT_TAB_STATE_CLOSING") + ) +) + +(define-flags WindowState + (in-module "Gedit") + (c-name "GeditWindowState") + (gtype-id "GEDIT_TYPE_WINDOW_STATE") + (values + '("normal" "GEDIT_WINDOW_STATE_NORMAL") + '("saving" "GEDIT_WINDOW_STATE_SAVING") + '("printing" "GEDIT_WINDOW_STATE_PRINTING") + '("loading" "GEDIT_WINDOW_STATE_LOADING") + '("error" "GEDIT_WINDOW_STATE_ERROR") + '("saving-session" "GEDIT_WINDOW_STATE_SAVING_SESSION") + ) +) + +;; Boxed types +(define-boxed Encoding + (in-module "Gedit") + (c-name "GeditEncoding") + (gtype-id "GEDIT_TYPE_ENCODING") + (copy-func "gedit_encoding_copy") + (release-func "gedit_encoding_free") +;; (fields +;; '("gint" "index") +;; '("gchar*" "charset") +;; '("gchar*" "name") +;; ) +) + +(define-boxed MessageType + (in-module "Gedit") + (c-name "GeditMessageType") + (gtype-id "GEDIT_TYPE_MESSAGE_TYPE") + (copy-func "gedit_message_type_ref") + (release-func "gedit_message_type_unref") +) + + +;; From ../../gedit/gedit-app.h + +(define-function gedit_app_get_type + (c-name "gedit_app_get_type") + (return-type "GType") +) + +(define-function app_get_default + (c-name "gedit_app_get_default") + (return-type "GeditApp*") +) + +; deprecated version ! +(define-function gedit_app_get_default + (c-name "gedit_app_get_default_deprecated") + (return-type "GeditApp*") +) + +(define-method create_window + (of-object "GeditApp") + (c-name "gedit_app_create_window") + (return-type "GeditWindow*") + (parameters + '("GdkScreen*" "screen") + ) +) + +(define-method get_windows + (of-object "GeditApp") + (c-name "gedit_app_get_windows") + (return-type "const-GList*") +) + +(define-method get_active_window + (of-object "GeditApp") + (c-name "gedit_app_get_active_window") + (return-type "GeditWindow*") +) + +(define-method get_documents + (of-object "GeditApp") + (c-name "gedit_app_get_documents") + (return-type "GList*") +) + +(define-method get_views + (of-object "GeditApp") + (c-name "gedit_app_get_views") + (return-type "GList*") +) + +(define-method get_lockdown + (of-object "GeditApp") + (c-name "gedit_app_get_lockdown") + (return-type "GeditLockdownMask") +) + + +;; From ../../gedit/gedit-document.h + +(define-function document_error_quark + (c-name "gedit_document_error_quark") + (return-type "GQuark") +) + +(define-function gedit_document_get_type + (c-name "gedit_document_get_type") + (return-type "GType") +) + +(define-function gedit_document_new + (c-name "gedit_document_new") + (is-constructor-of "GeditDocument") + (return-type "GeditDocument*") +) + +(define-method get_location + (of-object "GeditDocument") + (c-name "gedit_document_get_location") + (return-type "GFile*") +) + +(define-method get_uri + (of-object "GeditDocument") + (c-name "gedit_document_get_uri") + (return-type "gchar*") +) + +(define-method set_uri + (of-object "GeditDocument") + (c-name "gedit_document_set_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method get_uri_for_display + (of-object "GeditDocument") + (c-name "gedit_document_get_uri_for_display") + (return-type "gchar*") +) + +(define-method get_short_name_for_display + (of-object "GeditDocument") + (c-name "gedit_document_get_short_name_for_display") + (return-type "gchar*") +) + +(define-method get_content_type + (of-object "GeditDocument") + (c-name "gedit_document_get_content_type") + (return-type "gchar*") +) + +(define-method get_mime_type + (of-object "GeditDocument") + (c-name "gedit_document_get_mime_type") + (return-type "gchar*") +) + +(define-method get_readonly + (of-object "GeditDocument") + (c-name "gedit_document_get_readonly") + (return-type "gboolean") +) + +(define-method load + (of-object "GeditDocument") + (c-name "gedit_document_load") + (return-type "none") + (parameters + '("const-gchar*" "uri") + '("const-GeditEncoding*" "encoding") + '("gint" "line_pos") + '("gboolean" "create") + ) +) + +(define-method insert_file + (of-object "GeditDocument") + (c-name "gedit_document_insert_file") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "uri") + '("const-GeditEncoding*" "encoding") + ) +) + +(define-method load_cancel + (of-object "GeditDocument") + (c-name "gedit_document_load_cancel") + (return-type "gboolean") +) + +(define-method save + (of-object "GeditDocument") + (c-name "gedit_document_save") + (parameters + '("GeditDocumentSaveFlags" "flags") + ) + (return-type "none") +) + +(define-method save_as + (of-object "GeditDocument") + (c-name "gedit_document_save_as") + (return-type "none") + (parameters + '("const-gchar*" "uri") + '("const-GeditEncoding*" "encoding") + '("GeditDocumentSaveFlags" "flags") + ) +) + +(define-method is_untouched + (of-object "GeditDocument") + (c-name "gedit_document_is_untouched") + (return-type "gboolean") +) + +(define-method is_untitled + (of-object "GeditDocument") + (c-name "gedit_document_is_untitled") + (return-type "gboolean") +) + +(define-method is_local + (of-object "GeditDocument") + (c-name "gedit_document_is_local") + (return-type "gboolean") +) + +(define-method get_deleted + (of-object "GeditDocument") + (c-name "gedit_document_get_deleted") + (return-type "gboolean") +) + +(define-method goto_line + (of-object "GeditDocument") + (c-name "gedit_document_goto_line") + (return-type "gboolean") + (parameters + '("gint" "line") + ) +) + +(define-method set_search_text + (of-object "GeditDocument") + (c-name "gedit_document_set_search_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("guint" "flags") + ) +) + +(define-method get_search_text + (of-object "GeditDocument") + (c-name "gedit_document_get_search_text") + (return-type "gchar*") + (parameters + '("guint*" "flags") + ) +) + +(define-method get_can_search_again + (of-object "GeditDocument") + (c-name "gedit_document_get_can_search_again") + (return-type "gboolean") +) + +(define-method search_forward + (of-object "GeditDocument") + (c-name "gedit_document_search_forward") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + ) +) + +(define-method replace_all + (of-object "GeditDocument") + (c-name "gedit_document_replace_all") + (return-type "gint") + (parameters + '("const-gchar*" "find") + '("const-gchar*" "replace") + '("guint" "flags") + ) +) + +(define-method search_backward + (of-object "GeditDocument") + (c-name "gedit_document_search_backward") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "start") + '("const-GtkTextIter*" "end") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + ) +) + +(define-method set_language + (of-object "GeditDocument") + (c-name "gedit_document_set_language") + (return-type "none") + (parameters + '("GtkSourceLanguage*" "lang" (null-ok)) + ) +) + +(define-method get_language + (of-object "GeditDocument") + (c-name "gedit_document_get_language") + (return-type "GtkSourceLanguage*") +) + +(define-method get_encoding + (of-object "GeditDocument") + (c-name "gedit_document_get_encoding") + (return-type "const-GeditEncoding*") +) + +(define-method set_enable_search_highlighting + (of-object "GeditDocument") + (c-name "gedit_document_set_enable_search_highlighting") + (return-type "none") + (parameters + '("gboolean" "enable") + ) +) + +(define-method get_enable_search_highlighting + (of-object "GeditDocument") + (c-name "gedit_document_get_enable_search_highlighting") + (return-type "gboolean") +) + +;; From ../../gedit/gedit-encodings.h + +(define-function gedit_encoding_get_type + (c-name "gedit_encoding_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "GeditEncoding") + (c-name "gedit_encoding_copy") + (return-type "GeditEncoding*") +) + +(define-method free + (of-object "GeditEncoding") + (c-name "gedit_encoding_free") + (return-type "none") +) + +(define-function encoding_get_from_charset + (c-name "gedit_encoding_get_from_charset") + (return-type "const-GeditEncoding*") + (parameters + '("const-gchar*" "charset") + ) +) + +; Deprecated version ! +(define-function gedit_encoding_get_from_charset + (c-name "gedit_encoding_get_from_charset_deprecated") + (return-type "const-GeditEncoding*") + (parameters + '("const-gchar*" "charset") + ) +) + +(define-function encoding_get_from_index + (c-name "gedit_encoding_get_from_index") + (return-type "const-GeditEncoding*") + (parameters + '("gint" "index") + ) +) + +; Deprecated version ! +(define-function gedit_encoding_get_from_index + (c-name "gedit_encoding_get_from_index_deprecated") + (return-type "const-GeditEncoding*") + (parameters + '("gint" "index") + ) +) + +(define-method to_string + (of-object "GeditEncoding") + (c-name "gedit_encoding_to_string") + (return-type "gchar*") +) + +(define-method get_name + (of-object "GeditEncoding") + (c-name "gedit_encoding_get_name") + (return-type "const-gchar*") +) + +(define-method get_charset + (of-object "GeditEncoding") + (c-name "gedit_encoding_get_charset") + (return-type "const-gchar*") +) + +(define-function encoding_get_utf8 + (c-name "gedit_encoding_get_utf8") + (return-type "const-GeditEncoding*") +) + +; Deprecated version ! +(define-function gedit_encoding_get_utf8 + (c-name "gedit_encoding_get_utf8_deprecated") + (return-type "const-GeditEncoding*") +) + +(define-function encoding_get_current + (c-name "gedit_encoding_get_current") + (return-type "const-GeditEncoding*") +) + +; Deprecated version ! +(define-function gedit_encoding_get_current + (c-name "gedit_encoding_get_current_deprecated") + (return-type "const-GeditEncoding*") +) + +;; From ../../gedit/gedit-help.h + +(define-function help_display + (c-name "gedit_help_display") + (return-type "gboolean") + (parameters + '("GtkWindow*" "parent") + '("const-gchar*" "name") + '("const-gchar*" "link_id") + ) +) + + + +;; From ../../gedit/gedit-panel.h + +(define-function gedit_panel_get_type + (c-name "gedit_panel_get_type") + (return-type "GType") +) + +(define-function gedit_panel_new + (c-name "gedit_panel_new") + (is-constructor-of "GeditPanel") + (return-type "GtkWidget*") +) + +(define-method add_item + (of-object "GeditPanel") + (c-name "gedit_panel_add_item") + (return-type "none") + (parameters + '("GtkWidget*" "item") + '("const-gchar*" "name") + '("GtkWidget*" "image") + ) +) + +(define-method add_item_with_stock_icon + (of-object "GeditPanel") + (c-name "gedit_panel_add_item_with_stock_icon") + (return-type "none") + (parameters + '("GtkWidget*" "item") + '("const-gchar*" "name") + '("const-gchar*" "stock_id") + ) +) + +(define-method remove_item + (of-object "GeditPanel") + (c-name "gedit_panel_remove_item") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method activate_item + (of-object "GeditPanel") + (c-name "gedit_panel_activate_item") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method item_is_active + (of-object "GeditPanel") + (c-name "gedit_panel_item_is_active") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method get_orientation + (of-object "GeditPanel") + (c-name "gedit_panel_get_orientation") + (return-type "GtkOrientation") +) + +(define-method get_n_items + (of-object "GeditPanel") + (c-name "gedit_panel_get_n_items") + (return-type "gint") +) + + +;; From ../../gedit/gedit-plugin.h + +(define-function gedit_plugin_get_type + (c-name "gedit_plugin_get_type") + (return-type "GType") +) + +(define-method get_install_dir + (of-object "GeditPlugin") + (c-name "gedit_plugin_get_install_dir") + (return-type "gchar*") +) + +(define-method get_data_dir + (of-object "GeditPlugin") + (c-name "gedit_plugin_get_data_dir") + (return-type "gchar*") +) + +(define-method activate + (of-object "GeditPlugin") + (c-name "gedit_plugin_activate") + (return-type "none") + (parameters + '("GeditWindow*" "window") + ) +) + +(define-method deactivate + (of-object "GeditPlugin") + (c-name "gedit_plugin_deactivate") + (return-type "none") + (parameters + '("GeditWindow*" "window") + ) +) + +(define-method update_ui + (of-object "GeditPlugin") + (c-name "gedit_plugin_update_ui") + (return-type "none") + (parameters + '("GeditWindow*" "window") + ) +) + +(define-method is_configurable + (of-object "GeditPlugin") + (c-name "gedit_plugin_is_configurable") + (return-type "gboolean") +) + +(define-method create_configure_dialog + (of-object "GeditPlugin") + (c-name "gedit_plugin_create_configure_dialog") + (return-type "GtkWidget*") +) + +;; From ../gedit/gedit-plugin-python.h + +(define-function gedit_plugin_python_get_type + (c-name "gedit_plugin_python_get_type") + (return-type "GType") +) + +(define-function gedit_plugin_python_new + (c-name "gedit_plugin_python_new") + (is-constructor-of "GeditPluginPython") + (return-type "GeditPluginPython*") +) + +;; From ../../gedit/gedit-status-bar.h + +(define-method flash_message + (of-object "GeditStatusbar") + (c-name "gedit_statusbar_flash_message") + (return-type "none") + (parameters + '("int" "context_id") + '("const-gchar*" "message") + ) + ) + +;; From ../../gedit/gedit-tab.h + +(define-function gedit_tab_get_type + (c-name "gedit_tab_get_type") + (return-type "GType") +) + +(define-method get_view + (of-object "GeditTab") + (c-name "gedit_tab_get_view") + (return-type "GeditView*") +) + +(define-method get_document + (of-object "GeditTab") + (c-name "gedit_tab_get_document") + (return-type "GeditDocument*") +) + +(define-function tab_get_from_document + (c-name "gedit_tab_get_from_document") + (return-type "GeditTab*") + (parameters + '("GeditDocument*" "doc") + ) +) + +; Deprecated version ! +(define-function gedit_tab_get_from_document + (c-name "gedit_tab_get_from_document_deprecated") + (return-type "GeditTab*") + (parameters + '("GeditDocument*" "doc") + ) +) + +(define-method get_state + (of-object "GeditTab") + (c-name "gedit_tab_get_state") + (return-type "GeditTabState") +) + +(define-method set_auto_save_enabled + (of-object "GeditTab") + (c-name "gedit_tab_set_auto_save_enabled") + (return-type "none") + (parameters + '("gboolean" "enable") + ) +) + +(define-method get_auto_save_enabled + (of-object "GeditTab") + (c-name "gedit_tab_get_auto_save_enabled") + (return-type "gboolean") +) + +(define-method set_auto_save_interval + (of-object "GeditTab") + (c-name "gedit_tab_set_auto_save_interval") + (return-type "none") + (parameters + '("gint" "interval") + ) +) + +(define-method get_auto_save_interval + (of-object "GeditTab") + (c-name "gedit_tab_get_auto_save_interval") + (return-type "gint") +) + +;; From ../../gedit/gedit-view.h + +(define-function gedit_view_get_type + (c-name "gedit_view_get_type") + (return-type "GtkType") +) + +(define-function gedit_view_new + (c-name "gedit_view_new") + (is-constructor-of "GeditView") + (return-type "GtkWidget*") + (parameters + '("GeditDocument*" "doc") + ) +) + +(define-method cut_clipboard + (of-object "GeditView") + (c-name "gedit_view_cut_clipboard") + (return-type "none") +) + +(define-method copy_clipboard + (of-object "GeditView") + (c-name "gedit_view_copy_clipboard") + (return-type "none") +) + +(define-method paste_clipboard + (of-object "GeditView") + (c-name "gedit_view_paste_clipboard") + (return-type "none") +) + +(define-method delete_selection + (of-object "GeditView") + (c-name "gedit_view_delete_selection") + (return-type "none") +) + +(define-method select_all + (of-object "GeditView") + (c-name "gedit_view_select_all") + (return-type "none") +) + +(define-method scroll_to_cursor + (of-object "GeditView") + (c-name "gedit_view_scroll_to_cursor") + (return-type "none") +) + +(define-method set_font + (of-object "GeditView") + (c-name "gedit_view_set_font") + (return-type "none") + (parameters + '("gboolean" "def") + '("const-gchar*" "font_name") + ) +) + + + +;; From ../../gedit/gedit-window.h + +(define-function gedit_window_get_type + (c-name "gedit_window_get_type") + (return-type "GType") +) + +(define-method create_tab + (of-object "GeditWindow") + (c-name "gedit_window_create_tab") + (return-type "GeditTab*") + (parameters + '("gboolean" "jump_to") + ) +) + +(define-method create_tab_from_uri + (of-object "GeditWindow") + (c-name "gedit_window_create_tab_from_uri") + (return-type "GeditTab*") + (parameters + '("const-gchar*" "uri") + '("const-GeditEncoding*" "encoding" (null-ok)) + '("gint" "line_pos") + '("gboolean" "create") + '("gboolean" "jump_to") + ) +) + +(define-method close_tab + (of-object "GeditWindow") + (c-name "gedit_window_close_tab") + (return-type "none") + (parameters + '("GeditTab*" "tab") + ) +) + +(define-method close_tabs + (of-object "GeditWindow") + (c-name "gedit_window_close_tabs") + (return-type "none") + (parameters + '("const-GList*" "tabs") + ) +) + +(define-method close_all_tabs + (of-object "GeditWindow") + (c-name "gedit_window_close_all_tabs") + (return-type "none") +) + +(define-method get_active_tab + (of-object "GeditWindow") + (c-name "gedit_window_get_active_tab") + (return-type "GeditTab*") +) + +(define-method set_active_tab + (of-object "GeditWindow") + (c-name "gedit_window_set_active_tab") + (return-type "none") + (parameters + '("GeditTab*" "tab") + ) +) + +(define-method get_active_view + (of-object "GeditWindow") + (c-name "gedit_window_get_active_view") + (return-type "GeditView*") +) + +(define-method get_active_document + (of-object "GeditWindow") + (c-name "gedit_window_get_active_document") + (return-type "GeditDocument*") +) + +(define-method get_documents + (of-object "GeditWindow") + (c-name "gedit_window_get_documents") + (return-type "GList*") +) + +(define-method get_unsaved_documents + (of-object "GeditWindow") + (c-name "gedit_window_get_unsaved_documents") + (return-type "GList*") +) + +(define-method get_views + (of-object "GeditWindow") + (c-name "gedit_window_get_views") + (return-type "GList*") +) + +(define-method get_group + (of-object "GeditWindow") + (c-name "gedit_window_get_group") + (return-type "GtkWindowGroup*") +) + +(define-method get_side_panel + (of-object "GeditWindow") + (c-name "gedit_window_get_side_panel") + (return-type "GeditPanel*") +) + +(define-method get_bottom_panel + (of-object "GeditWindow") + (c-name "gedit_window_get_bottom_panel") + (return-type "GeditPanel*") +) + +(define-method get_statusbar + (of-object "GeditWindow") + (c-name "gedit_window_get_statusbar") + (return-type "GtkWidget*") +) + +(define-method get_ui_manager + (of-object "GeditWindow") + (c-name "gedit_window_get_ui_manager") + (return-type "GtkUIManager*") +) + +(define-method get_state + (of-object "GeditWindow") + (c-name "gedit_window_get_state") + (return-type "GeditWindowState") +) + +(define-method get_message_bus + (of-object "GeditWindow") + (c-name "gedit_window_get_message_bus") + (return-type "GeditMessageBus*") +) + +(define-method get_tab_from_uri + (of-object "GeditWindow") + (c-name "gedit_window_get_tab_from_uri") + (return-type "GeditTab*") + (parameters + '("const-gchar*" "uri") + ) +) + +;; From gedit-language-manager.h + +(define-function get_language_manager + (c-name "gedit_get_language_manager") + (return-type "GtkSourceLanguageManager*") +) + +(define-function language_manager_list_languages_sorted + (c-name "gedit_language_manager_list_languages_sorted") + (return-type "GSList*") + (parameters + '("GtkSourceLanguageManager*" "lm") + '("gboolean" "include_hidden") + ) +) + + +;; From gedit-message-bus.h + +(define-function gedit_message_bus_get_type + (c-name "gedit_message_bus_get_type") + (return-type "GType") +) + +(define-function message_bus_get_default + (c-name "gedit_message_bus_get_default") + (return-type "GeditMessageBus*") +) + +(define-function gedit_message_bus_new + (c-name "gedit_message_bus_new") + (is-constructor-of "GeditMessageBus") + (return-type "GeditMessageBus*") +) + +(define-method lookup + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_lookup") + (return-type "GeditMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-method register + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_register") + (return-type "GeditMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + ) + (varargs #t) +) + +(define-method unregister + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_unregister") + (return-type "none") + (parameters + '("GeditMessageType*" "message_type") + ) +) + +(define-method unregister_all + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_unregister_all") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + ) +) + +(define-method is_registered + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_is_registered") + (return-type "gboolean") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-method connect + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_connect") + (return-type "guint") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("GeditMessageCallback" "callback") + '("gpointer" "userdata") + '("GDestroyNotify" "destroy_data") + ) +) + +(define-method disconnect + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_disconnect") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method disconnect_by_func + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_disconnect_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("GeditMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method block + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_block") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method block_by_func + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_block_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("GeditMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method unblock + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_unblock") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method unblock_by_func + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_unblock_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("GeditMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method send_message + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_send_message") + (return-type "none") + (parameters + '("GeditMessage*" "message") + ) +) + +(define-method send_message_sync + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_send_message_sync") + (return-type "none") + (parameters + '("GeditMessage*" "message") + ) +) + +(define-method send + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_send") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) + (varargs #t) +) + +(define-method send_sync + (of-object "GeditMessageBus") + (c-name "gedit_message_bus_send_sync") + (return-type "GeditMessage*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) + (varargs #t) +) + + +;; From gedit-message-type.h + +(define-function gedit_message_type_get_type + (c-name "gedit_message_type_get_type") + (return-type "GType") +) + +(define-function gedit_message_type_is_supported + (c-name "gedit_message_type_is_supported") + (return-type "gboolean") + (parameters + '("GType" "type") + ) +) + +(define-function gedit_message_type_identifier + (c-name "gedit_message_type_identifier") + (return-type "gchar*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-function gedit_message_type_new + (c-name "gedit_message_type_new") + (is-constructor-of "GeditMessageType") + (return-type "GeditMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + ) + (varargs #t) +) + +(define-function gedit_message_type_new_valist + (c-name "gedit_message_type_new_valist") + (return-type "GeditMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + '("va_list" "va_args") + ) +) + +(define-method ref + (of-object "GeditMessageType") + (c-name "gedit_message_type_ref") + (return-type "GeditMessageType*") +) + +(define-method unref + (of-object "GeditMessageType") + (c-name "gedit_message_type_unref") + (return-type "none") +) + +(define-method instantiate_valist + (of-object "GeditMessageType") + (c-name "gedit_message_type_instantiate_valist") + (return-type "GeditMessage*") + (parameters + '("va_list" "va_args") + ) +) + +(define-method instantiate + (of-object "GeditMessageType") + (c-name "gedit_message_type_instantiate") + (return-type "GeditMessage*") + (parameters + ) + (varargs #t) +) + +(define-method get_object_path + (of-object "GeditMessageType") + (c-name "gedit_message_type_get_object_path") + (return-type "const-gchar*") +) + +(define-method get_method + (of-object "GeditMessageType") + (c-name "gedit_message_type_get_method") + (return-type "const-gchar*") +) + +(define-method lookup + (of-object "GeditMessageType") + (c-name "gedit_message_type_lookup") + (return-type "GType") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method foreach + (of-object "GeditMessageType") + (c-name "gedit_message_type_foreach") + (return-type "none") + (parameters + '("GeditMessageTypeForeach" "func") + '("gpointer" "user_data") + ) +) + + +;; From gedit-message.h + +(define-function gedit_message_get_type + (c-name "gedit_message_get_type") + (return-type "GType") +) + +(define-method get + (of-object "GeditMessage") + (c-name "gedit_message_get") + (return-type "none") + (parameters + ) + (varargs #t) +) + +(define-method get_valist + (of-object "GeditMessage") + (c-name "gedit_message_get_valist") + (return-type "none") + (parameters + '("va_list" "var_args") + ) +) + +(define-method get_value + (of-object "GeditMessage") + (c-name "gedit_message_get_value") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("GValue*" "value") + ) +) + +(define-method set + (of-object "GeditMessage") + (c-name "gedit_message_set") + (return-type "none") + (parameters + ) + (varargs #t) +) + +(define-method set_valist + (of-object "GeditMessage") + (c-name "gedit_message_set_valist") + (return-type "none") + (parameters + '("va_list" "var_args") + ) +) + +(define-method set_value + (of-object "GeditMessage") + (c-name "gedit_message_set_value") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("GValue*" "value") + ) +) + +(define-method set_valuesv + (of-object "GeditMessage") + (c-name "gedit_message_set_valuesv") + (return-type "none") + (parameters + '("const-gchar**" "keys") + '("GValue*" "values") + '("gint" "n_values") + ) +) + +(define-method get_object_path + (of-object "GeditMessage") + (c-name "gedit_message_get_object_path") + (return-type "const-gchar*") +) + +(define-method get_method + (of-object "GeditMessage") + (c-name "gedit_message_get_method") + (return-type "const-gchar*") +) + +(define-method has_key + (of-object "GeditMessage") + (c-name "gedit_message_has_key") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method get_key_type + (of-object "GeditMessage") + (c-name "gedit_message_get_key_type") + (return-type "GType") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method validate + (of-object "GeditMessage") + (c-name "gedit_message_validate") + (return-type "gboolean") +) + + +;; From ../../gedit/gedit-debug.h + +(define-function debug + (c-name "gedit_debug") + (parameters + '("const-gchar*" "message") + ) + (return-type "none") +) + diff --git a/plugin-loaders/python/bindings/gedit.override b/plugin-loaders/python/bindings/gedit.override new file mode 100755 index 00000000..52c492a4 --- /dev/null +++ b/plugin-loaders/python/bindings/gedit.override @@ -0,0 +1,461 @@ +%% +headers +#include <pygobject.h> +#include <pygtk/pygtk.h> + +#include <gedit/gedit-language-manager.h> +#include <gedit/gedit-plugin.h> +#include <gedit/gedit-app.h> +#include <gedit/gedit-encodings.h> +#include <gedit/gedit-enum-types.h> +#include <gedit/gedit-statusbar.h> +#include <gedit/gedit-debug.h> +#include <gedit/gedit-help.h> + +#include "gedit-plugin-python.h" + +void pygedit_register_classes (PyObject *d); +void pygedit_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 + geditplugin.override + geditmessage.override +%% +modulename gedit +%% +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 + gedit_document_error_quark + gedit_panel_add_item_with_stock_icon +%% +override gedit_app_create_window kwargs +static PyObject * +_wrap_gedit_app_create_window(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "screen", NULL}; + PyGObject *screen = NULL; + GeditWindow *ret; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "|O!", kwlist, + &PyGdkScreen_Type, &screen)) + return NULL; + + ret = gedit_app_create_window(GEDIT_APP(self->obj), + screen ? GDK_SCREEN(screen->obj) : NULL); + + /* pygobject_new handles NULL checking */ + return pygobject_new((GObject *)ret); +} +%% +override gedit_app_get_windows +static PyObject * +_wrap_gedit_app_get_windows(PyGObject *self) +{ + const GList *list; + PyObject *py_list; + + list = gedit_app_get_windows (GEDIT_APP (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + return py_list; +} +%% +override gedit_app_get_views +static PyObject * +_wrap_gedit_app_get_views(PyGObject *self) +{ + GList *list; + PyObject *py_list; + + list = gedit_app_get_views (GEDIT_APP (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + g_list_free (list); + + return py_list; +} +%% +override gedit_app_get_documents +static PyObject * +_wrap_gedit_app_get_documents(PyGObject *self) +{ + GList *list; + PyObject *py_list; + + list = gedit_app_get_documents (GEDIT_APP (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + g_list_free (list); + + return py_list; +} +%% +override gedit_window_get_documents +static PyObject * +_wrap_gedit_window_get_documents(PyGObject *self) +{ + GList *list; + PyObject *py_list; + + list = gedit_window_get_documents (GEDIT_WINDOW (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + g_list_free(list); + + return py_list; +} +%% +override gedit_window_get_unsaved_documents +static PyObject * +_wrap_gedit_window_get_unsaved_documents(PyGObject *self) +{ + GList *list; + PyObject *py_list; + + list = gedit_window_get_unsaved_documents (GEDIT_WINDOW (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + g_list_free(list); + + return py_list; +} +%% +override gedit_window_get_views +static PyObject * +_wrap_gedit_window_get_views(PyGObject *self) +{ + GList *list; + PyObject *py_list; + + list = gedit_window_get_views (GEDIT_WINDOW (self->obj)); + + py_list = _helper_wrap_gobject_glist (list); + + g_list_free(list); + + return py_list; +} +%% +override gedit_window_close_tabs kwargs +static PyObject * +_wrap_gedit_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:GeditWindow.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, &PyGeditTab_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)); + } + + gedit_window_close_tabs (GEDIT_WINDOW (self->obj), glist); + + g_list_free (glist); + Py_INCREF (Py_None); + return Py_None; +} +%% +override gedit_document_get_search_text +static PyObject * +_wrap_gedit_document_get_search_text(PyGObject *self) +{ + PyObject *tuple, *string; + guint flags; + gchar *ret; + + ret = gedit_document_get_search_text (GEDIT_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 gedit_panel_add_item kwargs +static PyObject * +_wrap_gedit_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!:GeditPanel.add_item", kwlist1, &PyGtkWidget_Type, &item, &name, &PyGtkImage_Type, &image)) { + gedit_panel_add_item(GEDIT_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:GeditPanel.add_item", kwlist2, &PyGtkWidget_Type, &item, &name, &stock_id)) { + gedit_panel_add_item_with_stock_icon(GEDIT_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 gedit_app_get_default_deprecated +/* deprecated wrappers */ +static PyObject * +_wrap_gedit_app_get_default_deprecated(PyObject *self) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.app_get_default instead") < 0) + return NULL; + return _wrap_gedit_app_get_default(self); +} +%% +override gedit_encoding_get_from_charset_deprecated kwargs +static PyObject * +_wrap_gedit_encoding_get_from_charset_deprecated(PyObject *self, PyObject *args, PyObject *kwargs) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_from_charset instead") < 0) + return NULL; + return _wrap_gedit_encoding_get_from_charset(self, args, kwargs); +} +%% +override gedit_encoding_get_from_index_deprecated kwargs +static PyObject * +_wrap_gedit_encoding_get_from_index_deprecated(PyObject *self, PyObject *args, PyObject *kwargs) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_from_index instead") < 0) + return NULL; + return _wrap_gedit_encoding_get_from_index(self, args, kwargs); +} +%% +override gedit_encoding_get_utf8_deprecated +static PyObject * +_wrap_gedit_encoding_get_utf8_deprecated(PyObject *self) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_utf8 instead") < 0) + return NULL; + return _wrap_gedit_encoding_get_utf8(self); +} +%% +override gedit_encoding_get_current_deprecated +static PyObject * +_wrap_gedit_encoding_get_current_deprecated(PyObject *self) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_current instead") < 0) + return NULL; + return _wrap_gedit_encoding_get_current(self); +} +%% +override gedit_tab_get_from_document_deprecated kwargs +static PyObject * +_wrap_gedit_tab_get_from_document_deprecated(PyObject *self, PyObject *args, PyObject *kwargs) +{ + if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.tab_get_from_document instead") < 0) + return NULL; + return _wrap_gedit_tab_get_from_document(self, args, kwargs); +} +%% +override gedit_language_manager_list_languages_sorted kwargs +static PyObject * +_wrap_gedit_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 = gedit_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 gedit_debug kwargs +static PyObject * +_wrap_gedit_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 ("GEDIT_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) + gedit_debug (GEDIT_DEBUG_PLUGINS, + PyString_AsString (filename), + PyInt_AsLong (lineno), + PyString_AsString (funcname)); + else + gedit_debug_message (GEDIT_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 gedit_statusbar_flash_message kwargs +static PyObject * +_wrap_gedit_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:GeditStatusbar.flash_message", kwlist, &context_id, &message)) + return NULL; + + gedit_statusbar_flash_message(GEDIT_STATUSBAR(self->obj), context_id, "%s", message); + + Py_INCREF(Py_None); + return Py_None; +} +%% diff --git a/plugin-loaders/python/bindings/geditcommands.defs b/plugin-loaders/python/bindings/geditcommands.defs new file mode 100755 index 00000000..3808fa43 --- /dev/null +++ b/plugin-loaders/python/bindings/geditcommands.defs @@ -0,0 +1,45 @@ +;; -*- scheme -*- +; object definitions ... +;; Enumerations and flags ... + + +;; From ../../gedit/gedit-commands.h + +(define-function load_uri + (c-name "gedit_commands_load_uri") + (return-type "none") + (parameters + '("GeditWindow*" "window") + '("const-gchar*" "uri") + '("const-GeditEncoding*" "encoding") + '("gint" "line_pos") + ) +) + +(define-function load_uris + (c-name "gedit_commands_load_uris") + (return-type "gint") + (parameters + '("GeditWindow*" "window") + '("const-GSList*" "uris") + '("const-GeditEncoding*" "encoding") + '("gint" "line_pos") + ) +) + +(define-function save_document + (c-name "gedit_commands_save_document") + (return-type "none") + (parameters + '("GeditWindow*" "window") + '("GeditDocument*" "document") + ) +) + +(define-function save_all_documents + (c-name "gedit_commands_save_all_documents") + (return-type "none") + (parameters + '("GeditWindow*" "window") + ) +) diff --git a/plugin-loaders/python/bindings/geditcommands.override b/plugin-loaders/python/bindings/geditcommands.override new file mode 100755 index 00000000..a81f9181 --- /dev/null +++ b/plugin-loaders/python/bindings/geditcommands.override @@ -0,0 +1,122 @@ +%% +headers +#define NO_IMPORT_PYGOBJECT +#define NO_IMPORT_PYGTK +#include <pygobject.h> +#include <pygtk/pygtk.h> + +#include "gedit-commands.h" +#include "gedit-window.h" + +void pygeditcommands_register_classes (PyObject *d); +void pygeditcommands_add_constants (PyObject *module, const gchar *strip_prefix); + +%% +modulename gedit.commands +%% +import gedit.Window as PyGeditWindow_Type +import gedit.Document as PyGeditDocument_Type +%% +ignore-glob + _* +%% +override gedit_commands_load_uri kwargs +static PyObject * +_wrap_gedit_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; + GeditEncoding *encoding = NULL; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!s|Oi:load_uri", + kwlist, &PyGeditWindow_Type, + &window, &uri, &py_encoding, + &line_pos)) + return NULL; + + if (py_encoding != NULL && py_encoding != Py_None) + { + if (pyg_boxed_check (py_encoding, GEDIT_TYPE_ENCODING)) + encoding = pyg_boxed_get (py_encoding, GeditEncoding); + else + { + PyErr_SetString (PyExc_TypeError, + "encoding should be a GeditEncoding"); + return NULL; + } + } + + gedit_commands_load_uri (GEDIT_WINDOW (window->obj), uri, encoding, + line_pos); + Py_INCREF (Py_None); + return Py_None; +} +%% +override gedit_commands_load_uris kwargs +static PyObject * +_wrap_gedit_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; + GeditEncoding *encoding = NULL; + int len; + int i; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!O|Oi:load_uri", + kwlist, &PyGeditWindow_Type, + &window, &list, &py_encoding, + &line_pos)) + return NULL; + + if (py_encoding != NULL && py_encoding != Py_None) + { + if (pyg_boxed_check (py_encoding, GEDIT_TYPE_ENCODING)) + encoding = pyg_boxed_get (py_encoding, GeditEncoding); + else { + PyErr_SetString (PyExc_TypeError, + "encoding should be a GeditEncoding"); + 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); + gedit_commands_load_uris (GEDIT_WINDOW (window->obj), uris, + encoding, line_pos); + g_slist_free (uris); + + Py_INCREF (Py_None); + return Py_None; +} diff --git a/plugin-loaders/python/bindings/geditmessage.override b/plugin-loaders/python/bindings/geditmessage.override new file mode 100755 index 00000000..244d60ce --- /dev/null +++ b/plugin-loaders/python/bindings/geditmessage.override @@ -0,0 +1,556 @@ +%% +headers + +#include <gedit/gedit-message-bus.h> +#include <gedit/gedit-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(GeditMessage *message, PyObject *pykey, PyObject *pyvalue) +{ + gchar *key; + GType gtype; + GValue value = {0,}; + + key = _helper_wrap_get_string(pykey); + + if (key == NULL) + return 0; + + gtype = gedit_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; + } + + gedit_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, GeditMessage *message) +{ + _helper_wrap_message_set_value(message, key, value); +} + +static void +_helper_message_set_values(GeditMessage *message, PyObject *args, PyObject *kwargs) +{ + _helper_parse_pairs(args, kwargs, (ParsePairFunc)_helper_message_set, message); +} + +static GeditMessage * +_helper_wrap_create_message(GeditMessageBus *bus, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *pydict; + + if (!PyArg_ParseTuple(args, "OO|O:GeditMessage.create", &pypath, &pymethod, &pydict)) + return NULL; + + gchar *object_path = _helper_wrap_get_string(pypath); + gchar *method = _helper_wrap_get_string(pymethod); + + GeditMessageType *message_type = gedit_message_bus_lookup (bus, object_path, method); + GeditMessage *message; + + if (message_type) + { + message = gedit_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; +} PyGeditCustomNotify; + +static void +pygedit_custom_destroy_notify(gpointer user_data) +{ + PyGeditCustomNotify *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 + gedit_message_type_foreach + gedit_message_type_instantiate_valist + gedit_message_type_new_valist + gedit_message_get_valist + gedit_message_set_valist + gedit_message_set_valuesv + gedit_message_bus_disconnect_by_func + gedit_message_bus_block_by_func + gedit_message_bus_unblock_by_func +%% +override gedit_message_type_new kwargs + +typedef struct +{ + GeditMessageType *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); + + gedit_message_type_set(info->message_type, optional, k, gtype, NULL); + g_free(k); +} + +static int +_wrap_gedit_message_type_new(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *optional = NULL, *pydict; + + if (!PyArg_ParseTuple(args, "OO|OO:GeditMessageType.new", &pypath, &pymethod, &optional, &pydict)) + return -1; + + GeditMessageType *message_type = GEDIT_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 gedit_message_type_instantiate kwargs +static PyObject * +_wrap_gedit_message_type_instantiate(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + GeditMessageType *message_type = GEDIT_MESSAGE_TYPE (self->obj); + GeditMessage *message = gedit_message_type_instantiate(message_type, NULL); + + _helper_message_set_values(message, args, kwargs); + + return pygobject_new((GObject *)message); +} +%% +override gedit_message_get args +static PyObject * +_wrap_gedit_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; + } + + gedit_message_get_value (GEDIT_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 gedit_message_get_value kwargs +static PyObject * +_wrap_gedit_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:GeditMessage.get_value", kwlist, &key)) + return NULL; + + gedit_message_get_value(GEDIT_MESSAGE(self->obj), key, &value); + ret = pyg_value_as_pyobject(&value, TRUE); + g_value_unset(&value); + + return ret; +} +%% +override gedit_message_set_value kwargs +static PyObject * +_wrap_gedit_message_set_value(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "key", "value", NULL }; + PyObject *pykey, *pyvalue; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeditMessage.set_value", kwlist, &pykey, &pyvalue)) + return NULL; + + if (!_helper_wrap_message_set_value(GEDIT_MESSAGE(self->obj), pykey, pyvalue)) + return NULL; + + Py_INCREF(Py_None); + return Py_None; +} +%% +override gedit_message_set kwargs +static PyObject * +_wrap_gedit_message_set (PyGObject *self, PyObject *args, PyObject *kwargs) { + _helper_message_set_values(GEDIT_MESSAGE(self->obj), args, kwargs); + + Py_INCREF(Py_None); + return Py_None; +} +%% +override gedit_message_bus_new +static int +_wrap_gedit_message_bus_new(PyGObject *self) +{ + pygobject_construct (self, NULL); + + if (!self->obj) { + PyErr_SetString (PyExc_RuntimeError, "could not create gedit.MessageBus object"); + return -1; + } + + return 0; +} +%% +new-constructor GEDIT_TYPE_MESSAGE_BUS +%% +override gedit_message_bus_register kwargs +static PyObject * +_wrap_gedit_message_bus_register(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + PyObject *pypath, *pymethod, *optional = NULL, *pydict; + GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj); + + if (!PyArg_ParseTuple(args, "OO|OO:GeditMessageBus.register", &pypath, &pymethod, &optional, &pydict)) + return NULL; + + gchar *object_path = _helper_wrap_get_string(pypath); + gchar *method = _helper_wrap_get_string(pymethod); + + GeditMessageType *message_type = gedit_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(GEDIT_TYPE_MESSAGE_TYPE, message_type, TRUE, TRUE); +} +%% +override gedit_message_bus_connect kwargs +static void +pygedit_message_bus_connect_cb(GeditMessageBus *bus, GeditMessage *message, gpointer data) +{ + PyGILState_STATE state; + PyGeditCustomNotify *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_gedit_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; + PyGeditCustomNotify *cunote; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "ssO|O:GeditMessageBus.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(PyGeditCustomNotify, 1); + Py_INCREF(pyfunc); + cunote->func = pyfunc; + Py_XINCREF(pyarg); + cunote->data = pyarg; + + guint id = gedit_message_bus_connect(GEDIT_MESSAGE_BUS(self->obj), + domain, + name, + pygedit_message_bus_connect_cb, + (gpointer)cunote, + pygedit_custom_destroy_notify); + return PyLong_FromUnsignedLong(id); +} +%% +override gedit_message_bus_send kwargs +static PyObject * +_wrap_gedit_message_bus_send(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + /* create a new message object */ + GeditMessage *message; + GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj); + message = _helper_wrap_create_message(bus, args, kwargs); + + if (!message) + return NULL; + + gedit_message_bus_send_message(bus, message); + g_object_unref (message); + + Py_INCREF(Py_None); + return Py_None; +} +%% +override gedit_message_bus_send_sync kwargs +static PyObject * +_wrap_gedit_message_bus_send_sync(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + /* create a new message object */ + GeditMessage *message; + GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj); + + message = _helper_wrap_create_message(bus, args, kwargs); + + if (!message) + return NULL; + + gedit_message_bus_send_message_sync(bus, message); + return pygobject_new((GObject *)message); +} +%% +override-slot GeditMessage.tp_getattro +static PyObject * +_wrap_gedit_message_tp_getattro(PyObject *self, PyObject *attrname) +{ + GeditMessage *message = GEDIT_MESSAGE(((PyGObject *)self)->obj); + GeditMessageType *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 = gedit_message_type_lookup (type, name) != G_TYPE_INVALID; + gedit_message_type_unref (type); + + exists = gedit_message_has_key (message, name); + + if (!intype) + { + ret = PyObject_GenericGetAttr(self, attrname); + } + else if (exists) + { + GValue value = { 0, }; + gedit_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 GeditMessage.tp_setattro +static int +_wrap_gedit_message_tp_setattro(PyObject *self, PyObject *attrname, PyObject *value) +{ + GeditMessage *message = GEDIT_MESSAGE(((PyGObject *)self)->obj); + + if (!_helper_wrap_message_set_value(message, attrname, value)) + { + return PyObject_GenericSetAttr(self, attrname, value); + } + else + { + return 1; + } +} diff --git a/plugin-loaders/python/bindings/geditplugin.override b/plugin-loaders/python/bindings/geditplugin.override new file mode 100755 index 00000000..178ea997 --- /dev/null +++ b/plugin-loaders/python/bindings/geditplugin.override @@ -0,0 +1,193 @@ +%% +headers +#include <gedit/gedit-plugin.h> +#include <gedit/gedit-window.h> +%% +override gedit_plugin_activate kwargs +static PyObject * +_wrap_gedit_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!:GeditPlugin.activate", + kwlist, + &PyGeditWindow_Type, + &window)) + return NULL; + + klass = g_type_class_ref (pyg_type_from_object (cls)); + + if (GEDIT_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 (GEDIT_PLUGIN_CLASS (klass)->activate) + GEDIT_PLUGIN_CLASS (klass)->activate (GEDIT_PLUGIN (self->obj), + GEDIT_WINDOW (window->obj)); + else { + PyErr_SetString (PyExc_NotImplementedError, + "virtual method GeditPlugin.activate not implemented"); + g_type_class_unref (klass); + return NULL; + } + + g_type_class_unref (klass); + Py_INCREF(Py_None); + return Py_None; +} + +%% +override gedit_plugin_deactivate kwargs +static PyObject * +_wrap_gedit_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!:GeditPlugin.deactivate", + kwlist, + &PyGeditWindow_Type, + &window)) + return NULL; + + klass = g_type_class_ref (pyg_type_from_object (cls)); + + if (GEDIT_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 (GEDIT_PLUGIN_CLASS (klass)->deactivate) + GEDIT_PLUGIN_CLASS (klass)->deactivate (GEDIT_PLUGIN (self->obj), + GEDIT_WINDOW (window->obj)); + else { + PyErr_SetString (PyExc_NotImplementedError, + "virtual method GeditPlugin.deactivate not implemented"); + g_type_class_unref (klass); + return NULL; + } + + g_type_class_unref (klass); + Py_INCREF(Py_None); + return Py_None; +} + +%% +override gedit_plugin_update_ui kwargs +static PyObject * +_wrap_gedit_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!:GeditPlugin.update_ui", + kwlist, + &PyGeditWindow_Type, + &window)) + return NULL; + + klass = g_type_class_ref (pyg_type_from_object (cls)); + + if (GEDIT_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 (GEDIT_PLUGIN_CLASS (klass)->update_ui) + GEDIT_PLUGIN_CLASS (klass)->update_ui (GEDIT_PLUGIN (self->obj), + GEDIT_WINDOW (window->obj)); + else { + PyErr_SetString (PyExc_NotImplementedError, + "virtual method GeditPlugin.update_ui not implemented"); + g_type_class_unref (klass); + return NULL; + } + + g_type_class_unref (klass); + Py_INCREF(Py_None); + return Py_None; +} + +%% +override gedit_plugin_is_configurable +static PyObject * +_wrap_gedit_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 (GEDIT_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 (GEDIT_PLUGIN_CLASS (klass)->is_configurable) + ret = GEDIT_PLUGIN_CLASS (klass)->is_configurable (GEDIT_PLUGIN (self->obj)); + else { + PyErr_SetString (PyExc_NotImplementedError, + "virtual method GeditPlugin.is_configurable not implemented"); + g_type_class_unref (klass); + return NULL; + } + + g_type_class_unref (klass); + return PyBool_FromLong (ret); +} + +%% +override gedit_plugin_configure_dialog +static PyObject * +_wrap_gedit_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 (GEDIT_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 (GEDIT_PLUGIN_CLASS (klass)->create_configure_dialog) + ret = GEDIT_PLUGIN_CLASS (klass)->create_configure_dialog (GEDIT_PLUGIN (self->obj)); + else { + PyErr_SetString (PyExc_NotImplementedError, + "virtual method GeditPlugin.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); +} diff --git a/plugin-loaders/python/bindings/geditutils.defs b/plugin-loaders/python/bindings/geditutils.defs new file mode 100755 index 00000000..3482f21c --- /dev/null +++ b/plugin-loaders/python/bindings/geditutils.defs @@ -0,0 +1,67 @@ +;; -*- scheme -*- + +;; From ../../gedit/gedit-utils.h + +(define-function uri_has_writable_scheme + (c-name "gedit_utils_uri_has_writable_scheme") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function uri_has_file_scheme + (c-name "gedit_utils_uri_has_file_scheme") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function uri_exists + (c-name "gedit_utils_uri_exists") + (return-type "gboolean") + (parameters + '("const-gchar*" "text_uri") + ) +) + +(define-function uri_is_valid + (c-name "gedit_utils_is_valid_uri") + (return-type "gboolean") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-function uri_get_dirname + (c-name "gedit_utils_uri_get_dirname") + (return-type "gchar*") + (parameters + '("const-char*" "uri") + ) +) + +(define-function menu_position_under_widget + (c-name "gedit_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 "gedit_utils_menu_position_under_tree_view") + (return-type "none") + (parameters + '("GtkMenu*" "menu") + '("gint*" "x") + '("gint*" "y") + '("gboolean*" "push_in") + '("gpointer" "user_data") + ) +) diff --git a/plugin-loaders/python/bindings/geditutils.override b/plugin-loaders/python/bindings/geditutils.override new file mode 100755 index 00000000..a7bf7fbe --- /dev/null +++ b/plugin-loaders/python/bindings/geditutils.override @@ -0,0 +1,85 @@ +%% +headers +#define NO_IMPORT_PYGOBJECT +#define NO_IMPORT_PYGTK +#include <pygobject.h> +#include <pygtk/pygtk.h> + +#include "gedit-utils.h" + +void pygeditutils_register_classes (PyObject *d); +void pygeditutils_add_constants (PyObject *module, const gchar *strip_prefix); + +%% +modulename gedit.utils +%% +import gtk.Widget as PyGtkWidget_Type +import gtk.TreeView as PyGtkTreeView_Type +import gtk.Menu as PyGtkMenu_Type +%% +ignore-glob + _* +%% +override gedit_utils_menu_position_under_widget kwargs +static PyObject * +_wrap_gedit_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)); + + gedit_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 gedit_utils_menu_position_under_tree_view kwargs +static PyObject * +_wrap_gedit_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)); + + gedit_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; +} diff --git a/plugin-loaders/python/gedit-plugin-loader-python.c b/plugin-loaders/python/gedit-plugin-loader-python.c new file mode 100755 index 00000000..7a9c8d18 --- /dev/null +++ b/plugin-loaders/python/gedit-plugin-loader-python.c @@ -0,0 +1,719 @@ +/* + * gedit-plugin-loader-python.c + * This file is part of gedit + * + * 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., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "gedit-plugin-loader-python.h" +#include "gedit-plugin-python.h" +#include <gedit/gedit-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 GEDIT_PLUGIN_LOADER_PYTHON_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE((object), GEDIT_TYPE_PLUGIN_LOADER_PYTHON, GeditPluginLoaderPythonPrivate)) + +struct _GeditPluginLoaderPythonPrivate +{ + GHashTable *loaded_plugins; + guint idle_gc; + gboolean init_failed; +}; + +typedef struct +{ + PyObject *type; + PyObject *instance; + gchar *path; +} PythonInfo; + +static void gedit_plugin_loader_iface_init (gpointer g_iface, gpointer iface_data); + +/* Exported by pygedit module */ +void pygedit_register_classes (PyObject *d); +void pygedit_add_constants (PyObject *module, const gchar *strip_prefix); +extern PyMethodDef pygedit_functions[]; + +/* Exported by pygeditutils module */ +void pygeditutils_register_classes (PyObject *d); +extern PyMethodDef pygeditutils_functions[]; + +/* Exported by pygeditcommands module */ +void pygeditcommands_register_classes (PyObject *d); +extern PyMethodDef pygeditcommands_functions[]; + +/* We retreive this to check for correct class hierarchy */ +static PyTypeObject *PyGeditPlugin_Type; + +GEDIT_PLUGIN_LOADER_REGISTER_TYPE (GeditPluginLoaderPython, gedit_plugin_loader_python, G_TYPE_OBJECT, gedit_plugin_loader_iface_init); + + +static PyObject * +find_python_plugin_type (GeditPluginInfo *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*) PyGeditPlugin_Type)) + return value; + } + + g_warning ("No GeditPlugin derivative found in Python plugin '%s'", + gedit_plugin_info_get_name (info)); + return NULL; +} + +static GeditPlugin * +new_plugin_from_info (GeditPluginLoaderPython *loader, + GeditPluginInfo *info) +{ + PythonInfo *pyinfo; + PyTypeObject *pytype; + PyObject *pyobject; + PyGObject *pygobject; + GeditPlugin *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.", gedit_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).", gedit_plugin_info_get_name (info)); + return NULL; + } + + pygobject_construct (pygobject, + "install-dir", pyinfo->path, + "data-dir-name", gedit_plugin_info_get_module_name (info), + NULL); + + if (pygobject->obj == NULL) + { + g_error ("Could not create instance for %s (GObject not constructed).", gedit_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 = GEDIT_PLUGIN (pygobject->obj); + pyinfo->instance = (PyObject *)pygobject; + + /* make sure to register the python instance for the GeditPluginPython + object to it can wrap the virtual gedit plugin funcs back to python */ + _gedit_plugin_python_set_instance (GEDIT_PLUGIN_PYTHON (instance), (PyObject *)pygobject); + + /* we return a reference here because the other is owned by python */ + return GEDIT_PLUGIN (g_object_ref (instance)); +} + +static GeditPlugin * +add_python_info (GeditPluginLoaderPython *loader, + GeditPluginInfo *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 * +gedit_plugin_loader_iface_get_id (void) +{ + return "Python"; +} + +static GeditPlugin * +gedit_plugin_loader_iface_load (GeditPluginLoader *loader, + GeditPluginInfo *info, + const gchar *path) +{ + GeditPluginLoaderPython *pyloader = GEDIT_PLUGIN_LOADER_PYTHON (loader); + PyObject *main_module, *main_locals, *pytype; + PyObject *pymodule, *fromlist; + gchar *module_name; + GeditPlugin *result; + + if (pyloader->priv->init_failed) + { + g_warning ("Cannot load python plugin Python '%s' since gedit was" + "not able to initialize the Python interpreter.", + gedit_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 ("gedit.plugins"); + if (main_module == NULL) + { + g_warning ("Could not get gedit.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 (gedit_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 +gedit_plugin_loader_iface_unload (GeditPluginLoader *loader, + GeditPluginInfo *info) +{ + GeditPluginLoaderPython *pyloader = GEDIT_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 (GeditPluginLoaderPython *loader) +{ + while (PyGC_Collect ()) + ; + + loader->priv->idle_gc = 0; + return FALSE; +} + +static void +gedit_plugin_loader_iface_garbage_collect (GeditPluginLoader *loader) +{ + GeditPluginLoaderPython *pyloader; + + if (!Py_IsInitialized()) + return; + + pyloader = GEDIT_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 +gedit_plugin_loader_iface_init (gpointer g_iface, + gpointer iface_data) +{ + GeditPluginLoaderInterface *iface = (GeditPluginLoaderInterface *)g_iface; + + iface->get_id = gedit_plugin_loader_iface_get_id; + iface->load = gedit_plugin_loader_iface_load; + iface->unload = gedit_plugin_loader_iface_unload; + iface->garbage_collect = gedit_plugin_loader_iface_garbage_collect; +} + +static void +gedit_python_shutdown (GeditPluginLoaderPython *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 +gedit_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 +gedit_init_pygobject (void) +{ + init_pygobject_check (2, 11, 5); /* FIXME: get from config */ +} + +static void +gedit_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 +gedit_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 +gedit_python_init (GeditPluginLoaderPython *loader) +{ + PyObject *mdict, *tuple; + PyObject *gedit, *geditutils, *geditcommands, *geditplugins; + PyObject *gettext, *install, *gettext_args; + //char *argv[] = { "gedit", NULL }; + char *argv[] = { GEDIT_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 (!gedit_check_pygtk2 ()) + { + /* Warning message already printed in check_pygtk2 */ + goto python_init_error; + } + + /* import gobject */ + gedit_init_pygobject (); + if (PyErr_Occurred ()) + { + g_warning ("Error initializing Python interpreter: could not import pygobject."); + + goto python_init_error; + } + + /* import gtk */ + gedit_init_pygtk (); + if (PyErr_Occurred ()) + { + g_warning ("Error initializing Python interpreter: could not import pygtk."); + + goto python_init_error; + } + + /* import gtksourceview */ + gedit_init_pygtksourceview (); + if (PyErr_Occurred ()) + { + PyErr_Print (); + + g_warning ("Error initializing Python interpreter: could not import pygtksourceview."); + + goto python_init_error; + } + + /* import gedit */ + gedit = Py_InitModule ("gedit", pygedit_functions); + mdict = PyModule_GetDict (gedit); + + pygedit_register_classes (mdict); + pygedit_add_constants (gedit, "GEDIT_"); + + /* gedit version */ + tuple = Py_BuildValue("(iii)", + GEDIT_MAJOR_VERSION, + GEDIT_MINOR_VERSION, + GEDIT_MICRO_VERSION); + PyDict_SetItemString(mdict, "version", tuple); + Py_DECREF(tuple); + + /* Retrieve the Python type for gedit.Plugin */ + PyGeditPlugin_Type = (PyTypeObject *) PyDict_GetItemString (mdict, "Plugin"); + if (PyGeditPlugin_Type == NULL) + { + PyErr_Print (); + + goto python_init_error; + } + + /* import gedit.utils */ + geditutils = Py_InitModule ("gedit.utils", pygeditutils_functions); + PyDict_SetItemString (mdict, "utils", geditutils); + + /* import gedit.commands */ + geditcommands = Py_InitModule ("gedit.commands", pygeditcommands_functions); + PyDict_SetItemString (mdict, "commands", geditcommands); + + /* initialize empty gedit.plugins module */ + geditplugins = Py_InitModule ("gedit.plugins", NULL); + PyDict_SetItemString (mdict, "plugins", geditplugins); + + mdict = PyModule_GetDict (geditutils); + pygeditutils_register_classes (mdict); + + mdict = PyModule_GetDict (geditcommands); + pygeditcommands_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, GEDIT_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 gedit and try again."); + + PyErr_Clear (); + + gedit_python_shutdown (loader); + + return FALSE; +} + +static void +gedit_plugin_loader_python_finalize (GObject *object) +{ + GeditPluginLoaderPython *pyloader = GEDIT_PLUGIN_LOADER_PYTHON (object); + + g_hash_table_destroy (pyloader->priv->loaded_plugins); + gedit_python_shutdown (pyloader); + + G_OBJECT_CLASS (gedit_plugin_loader_python_parent_class)->finalize (object); +} + +static void +gedit_plugin_loader_python_class_init (GeditPluginLoaderPythonClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gedit_plugin_loader_python_finalize; + + g_type_class_add_private (object_class, sizeof (GeditPluginLoaderPythonPrivate)); +} + +static void +gedit_plugin_loader_python_class_finalize (GeditPluginLoaderPythonClass *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 +gedit_plugin_loader_python_init (GeditPluginLoaderPython *self) +{ + self->priv = GEDIT_PLUGIN_LOADER_PYTHON_GET_PRIVATE (self); + + /* initialize python interpreter */ + gedit_python_init (self); + + /* loaded_plugins maps GeditPluginInfo to a PythonInfo */ + self->priv->loaded_plugins = g_hash_table_new_full (g_direct_hash, + g_direct_equal, + NULL, + (GDestroyNotify)destroy_python_info); +} + +GeditPluginLoaderPython * +gedit_plugin_loader_python_new () +{ + GObject *loader = g_object_new (GEDIT_TYPE_PLUGIN_LOADER_PYTHON, NULL); + + return GEDIT_PLUGIN_LOADER_PYTHON (loader); +} + diff --git a/plugin-loaders/python/gedit-plugin-loader-python.h b/plugin-loaders/python/gedit-plugin-loader-python.h new file mode 100755 index 00000000..35ae241c --- /dev/null +++ b/plugin-loaders/python/gedit-plugin-loader-python.h @@ -0,0 +1,61 @@ +/* + * gedit-plugin-loader-python.h + * This file is part of gedit + * + * 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., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GEDIT_PLUGIN_LOADER_PYTHON_H__ +#define __GEDIT_PLUGIN_LOADER_PYTHON_H__ + +#include <gedit/gedit-plugin-loader.h> + +G_BEGIN_DECLS + +#define GEDIT_TYPE_PLUGIN_LOADER_PYTHON (gedit_plugin_loader_python_get_type ()) +#define GEDIT_PLUGIN_LOADER_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEDIT_TYPE_PLUGIN_LOADER_PYTHON, GeditPluginLoaderPython)) +#define GEDIT_PLUGIN_LOADER_PYTHON_CONST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEDIT_TYPE_PLUGIN_LOADER_PYTHON, GeditPluginLoaderPython const)) +#define GEDIT_PLUGIN_LOADER_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEDIT_TYPE_PLUGIN_LOADER_PYTHON, GeditPluginLoaderPythonClass)) +#define GEDIT_IS_PLUGIN_LOADER_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEDIT_TYPE_PLUGIN_LOADER_PYTHON)) +#define GEDIT_IS_PLUGIN_LOADER_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_PLUGIN_LOADER_PYTHON)) +#define GEDIT_PLUGIN_LOADER_PYTHON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEDIT_TYPE_PLUGIN_LOADER_PYTHON, GeditPluginLoaderPythonClass)) + +typedef struct _GeditPluginLoaderPython GeditPluginLoaderPython; +typedef struct _GeditPluginLoaderPythonClass GeditPluginLoaderPythonClass; +typedef struct _GeditPluginLoaderPythonPrivate GeditPluginLoaderPythonPrivate; + +struct _GeditPluginLoaderPython { + GObject parent; + + GeditPluginLoaderPythonPrivate *priv; +}; + +struct _GeditPluginLoaderPythonClass { + GObjectClass parent_class; +}; + +GType gedit_plugin_loader_python_get_type (void) G_GNUC_CONST; +GeditPluginLoaderPython *gedit_plugin_loader_python_new(void); + +/* All the loaders must implement this function */ +G_MODULE_EXPORT GType register_gedit_plugin_loader (GTypeModule * module); + +G_END_DECLS + +#endif /* __GEDIT_PLUGIN_LOADER_PYTHON_H__ */ + diff --git a/plugin-loaders/python/gedit-plugin-python.c b/plugin-loaders/python/gedit-plugin-python.c new file mode 100755 index 00000000..0573828b --- /dev/null +++ b/plugin-loaders/python/gedit-plugin-python.c @@ -0,0 +1,281 @@ +/* + * gedit-plugin-python.c + * This file is part of gedit + * + * 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., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include <config.h> + +#include "gedit-plugin-python.h" + +#include <gedit/gedit-plugin.h> +#include <gedit/gedit-debug.h> +#include <pygobject.h> +#include <string.h> + +#define GEDIT_PLUGIN_PYTHON_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), GEDIT_TYPE_PLUGIN_PYTHON, GeditPluginPythonPrivate)) + +static GObjectClass *parent_class; + +struct _GeditPluginPythonPrivate +{ + PyObject *instance; +}; + +static void gedit_plugin_python_class_init (GeditPluginPythonClass *klass); +static void gedit_plugin_python_init (GeditPluginPython *plugin); + +G_DEFINE_TYPE (GeditPluginPython, gedit_plugin_python, GEDIT_TYPE_PLUGIN) + +static PyObject * +call_python_method (GeditPluginPythonPrivate *priv, + GeditWindow *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 (GeditPlugin *plugin, + GeditWindow *window) +{ + PyGILState_STATE state = pyg_gil_state_ensure (); + GeditPluginPythonPrivate *priv = GEDIT_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 + GEDIT_PLUGIN_CLASS (parent_class)->update_ui (plugin, window); + + pyg_gil_state_release (state); +} + +static void +impl_deactivate (GeditPlugin *plugin, + GeditWindow *window) +{ + PyGILState_STATE state = pyg_gil_state_ensure (); + GeditPluginPythonPrivate *priv = GEDIT_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 + GEDIT_PLUGIN_CLASS (parent_class)->deactivate (plugin, window); + + pyg_gil_state_release (state); +} + +static void +impl_activate (GeditPlugin *plugin, + GeditWindow *window) +{ + PyGILState_STATE state = pyg_gil_state_ensure (); + GeditPluginPythonPrivate *priv = GEDIT_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 + GEDIT_PLUGIN_CLASS (parent_class)->activate (plugin, window); + + pyg_gil_state_release (state); +} + +static GtkWidget * +impl_create_configure_dialog (GeditPlugin *plugin) +{ + PyGILState_STATE state = pyg_gil_state_ensure (); + GeditPluginPythonPrivate *priv = GEDIT_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 = GEDIT_PLUGIN_CLASS (parent_class)->create_configure_dialog (plugin); + + pyg_gil_state_release (state); + + return ret; +} + +static gboolean +impl_is_configurable (GeditPlugin *plugin) +{ + PyGILState_STATE state = pyg_gil_state_ensure (); + GeditPluginPythonPrivate *priv = GEDIT_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 +_gedit_plugin_python_set_instance (GeditPluginPython *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 * +_gedit_plugin_python_get_instance (GeditPluginPython *plugin) +{ + return plugin->priv->instance; +} + +static void +gedit_plugin_python_init (GeditPluginPython *plugin) +{ + plugin->priv = GEDIT_PLUGIN_PYTHON_GET_PRIVATE(plugin); + + gedit_debug_message (DEBUG_PLUGINS, "Creating Python plugin instance"); + plugin->priv->instance = 0; +} + +static void +gedit_plugin_python_finalize (GObject *object) +{ + PyGILState_STATE state; + + gedit_debug_message (DEBUG_PLUGINS, "Finalizing Python plugin instance"); + + state = pyg_gil_state_ensure (); + Py_XDECREF (GEDIT_PLUGIN_PYTHON(object)->priv->instance); + pyg_gil_state_release (state); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gedit_plugin_python_class_init (GeditPluginPythonClass *klass) +{ + GeditPluginClass *plugin_class = GEDIT_PLUGIN_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + g_type_class_add_private (klass, sizeof (GeditPluginPythonPrivate)); + G_OBJECT_CLASS (klass)->finalize = gedit_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; +} + diff --git a/plugin-loaders/python/gedit-plugin-python.h b/plugin-loaders/python/gedit-plugin-python.h new file mode 100755 index 00000000..e67584b0 --- /dev/null +++ b/plugin-loaders/python/gedit-plugin-python.h @@ -0,0 +1,88 @@ +/* + * gedit-plugin-python.h + * This file is part of gedit + * + * 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., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GEDIT_PLUGIN_PYTHON_H__ +#define __GEDIT_PLUGIN_PYTHON_H__ + +#define NO_IMPORT_PYGOBJECT + +#include <glib-object.h> +#include <pygobject.h> + +#include <gedit/gedit-plugin.h> + +G_BEGIN_DECLS + +/* + * Type checking and casting macros + */ +#define GEDIT_TYPE_PLUGIN_PYTHON (gedit_plugin_python_get_type()) +#define GEDIT_PLUGIN_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GEDIT_TYPE_PLUGIN_PYTHON, GeditPluginPython)) +#define GEDIT_PLUGIN_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GEDIT_TYPE_PLUGIN_PYTHON, GeditPluginPythonClass)) +#define GEDIT_IS_PLUGIN_PYTHON(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEDIT_TYPE_PLUGIN_PYTHON)) +#define GEDIT_IS_PLUGIN_PYTHON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEDIT_TYPE_PLUGIN_PYTHON)) +#define GEDIT_PLUGIN_PYTHON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GEDIT_TYPE_PLUGIN_PYTHON, GeditPluginPythonClass)) + +/* Private structure type */ +typedef struct _GeditPluginPythonPrivate GeditPluginPythonPrivate; + +/* + * Main object structure + */ +typedef struct _GeditPluginPython GeditPluginPython; + +struct _GeditPluginPython +{ + GeditPlugin parent; + + /*< private > */ + GeditPluginPythonPrivate *priv; +}; + +/* + * Class definition + */ +typedef struct _GeditPluginPythonClass GeditPluginPythonClass; + +struct _GeditPluginPythonClass +{ + GeditPluginClass parent_class; +}; + +/* + * Public methods + */ +GType gedit_plugin_python_get_type (void) G_GNUC_CONST; + + +/* + * Private methods + */ +void _gedit_plugin_python_set_instance (GeditPluginPython *plugin, + PyObject *instance); +PyObject *_gedit_plugin_python_get_instance (GeditPluginPython *plugin); + +G_END_DECLS + +#endif /* __GEDIT_PLUGIN_PYTHON_H__ */ + |