From 5ded9cba8563f336939400303d6a841d5089b107 Mon Sep 17 00:00:00 2001 From: Perberos Date: Mon, 7 Nov 2011 19:52:18 -0300 Subject: renaming from gedit to pluma --- plugin-loaders/python/bindings/pluma.defs | 1461 +++++++++++++++++++++++++++++ 1 file changed, 1461 insertions(+) create mode 100755 plugin-loaders/python/bindings/pluma.defs (limited to 'plugin-loaders/python/bindings/pluma.defs') diff --git a/plugin-loaders/python/bindings/pluma.defs b/plugin-loaders/python/bindings/pluma.defs new file mode 100755 index 00000000..f4e799f1 --- /dev/null +++ b/plugin-loaders/python/bindings/pluma.defs @@ -0,0 +1,1461 @@ +;; -*- scheme -*- +; object definitions ... +(define-object App + (in-module "Pluma") + (parent "GObject") + (c-name "PlumaApp") + (gtype-id "PLUMA_TYPE_APP") +) + +(define-object Document + (in-module "Pluma") + (parent "GtkSourceBuffer") + (c-name "PlumaDocument") + (gtype-id "PLUMA_TYPE_DOCUMENT") +) + +(define-object Message + (in-module "Pluma") + (parent "GObject") + (c-name "PlumaMessage") + (gtype-id "PLUMA_TYPE_MESSAGE") +) + +(define-object MessageBus + (in-module "Pluma") + (parent "GObject") + (c-name "PlumaMessageBus") + (gtype-id "PLUMA_TYPE_MESSAGE_BUS") +) + +(define-object Panel + (in-module "Pluma") + (parent "GtkVBox") + (c-name "PlumaPanel") + (gtype-id "PLUMA_TYPE_PANEL") +) + +(define-object __Plugin + (in-module "Pluma") + (parent "GObject") + (c-name "PlumaPlugin") + (gtype-id "PLUMA_TYPE_PLUGIN") +) + +(define-object Plugin + (in-module "Pluma") + (parent "PlumaPlugin") + (c-name "PlumaPluginPython") + (gtype-id "PLUMA_TYPE_PLUGIN_PYTHON") +) + +(define-object Statusbar + (in-module "Pluma") + (parent "GtkStatusbar") + (c-name "PlumaStatusbar") + (gtype-id "PLUMA_TYPE_STATUSBAR") +) + +(define-object Tab + (in-module "Pluma") + (parent "GtkVBox") + (c-name "PlumaTab") + (gtype-id "PLUMA_TYPE_TAB") +) + +(define-object View + (in-module "Pluma") + (parent "GtkSourceView") + (c-name "PlumaView") + (gtype-id "PLUMA_TYPE_VIEW") +) + +(define-object Window + (in-module "Pluma") + (parent "GtkWindow") + (c-name "PlumaWindow") + (gtype-id "PLUMA_TYPE_WINDOW") +) + +;; Enumerations and flags ... + +(define-flags LockdownMask + (in-module "Pluma") + (c-name "PlumaLockdownMask") + (gtype-id "PLUMA_TYPE_LOCKDOWN_MASK") + (values + '("command-line" "PLUMA_LOCKDOWN_COMMAND_LINE") + '("printing" "PLUMA_LOCKDOWN_PRINTING") + '("print-setup" "PLUMA_LOCKDOWN_PRINT_SETUP") + '("save-to-disk" "PLUMA_LOCKDOWN_SAVE_TO_DISK") + '("all" "PLUMA_LOCKDOWN_ALL") + ) +) + +(define-flags SearchFlags + (in-module "Pluma") + (c-name "PlumaSearchFlags") + (gtype-id "PLUMA_TYPE_SEARCH_FLAGS") + (values + '("dont-set-flags" "PLUMA_SEARCH_DONT_SET_FLAGS") + '("entire-word" "PLUMA_SEARCH_ENTIRE_WORD") + '("case-sensitive" "PLUMA_SEARCH_CASE_SENSITIVE") + ) +) + +(define-flags DocumentSaveFlags + (in-module "Pluma") + (c-name "PlumaDocumentSaveFlags") + (gtype-id "PLUMA_TYPE_DOCUMENT_SAVE_FLAGS") + (values + '("ignore-mtime" "PLUMA_DOCUMENT_SAVE_IGNORE_MTIME") + '("ignore-backup" "PLUMA_DOCUMENT_SAVE_IGNORE_BACKUP") + '("preserve-backup" "PLUMA_DOCUMENT_SAVE_PRESERVE_BACKUP") + ) +) + +(define-enum TabState + (in-module "Pluma") + (c-name "PlumaTabState") + (gtype-id "PLUMA_TYPE_TAB_STATE") + (values + '("normal" "PLUMA_TAB_STATE_NORMAL") + '("loading" "PLUMA_TAB_STATE_LOADING") + '("reverting" "PLUMA_TAB_STATE_REVERTING") + '("saving" "PLUMA_TAB_STATE_SAVING") + '("printing" "PLUMA_TAB_STATE_PRINTING") + '("print-previewing" "PLUMA_TAB_STATE_PRINT_PREVIEWING") + '("showing-print-preview" "PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW") + '("generic-not-editable" "PLUMA_TAB_STATE_GENERIC_NOT_EDITABLE") + '("loading-error" "PLUMA_TAB_STATE_LOADING_ERROR") + '("reverting-error" "PLUMA_TAB_STATE_REVERTING_ERROR") + '("saving-error" "PLUMA_TAB_STATE_SAVING_ERROR") + '("generic-error" "PLUMA_TAB_STATE_GENERIC_ERROR") + '("closing" "PLUMA_TAB_STATE_CLOSING") + ) +) + +(define-flags WindowState + (in-module "Pluma") + (c-name "PlumaWindowState") + (gtype-id "PLUMA_TYPE_WINDOW_STATE") + (values + '("normal" "PLUMA_WINDOW_STATE_NORMAL") + '("saving" "PLUMA_WINDOW_STATE_SAVING") + '("printing" "PLUMA_WINDOW_STATE_PRINTING") + '("loading" "PLUMA_WINDOW_STATE_LOADING") + '("error" "PLUMA_WINDOW_STATE_ERROR") + '("saving-session" "PLUMA_WINDOW_STATE_SAVING_SESSION") + ) +) + +;; Boxed types +(define-boxed Encoding + (in-module "Pluma") + (c-name "PlumaEncoding") + (gtype-id "PLUMA_TYPE_ENCODING") + (copy-func "pluma_encoding_copy") + (release-func "pluma_encoding_free") +;; (fields +;; '("gint" "index") +;; '("gchar*" "charset") +;; '("gchar*" "name") +;; ) +) + +(define-boxed MessageType + (in-module "Pluma") + (c-name "PlumaMessageType") + (gtype-id "PLUMA_TYPE_MESSAGE_TYPE") + (copy-func "pluma_message_type_ref") + (release-func "pluma_message_type_unref") +) + + +;; From ../../pluma/pluma-app.h + +(define-function pluma_app_get_type + (c-name "pluma_app_get_type") + (return-type "GType") +) + +(define-function app_get_default + (c-name "pluma_app_get_default") + (return-type "PlumaApp*") +) + +; deprecated version ! +(define-function pluma_app_get_default + (c-name "pluma_app_get_default_deprecated") + (return-type "PlumaApp*") +) + +(define-method create_window + (of-object "PlumaApp") + (c-name "pluma_app_create_window") + (return-type "PlumaWindow*") + (parameters + '("GdkScreen*" "screen") + ) +) + +(define-method get_windows + (of-object "PlumaApp") + (c-name "pluma_app_get_windows") + (return-type "const-GList*") +) + +(define-method get_active_window + (of-object "PlumaApp") + (c-name "pluma_app_get_active_window") + (return-type "PlumaWindow*") +) + +(define-method get_documents + (of-object "PlumaApp") + (c-name "pluma_app_get_documents") + (return-type "GList*") +) + +(define-method get_views + (of-object "PlumaApp") + (c-name "pluma_app_get_views") + (return-type "GList*") +) + +(define-method get_lockdown + (of-object "PlumaApp") + (c-name "pluma_app_get_lockdown") + (return-type "PlumaLockdownMask") +) + + +;; From ../../pluma/pluma-document.h + +(define-function document_error_quark + (c-name "pluma_document_error_quark") + (return-type "GQuark") +) + +(define-function pluma_document_get_type + (c-name "pluma_document_get_type") + (return-type "GType") +) + +(define-function pluma_document_new + (c-name "pluma_document_new") + (is-constructor-of "PlumaDocument") + (return-type "PlumaDocument*") +) + +(define-method get_location + (of-object "PlumaDocument") + (c-name "pluma_document_get_location") + (return-type "GFile*") +) + +(define-method get_uri + (of-object "PlumaDocument") + (c-name "pluma_document_get_uri") + (return-type "gchar*") +) + +(define-method set_uri + (of-object "PlumaDocument") + (c-name "pluma_document_set_uri") + (return-type "none") + (parameters + '("const-gchar*" "uri") + ) +) + +(define-method get_uri_for_display + (of-object "PlumaDocument") + (c-name "pluma_document_get_uri_for_display") + (return-type "gchar*") +) + +(define-method get_short_name_for_display + (of-object "PlumaDocument") + (c-name "pluma_document_get_short_name_for_display") + (return-type "gchar*") +) + +(define-method get_content_type + (of-object "PlumaDocument") + (c-name "pluma_document_get_content_type") + (return-type "gchar*") +) + +(define-method get_mime_type + (of-object "PlumaDocument") + (c-name "pluma_document_get_mime_type") + (return-type "gchar*") +) + +(define-method get_readonly + (of-object "PlumaDocument") + (c-name "pluma_document_get_readonly") + (return-type "gboolean") +) + +(define-method load + (of-object "PlumaDocument") + (c-name "pluma_document_load") + (return-type "none") + (parameters + '("const-gchar*" "uri") + '("const-PlumaEncoding*" "encoding") + '("gint" "line_pos") + '("gboolean" "create") + ) +) + +(define-method insert_file + (of-object "PlumaDocument") + (c-name "pluma_document_insert_file") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "iter") + '("const-gchar*" "uri") + '("const-PlumaEncoding*" "encoding") + ) +) + +(define-method load_cancel + (of-object "PlumaDocument") + (c-name "pluma_document_load_cancel") + (return-type "gboolean") +) + +(define-method save + (of-object "PlumaDocument") + (c-name "pluma_document_save") + (parameters + '("PlumaDocumentSaveFlags" "flags") + ) + (return-type "none") +) + +(define-method save_as + (of-object "PlumaDocument") + (c-name "pluma_document_save_as") + (return-type "none") + (parameters + '("const-gchar*" "uri") + '("const-PlumaEncoding*" "encoding") + '("PlumaDocumentSaveFlags" "flags") + ) +) + +(define-method is_untouched + (of-object "PlumaDocument") + (c-name "pluma_document_is_untouched") + (return-type "gboolean") +) + +(define-method is_untitled + (of-object "PlumaDocument") + (c-name "pluma_document_is_untitled") + (return-type "gboolean") +) + +(define-method is_local + (of-object "PlumaDocument") + (c-name "pluma_document_is_local") + (return-type "gboolean") +) + +(define-method get_deleted + (of-object "PlumaDocument") + (c-name "pluma_document_get_deleted") + (return-type "gboolean") +) + +(define-method goto_line + (of-object "PlumaDocument") + (c-name "pluma_document_goto_line") + (return-type "gboolean") + (parameters + '("gint" "line") + ) +) + +(define-method set_search_text + (of-object "PlumaDocument") + (c-name "pluma_document_set_search_text") + (return-type "none") + (parameters + '("const-gchar*" "text") + '("guint" "flags") + ) +) + +(define-method get_search_text + (of-object "PlumaDocument") + (c-name "pluma_document_get_search_text") + (return-type "gchar*") + (parameters + '("guint*" "flags") + ) +) + +(define-method get_can_search_again + (of-object "PlumaDocument") + (c-name "pluma_document_get_can_search_again") + (return-type "gboolean") +) + +(define-method search_forward + (of-object "PlumaDocument") + (c-name "pluma_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 "PlumaDocument") + (c-name "pluma_document_replace_all") + (return-type "gint") + (parameters + '("const-gchar*" "find") + '("const-gchar*" "replace") + '("guint" "flags") + ) +) + +(define-method search_backward + (of-object "PlumaDocument") + (c-name "pluma_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 "PlumaDocument") + (c-name "pluma_document_set_language") + (return-type "none") + (parameters + '("GtkSourceLanguage*" "lang" (null-ok)) + ) +) + +(define-method get_language + (of-object "PlumaDocument") + (c-name "pluma_document_get_language") + (return-type "GtkSourceLanguage*") +) + +(define-method get_encoding + (of-object "PlumaDocument") + (c-name "pluma_document_get_encoding") + (return-type "const-PlumaEncoding*") +) + +(define-method set_enable_search_highlighting + (of-object "PlumaDocument") + (c-name "pluma_document_set_enable_search_highlighting") + (return-type "none") + (parameters + '("gboolean" "enable") + ) +) + +(define-method get_enable_search_highlighting + (of-object "PlumaDocument") + (c-name "pluma_document_get_enable_search_highlighting") + (return-type "gboolean") +) + +;; From ../../pluma/pluma-encodings.h + +(define-function pluma_encoding_get_type + (c-name "pluma_encoding_get_type") + (return-type "GType") +) + +(define-method copy + (of-object "PlumaEncoding") + (c-name "pluma_encoding_copy") + (return-type "PlumaEncoding*") +) + +(define-method free + (of-object "PlumaEncoding") + (c-name "pluma_encoding_free") + (return-type "none") +) + +(define-function encoding_get_from_charset + (c-name "pluma_encoding_get_from_charset") + (return-type "const-PlumaEncoding*") + (parameters + '("const-gchar*" "charset") + ) +) + +; Deprecated version ! +(define-function pluma_encoding_get_from_charset + (c-name "pluma_encoding_get_from_charset_deprecated") + (return-type "const-PlumaEncoding*") + (parameters + '("const-gchar*" "charset") + ) +) + +(define-function encoding_get_from_index + (c-name "pluma_encoding_get_from_index") + (return-type "const-PlumaEncoding*") + (parameters + '("gint" "index") + ) +) + +; Deprecated version ! +(define-function pluma_encoding_get_from_index + (c-name "pluma_encoding_get_from_index_deprecated") + (return-type "const-PlumaEncoding*") + (parameters + '("gint" "index") + ) +) + +(define-method to_string + (of-object "PlumaEncoding") + (c-name "pluma_encoding_to_string") + (return-type "gchar*") +) + +(define-method get_name + (of-object "PlumaEncoding") + (c-name "pluma_encoding_get_name") + (return-type "const-gchar*") +) + +(define-method get_charset + (of-object "PlumaEncoding") + (c-name "pluma_encoding_get_charset") + (return-type "const-gchar*") +) + +(define-function encoding_get_utf8 + (c-name "pluma_encoding_get_utf8") + (return-type "const-PlumaEncoding*") +) + +; Deprecated version ! +(define-function pluma_encoding_get_utf8 + (c-name "pluma_encoding_get_utf8_deprecated") + (return-type "const-PlumaEncoding*") +) + +(define-function encoding_get_current + (c-name "pluma_encoding_get_current") + (return-type "const-PlumaEncoding*") +) + +; Deprecated version ! +(define-function pluma_encoding_get_current + (c-name "pluma_encoding_get_current_deprecated") + (return-type "const-PlumaEncoding*") +) + +;; From ../../pluma/pluma-help.h + +(define-function help_display + (c-name "pluma_help_display") + (return-type "gboolean") + (parameters + '("GtkWindow*" "parent") + '("const-gchar*" "name") + '("const-gchar*" "link_id") + ) +) + + + +;; From ../../pluma/pluma-panel.h + +(define-function pluma_panel_get_type + (c-name "pluma_panel_get_type") + (return-type "GType") +) + +(define-function pluma_panel_new + (c-name "pluma_panel_new") + (is-constructor-of "PlumaPanel") + (return-type "GtkWidget*") +) + +(define-method add_item + (of-object "PlumaPanel") + (c-name "pluma_panel_add_item") + (return-type "none") + (parameters + '("GtkWidget*" "item") + '("const-gchar*" "name") + '("GtkWidget*" "image") + ) +) + +(define-method add_item_with_stock_icon + (of-object "PlumaPanel") + (c-name "pluma_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 "PlumaPanel") + (c-name "pluma_panel_remove_item") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method activate_item + (of-object "PlumaPanel") + (c-name "pluma_panel_activate_item") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method item_is_active + (of-object "PlumaPanel") + (c-name "pluma_panel_item_is_active") + (return-type "gboolean") + (parameters + '("GtkWidget*" "item") + ) +) + +(define-method get_orientation + (of-object "PlumaPanel") + (c-name "pluma_panel_get_orientation") + (return-type "GtkOrientation") +) + +(define-method get_n_items + (of-object "PlumaPanel") + (c-name "pluma_panel_get_n_items") + (return-type "gint") +) + + +;; From ../../pluma/pluma-plugin.h + +(define-function pluma_plugin_get_type + (c-name "pluma_plugin_get_type") + (return-type "GType") +) + +(define-method get_install_dir + (of-object "PlumaPlugin") + (c-name "pluma_plugin_get_install_dir") + (return-type "gchar*") +) + +(define-method get_data_dir + (of-object "PlumaPlugin") + (c-name "pluma_plugin_get_data_dir") + (return-type "gchar*") +) + +(define-method activate + (of-object "PlumaPlugin") + (c-name "pluma_plugin_activate") + (return-type "none") + (parameters + '("PlumaWindow*" "window") + ) +) + +(define-method deactivate + (of-object "PlumaPlugin") + (c-name "pluma_plugin_deactivate") + (return-type "none") + (parameters + '("PlumaWindow*" "window") + ) +) + +(define-method update_ui + (of-object "PlumaPlugin") + (c-name "pluma_plugin_update_ui") + (return-type "none") + (parameters + '("PlumaWindow*" "window") + ) +) + +(define-method is_configurable + (of-object "PlumaPlugin") + (c-name "pluma_plugin_is_configurable") + (return-type "gboolean") +) + +(define-method create_configure_dialog + (of-object "PlumaPlugin") + (c-name "pluma_plugin_create_configure_dialog") + (return-type "GtkWidget*") +) + +;; From ../pluma/pluma-plugin-python.h + +(define-function pluma_plugin_python_get_type + (c-name "pluma_plugin_python_get_type") + (return-type "GType") +) + +(define-function pluma_plugin_python_new + (c-name "pluma_plugin_python_new") + (is-constructor-of "PlumaPluginPython") + (return-type "PlumaPluginPython*") +) + +;; From ../../pluma/pluma-status-bar.h + +(define-method flash_message + (of-object "PlumaStatusbar") + (c-name "pluma_statusbar_flash_message") + (return-type "none") + (parameters + '("int" "context_id") + '("const-gchar*" "message") + ) + ) + +;; From ../../pluma/pluma-tab.h + +(define-function pluma_tab_get_type + (c-name "pluma_tab_get_type") + (return-type "GType") +) + +(define-method get_view + (of-object "PlumaTab") + (c-name "pluma_tab_get_view") + (return-type "PlumaView*") +) + +(define-method get_document + (of-object "PlumaTab") + (c-name "pluma_tab_get_document") + (return-type "PlumaDocument*") +) + +(define-function tab_get_from_document + (c-name "pluma_tab_get_from_document") + (return-type "PlumaTab*") + (parameters + '("PlumaDocument*" "doc") + ) +) + +; Deprecated version ! +(define-function pluma_tab_get_from_document + (c-name "pluma_tab_get_from_document_deprecated") + (return-type "PlumaTab*") + (parameters + '("PlumaDocument*" "doc") + ) +) + +(define-method get_state + (of-object "PlumaTab") + (c-name "pluma_tab_get_state") + (return-type "PlumaTabState") +) + +(define-method set_auto_save_enabled + (of-object "PlumaTab") + (c-name "pluma_tab_set_auto_save_enabled") + (return-type "none") + (parameters + '("gboolean" "enable") + ) +) + +(define-method get_auto_save_enabled + (of-object "PlumaTab") + (c-name "pluma_tab_get_auto_save_enabled") + (return-type "gboolean") +) + +(define-method set_auto_save_interval + (of-object "PlumaTab") + (c-name "pluma_tab_set_auto_save_interval") + (return-type "none") + (parameters + '("gint" "interval") + ) +) + +(define-method get_auto_save_interval + (of-object "PlumaTab") + (c-name "pluma_tab_get_auto_save_interval") + (return-type "gint") +) + +;; From ../../pluma/pluma-view.h + +(define-function pluma_view_get_type + (c-name "pluma_view_get_type") + (return-type "GtkType") +) + +(define-function pluma_view_new + (c-name "pluma_view_new") + (is-constructor-of "PlumaView") + (return-type "GtkWidget*") + (parameters + '("PlumaDocument*" "doc") + ) +) + +(define-method cut_clipboard + (of-object "PlumaView") + (c-name "pluma_view_cut_clipboard") + (return-type "none") +) + +(define-method copy_clipboard + (of-object "PlumaView") + (c-name "pluma_view_copy_clipboard") + (return-type "none") +) + +(define-method paste_clipboard + (of-object "PlumaView") + (c-name "pluma_view_paste_clipboard") + (return-type "none") +) + +(define-method delete_selection + (of-object "PlumaView") + (c-name "pluma_view_delete_selection") + (return-type "none") +) + +(define-method select_all + (of-object "PlumaView") + (c-name "pluma_view_select_all") + (return-type "none") +) + +(define-method scroll_to_cursor + (of-object "PlumaView") + (c-name "pluma_view_scroll_to_cursor") + (return-type "none") +) + +(define-method set_font + (of-object "PlumaView") + (c-name "pluma_view_set_font") + (return-type "none") + (parameters + '("gboolean" "def") + '("const-gchar*" "font_name") + ) +) + + + +;; From ../../pluma/pluma-window.h + +(define-function pluma_window_get_type + (c-name "pluma_window_get_type") + (return-type "GType") +) + +(define-method create_tab + (of-object "PlumaWindow") + (c-name "pluma_window_create_tab") + (return-type "PlumaTab*") + (parameters + '("gboolean" "jump_to") + ) +) + +(define-method create_tab_from_uri + (of-object "PlumaWindow") + (c-name "pluma_window_create_tab_from_uri") + (return-type "PlumaTab*") + (parameters + '("const-gchar*" "uri") + '("const-PlumaEncoding*" "encoding" (null-ok)) + '("gint" "line_pos") + '("gboolean" "create") + '("gboolean" "jump_to") + ) +) + +(define-method close_tab + (of-object "PlumaWindow") + (c-name "pluma_window_close_tab") + (return-type "none") + (parameters + '("PlumaTab*" "tab") + ) +) + +(define-method close_tabs + (of-object "PlumaWindow") + (c-name "pluma_window_close_tabs") + (return-type "none") + (parameters + '("const-GList*" "tabs") + ) +) + +(define-method close_all_tabs + (of-object "PlumaWindow") + (c-name "pluma_window_close_all_tabs") + (return-type "none") +) + +(define-method get_active_tab + (of-object "PlumaWindow") + (c-name "pluma_window_get_active_tab") + (return-type "PlumaTab*") +) + +(define-method set_active_tab + (of-object "PlumaWindow") + (c-name "pluma_window_set_active_tab") + (return-type "none") + (parameters + '("PlumaTab*" "tab") + ) +) + +(define-method get_active_view + (of-object "PlumaWindow") + (c-name "pluma_window_get_active_view") + (return-type "PlumaView*") +) + +(define-method get_active_document + (of-object "PlumaWindow") + (c-name "pluma_window_get_active_document") + (return-type "PlumaDocument*") +) + +(define-method get_documents + (of-object "PlumaWindow") + (c-name "pluma_window_get_documents") + (return-type "GList*") +) + +(define-method get_unsaved_documents + (of-object "PlumaWindow") + (c-name "pluma_window_get_unsaved_documents") + (return-type "GList*") +) + +(define-method get_views + (of-object "PlumaWindow") + (c-name "pluma_window_get_views") + (return-type "GList*") +) + +(define-method get_group + (of-object "PlumaWindow") + (c-name "pluma_window_get_group") + (return-type "GtkWindowGroup*") +) + +(define-method get_side_panel + (of-object "PlumaWindow") + (c-name "pluma_window_get_side_panel") + (return-type "PlumaPanel*") +) + +(define-method get_bottom_panel + (of-object "PlumaWindow") + (c-name "pluma_window_get_bottom_panel") + (return-type "PlumaPanel*") +) + +(define-method get_statusbar + (of-object "PlumaWindow") + (c-name "pluma_window_get_statusbar") + (return-type "GtkWidget*") +) + +(define-method get_ui_manager + (of-object "PlumaWindow") + (c-name "pluma_window_get_ui_manager") + (return-type "GtkUIManager*") +) + +(define-method get_state + (of-object "PlumaWindow") + (c-name "pluma_window_get_state") + (return-type "PlumaWindowState") +) + +(define-method get_message_bus + (of-object "PlumaWindow") + (c-name "pluma_window_get_message_bus") + (return-type "PlumaMessageBus*") +) + +(define-method get_tab_from_uri + (of-object "PlumaWindow") + (c-name "pluma_window_get_tab_from_uri") + (return-type "PlumaTab*") + (parameters + '("const-gchar*" "uri") + ) +) + +;; From pluma-language-manager.h + +(define-function get_language_manager + (c-name "pluma_get_language_manager") + (return-type "GtkSourceLanguageManager*") +) + +(define-function language_manager_list_languages_sorted + (c-name "pluma_language_manager_list_languages_sorted") + (return-type "GSList*") + (parameters + '("GtkSourceLanguageManager*" "lm") + '("gboolean" "include_hidden") + ) +) + + +;; From pluma-message-bus.h + +(define-function pluma_message_bus_get_type + (c-name "pluma_message_bus_get_type") + (return-type "GType") +) + +(define-function message_bus_get_default + (c-name "pluma_message_bus_get_default") + (return-type "PlumaMessageBus*") +) + +(define-function pluma_message_bus_new + (c-name "pluma_message_bus_new") + (is-constructor-of "PlumaMessageBus") + (return-type "PlumaMessageBus*") +) + +(define-method lookup + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_lookup") + (return-type "PlumaMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-method register + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_register") + (return-type "PlumaMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + ) + (varargs #t) +) + +(define-method unregister + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_unregister") + (return-type "none") + (parameters + '("PlumaMessageType*" "message_type") + ) +) + +(define-method unregister_all + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_unregister_all") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + ) +) + +(define-method is_registered + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_is_registered") + (return-type "gboolean") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-method connect + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_connect") + (return-type "guint") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("PlumaMessageCallback" "callback") + '("gpointer" "userdata") + '("GDestroyNotify" "destroy_data") + ) +) + +(define-method disconnect + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_disconnect") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method disconnect_by_func + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_disconnect_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("PlumaMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method block + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_block") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method block_by_func + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_block_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("PlumaMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method unblock + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_unblock") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method unblock_by_func + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_unblock_by_func") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("PlumaMessageCallback" "callback") + '("gpointer" "userdata") + ) +) + +(define-method send_message + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_send_message") + (return-type "none") + (parameters + '("PlumaMessage*" "message") + ) +) + +(define-method send_message_sync + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_send_message_sync") + (return-type "none") + (parameters + '("PlumaMessage*" "message") + ) +) + +(define-method send + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_send") + (return-type "none") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) + (varargs #t) +) + +(define-method send_sync + (of-object "PlumaMessageBus") + (c-name "pluma_message_bus_send_sync") + (return-type "PlumaMessage*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) + (varargs #t) +) + + +;; From pluma-message-type.h + +(define-function pluma_message_type_get_type + (c-name "pluma_message_type_get_type") + (return-type "GType") +) + +(define-function pluma_message_type_is_supported + (c-name "pluma_message_type_is_supported") + (return-type "gboolean") + (parameters + '("GType" "type") + ) +) + +(define-function pluma_message_type_identifier + (c-name "pluma_message_type_identifier") + (return-type "gchar*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + ) +) + +(define-function pluma_message_type_new + (c-name "pluma_message_type_new") + (is-constructor-of "PlumaMessageType") + (return-type "PlumaMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + ) + (varargs #t) +) + +(define-function pluma_message_type_new_valist + (c-name "pluma_message_type_new_valist") + (return-type "PlumaMessageType*") + (parameters + '("const-gchar*" "object_path") + '("const-gchar*" "method") + '("guint" "num_optional") + '("va_list" "va_args") + ) +) + +(define-method ref + (of-object "PlumaMessageType") + (c-name "pluma_message_type_ref") + (return-type "PlumaMessageType*") +) + +(define-method unref + (of-object "PlumaMessageType") + (c-name "pluma_message_type_unref") + (return-type "none") +) + +(define-method instantiate_valist + (of-object "PlumaMessageType") + (c-name "pluma_message_type_instantiate_valist") + (return-type "PlumaMessage*") + (parameters + '("va_list" "va_args") + ) +) + +(define-method instantiate + (of-object "PlumaMessageType") + (c-name "pluma_message_type_instantiate") + (return-type "PlumaMessage*") + (parameters + ) + (varargs #t) +) + +(define-method get_object_path + (of-object "PlumaMessageType") + (c-name "pluma_message_type_get_object_path") + (return-type "const-gchar*") +) + +(define-method get_method + (of-object "PlumaMessageType") + (c-name "pluma_message_type_get_method") + (return-type "const-gchar*") +) + +(define-method lookup + (of-object "PlumaMessageType") + (c-name "pluma_message_type_lookup") + (return-type "GType") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method foreach + (of-object "PlumaMessageType") + (c-name "pluma_message_type_foreach") + (return-type "none") + (parameters + '("PlumaMessageTypeForeach" "func") + '("gpointer" "user_data") + ) +) + + +;; From pluma-message.h + +(define-function pluma_message_get_type + (c-name "pluma_message_get_type") + (return-type "GType") +) + +(define-method get + (of-object "PlumaMessage") + (c-name "pluma_message_get") + (return-type "none") + (parameters + ) + (varargs #t) +) + +(define-method get_valist + (of-object "PlumaMessage") + (c-name "pluma_message_get_valist") + (return-type "none") + (parameters + '("va_list" "var_args") + ) +) + +(define-method get_value + (of-object "PlumaMessage") + (c-name "pluma_message_get_value") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("GValue*" "value") + ) +) + +(define-method set + (of-object "PlumaMessage") + (c-name "pluma_message_set") + (return-type "none") + (parameters + ) + (varargs #t) +) + +(define-method set_valist + (of-object "PlumaMessage") + (c-name "pluma_message_set_valist") + (return-type "none") + (parameters + '("va_list" "var_args") + ) +) + +(define-method set_value + (of-object "PlumaMessage") + (c-name "pluma_message_set_value") + (return-type "none") + (parameters + '("const-gchar*" "key") + '("GValue*" "value") + ) +) + +(define-method set_valuesv + (of-object "PlumaMessage") + (c-name "pluma_message_set_valuesv") + (return-type "none") + (parameters + '("const-gchar**" "keys") + '("GValue*" "values") + '("gint" "n_values") + ) +) + +(define-method get_object_path + (of-object "PlumaMessage") + (c-name "pluma_message_get_object_path") + (return-type "const-gchar*") +) + +(define-method get_method + (of-object "PlumaMessage") + (c-name "pluma_message_get_method") + (return-type "const-gchar*") +) + +(define-method has_key + (of-object "PlumaMessage") + (c-name "pluma_message_has_key") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method get_key_type + (of-object "PlumaMessage") + (c-name "pluma_message_get_key_type") + (return-type "GType") + (parameters + '("const-gchar*" "key") + ) +) + +(define-method validate + (of-object "PlumaMessage") + (c-name "pluma_message_validate") + (return-type "gboolean") +) + + +;; From ../../pluma/pluma-debug.h + +(define-function debug + (c-name "pluma_debug") + (parameters + '("const-gchar*" "message") + ) + (return-type "none") +) + -- cgit v1.2.1