diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/Makefile.am | 2 | ||||
| -rw-r--r-- | python/pyempathy/Makefile.am | 38 | ||||
| -rw-r--r-- | python/pyempathy/pyempathy.defs | 1816 | ||||
| -rw-r--r-- | python/pyempathy/pyempathy.override | 84 | ||||
| -rw-r--r-- | python/pyempathy/pyempathymodule.c | 24 | ||||
| -rw-r--r-- | python/pyempathygtk/Makefile.am | 39 | ||||
| -rw-r--r-- | python/pyempathygtk/pyempathygtk.defs | 1698 | ||||
| -rw-r--r-- | python/pyempathygtk/pyempathygtk.override | 77 | ||||
| -rw-r--r-- | python/pyempathygtk/pyempathygtkmodule.c | 23 |
9 files changed, 3801 insertions, 0 deletions
diff --git a/python/Makefile.am b/python/Makefile.am new file mode 100644 index 000000000..5050f1b86 --- /dev/null +++ b/python/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS = pyempathy pyempathygtk + diff --git a/python/pyempathy/Makefile.am b/python/pyempathy/Makefile.am new file mode 100644 index 000000000..3c0bdbf2d --- /dev/null +++ b/python/pyempathy/Makefile.am @@ -0,0 +1,38 @@ +PYDEFS=`pkg-config --variable=defsdir pygtk-2.0` + +AM_CPPFLAGS = \ + -I. \ + -I$(top_srcdir)/libempathy \ + -I$(top_srcdir) \ + -DDATADIR=\""$(datadir)"\" \ + $(PYTHON_BINDING_CFLAGS) \ + `python-config --cflags` \ + $(WARN_CFLAGS) + +BUILT_SOURCES = \ + pyempathy.c + +pyempathydir = $(prefix)/lib/`pyversions -d`/site-packages +pyempathy_LTLIBRARIES = empathy.la + +empathy_la_SOURCES = \ + pyempathymodule.c \ + pyempathy.c + +empathy_la_LIBADD = \ + $(PYTHON_BINDING_LIBS) \ + $(top_builddir)/libempathy/libempathy.la + +empathy_la_LDFLAGS = \ + `python-config --libs` \ + -module -avoid-version + +pyempathy.c: pyempathy.override pyempathy.defs + pygtk-codegen-2.0 --prefix empathy \ + --register $(PYDEFS)/gdk-types.defs \ + --register $(PYDEFS)/gtk-types.defs \ + --override pyempathy.override \ + pyempathy.defs > $@ + +CLEANFILES = $(BUILT_SOURCES) + diff --git a/python/pyempathy/pyempathy.defs b/python/pyempathy/pyempathy.defs new file mode 100644 index 000000000..eea0b76d3 --- /dev/null +++ b/python/pyempathy/pyempathy.defs @@ -0,0 +1,1816 @@ +;; -*- scheme -*- +; interfaces + +(define-interface ContactList + (in-module "Empathy") + (c-name "EmpathyContactList") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST") +) + +; object definitions ... +(define-object Chandler + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyChandler") + (gtype-id "EMPATHY_TYPE_CHANDLER") +) + +(define-object Chatroom + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyChatroom") + (gtype-id "EMPATHY_TYPE_CHATROOM") +) + +(define-object ChatroomManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyChatroomManager") + (gtype-id "EMPATHY_TYPE_CHATROOM_MANAGER") +) + +(define-object Conf + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyConf") + (gtype-id "EMPATHY_TYPE_CONF") +) + +(define-object Contact + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyContact") + (gtype-id "EMPATHY_TYPE_CONTACT") +) + +(define-object ContactManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyContactManager") + (gtype-id "EMPATHY_TYPE_CONTACT_MANAGER") + (implements "EmpathyContactList") +) + +(define-object Filter + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyFilter") + (gtype-id "EMPATHY_TYPE_FILTER") +) + +(define-object Idle + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyIdle") + (gtype-id "EMPATHY_TYPE_IDLE") +) + +(define-object LogManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyLogManager") + (gtype-id "EMPATHY_TYPE_LOG_MANAGER") +) + +(define-object Message + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyMessage") + (gtype-id "EMPATHY_TYPE_MESSAGE") +) + +(define-object Presence + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyPresence") + (gtype-id "EMPATHY_TYPE_PRESENCE") +) + +(define-object TpChat + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpChat") + (gtype-id "EMPATHY_TYPE_TP_CHAT") +) + +(define-object TpChatroom + (in-module "Empathy") + (parent "EmpathyTpChat") + (c-name "EmpathyTpChatroom") + (gtype-id "EMPATHY_TYPE_TP_CHATROOM") + (implements "EmpathyContactList") +) + +(define-object TpContactList + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpContactList") + (gtype-id "EMPATHY_TYPE_TP_CONTACT_LIST") + (implements "EmpathyContactList") +) + +(define-object TpGroup + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpGroup") + (gtype-id "EMPATHY_TYPE_TP_GROUP") +) + +;; Enumerations and flags ... + +(define-flags Subscription + (in-module "Empathy") + (c-name "EmpathySubscription") + (gtype-id "EMPATHY_TYPE_SUBSCRIPTION") + (values + '("none" "EMPATHY_SUBSCRIPTION_NONE") + '("to" "EMPATHY_SUBSCRIPTION_TO") + '("from" "EMPATHY_SUBSCRIPTION_FROM") + '("both" "EMPATHY_SUBSCRIPTION_BOTH") + ) +) + +(define-enum MessageType + (in-module "Empathy") + (c-name "EmpathyMessageType") + (gtype-id "EMPATHY_TYPE_MESSAGE_TYPE") + (values + '("normal" "EMPATHY_MESSAGE_TYPE_NORMAL") + '("action" "EMPATHY_MESSAGE_TYPE_ACTION") + '("notice" "EMPATHY_MESSAGE_TYPE_NOTICE") + '("auto-reply" "EMPATHY_MESSAGE_TYPE_AUTO_REPLY") + '("last" "EMPATHY_MESSAGE_TYPE_LAST") + ) +) + +(define-enum RegExType + (in-module "Empathy") + (c-name "EmpathyRegExType") + (gtype-id "EMPATHY_TYPE_REG_EX_TYPE") + (values + '("as-is" "EMPATHY_REGEX_AS_IS") + '("browser" "EMPATHY_REGEX_BROWSER") + '("email" "EMPATHY_REGEX_EMAIL") + '("other" "EMPATHY_REGEX_OTHER") + '("all" "EMPATHY_REGEX_ALL") + ) +) + + +;; From empathy-avatar.h + +(define-function empathy_avatar_get_gtype + (c-name "empathy_avatar_get_gtype") + (return-type "GType") +) + +(define-function empathy_avatar_new + (c-name "empathy_avatar_new") + (is-constructor-of "EmpathyAvatar") + (return-type "EmpathyAvatar*") + (parameters + '("guchar*" "avatar") + '("gsize" "len") + '("gchar*" "format") + ) +) + +(define-method ref + (of-object "EmpathyAvatar") + (c-name "empathy_avatar_ref") + (return-type "EmpathyAvatar*") +) + +(define-method unref + (of-object "EmpathyAvatar") + (c-name "empathy_avatar_unref") + (return-type "none") +) + + + +;; From empathy-chandler-glue.h + +(define-function dbus_glib_marshal_empathy_chandler_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_POINTER + (c-name "dbus_glib_marshal_empathy_chandler_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_POINTER") + (return-type "none") + (parameters + '("GClosure*" "closure") + '("GValue*" "return_value") + '("guint" "n_param_values") + '("const-GValue*" "param_values") + '("gpointer" "invocation_hint") + '("gpointer" "marshal_data") + ) +) + + + +;; From empathy-chandler.h + +(define-function empathy_chandler_get_type + (c-name "empathy_chandler_get_type") + (return-type "GType") +) + +(define-function empathy_chandler_new + (c-name "empathy_chandler_new") + (is-constructor-of "EmpathyChandler") + (return-type "EmpathyChandler*") + (parameters + '("const-gchar*" "bus_name") + '("const-gchar*" "object_path") + ) +) + + + +;; From empathy-chatroom-manager.h + +(define-function empathy_chatroom_manager_get_type + (c-name "empathy_chatroom_manager_get_type") + (return-type "GType") +) + +(define-function empathy_chatroom_manager_new + (c-name "empathy_chatroom_manager_new") + (is-constructor-of "EmpathyChatroomManager") + (return-type "EmpathyChatroomManager*") +) + +(define-method add + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_add") + (return-type "gboolean") + (parameters + '("EmpathyChatroom*" "chatroom") + ) +) + +(define-method remove + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_remove") + (return-type "none") + (parameters + '("EmpathyChatroom*" "chatroom") + ) +) + +(define-method find + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_find") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + ) +) + +(define-method get_chatrooms + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_get_chatrooms") + (return-type "GList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_count + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_get_count") + (return-type "guint") + (parameters + '("McAccount*" "account") + ) +) + +(define-method store + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_store") + (return-type "none") +) + + + +;; From empathy-chatroom.h + +(define-function empathy_chatroom_get_type + (c-name "empathy_chatroom_get_type") + (return-type "GType") +) + +(define-function empathy_chatroom_new + (c-name "empathy_chatroom_new") + (is-constructor-of "EmpathyChatroom") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + ) +) + +(define-function empathy_chatroom_new_full + (c-name "empathy_chatroom_new_full") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + '("const-gchar*" "name") + '("gboolean" "auto_connect") + ) +) + +(define-method get_account + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_account") + (return-type "McAccount*") +) + +(define-method set_account + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_account") + (return-type "none") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_room + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_room") + (return-type "const-gchar*") +) + +(define-method set_room + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_room") + (return-type "none") + (parameters + '("const-gchar*" "room") + ) +) + +(define-method get_name + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_auto_connect + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_auto_connect") + (return-type "gboolean") +) + +(define-method set_auto_connect + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_auto_connect") + (return-type "none") + (parameters + '("gboolean" "auto_connect") + ) +) + +(define-function empathy_chatroom_equal + (c-name "empathy_chatroom_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + + + +;; From empathy-conf.h + +(define-function empathy_conf_get_type + (c-name "empathy_conf_get_type") + (return-type "GType") +) + +(define-function empathy_conf_get + (c-name "empathy_conf_get") + (return-type "EmpathyConf*") +) + +(define-function empathy_conf_shutdown + (c-name "empathy_conf_shutdown") + (return-type "none") +) + +(define-method notify_add + (of-object "EmpathyConf") + (c-name "empathy_conf_notify_add") + (return-type "guint") + (parameters + '("const-gchar*" "key") + '("EmpathyConfNotifyFunc" "func") + '("gpointer" "data") + ) +) + +(define-method notify_remove + (of-object "EmpathyConf") + (c-name "empathy_conf_notify_remove") + (return-type "gboolean") + (parameters + '("guint" "id") + ) +) + +(define-method set_int + (of-object "EmpathyConf") + (c-name "empathy_conf_set_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("gint" "value") + ) +) + +(define-method get_int + (of-object "EmpathyConf") + (c-name "empathy_conf_get_int") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("gint*" "value") + ) +) + +(define-method set_bool + (of-object "EmpathyConf") + (c-name "empathy_conf_set_bool") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("gboolean" "value") + ) +) + +(define-method get_bool + (of-object "EmpathyConf") + (c-name "empathy_conf_get_bool") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("gboolean*" "value") + ) +) + +(define-method set_string + (of-object "EmpathyConf") + (c-name "empathy_conf_set_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("const-gchar*" "value") + ) +) + +(define-method get_string + (of-object "EmpathyConf") + (c-name "empathy_conf_get_string") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("gchar**" "value") + ) +) + +(define-method set_string_list + (of-object "EmpathyConf") + (c-name "empathy_conf_set_string_list") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("GSList*" "value") + ) +) + +(define-method get_string_list + (of-object "EmpathyConf") + (c-name "empathy_conf_get_string_list") + (return-type "gboolean") + (parameters + '("const-gchar*" "key") + '("GSList**" "value") + ) +) + + + +;; From empathy-contact-list.h + +(define-function contact_list_get_type + (c-name "empathy_contact_list_get_type") + (return-type "GType") +) + +(define-method list_info_new + (of-object "EmpathyContact") + (c-name "empathy_contact_list_info_new") + (return-type "EmpathyContactListInfo*") + (parameters + '("const-gchar*" "message") + ) +) + +(define-method free + (of-object "EmpathyContactListInfo") + (c-name "empathy_contact_list_info_free") + (return-type "none") +) + +(define-method setup + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_setup") + (return-type "none") +) + +(define-method find + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_find") + (return-type "EmpathyContact*") + (parameters + '("const-gchar*" "id") + ) +) + +(define-method add + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_add") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-method remove + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_remove") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-method get_members + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_members") + (return-type "GList*") +) + +(define-method get_local_pending + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_local_pending") + (return-type "GList*") +) + +(define-method process_pending + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_process_pending") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("gboolean" "accept") + ) +) + +(define-virtual setup + (of-object "EmpathyContactList") + (return-type "none") +) + +(define-virtual find + (of-object "EmpathyContactList") + (return-type "EmpathyContact*") + (parameters + '("const-gchar*" "id") + ) +) + +(define-virtual add + (of-object "EmpathyContactList") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-virtual remove + (of-object "EmpathyContactList") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-virtual get_members + (of-object "EmpathyContactList") + (return-type "GList*") +) + +(define-virtual get_local_pending + (of-object "EmpathyContactList") + (return-type "GList*") +) + +(define-virtual process_pending + (of-object "EmpathyContactList") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("gboolean" "accept") + ) +) + +;; From empathy-contact-manager.h + +(define-function empathy_contact_manager_get_type + (c-name "empathy_contact_manager_get_type") + (return-type "GType") +) + +(define-function empathy_contact_manager_new + (c-name "empathy_contact_manager_new") + (is-constructor-of "EmpathyContactManager") + (return-type "EmpathyContactManager*") +) + +(define-method get_list + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_get_list") + (return-type "EmpathyTpContactList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_user + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_get_user") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method create + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_create") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "id") + ) +) + +(define-method rename_group + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_rename_group") + (return-type "none") + (parameters + '("const-gchar*" "old_group") + '("const-gchar*" "new_group") + ) +) + +(define-method get_groups + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_get_groups") + (return-type "GList*") +) + + + +;; From empathy-contact.h + +(define-function empathy_contact_get_gtype + (c-name "empathy_contact_get_gtype") + (return-type "GType") +) + +(define-function empathy_contact_new + (c-name "empathy_contact_new") + (is-constructor-of "EmpathyContact") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function empathy_contact_new_full + (c-name "empathy_contact_new_full") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "id") + '("const-gchar*" "name") + ) +) + +(define-method get_id + (of-object "EmpathyContact") + (c-name "empathy_contact_get_id") + (return-type "const-gchar*") +) + +(define-method get_name + (of-object "EmpathyContact") + (c-name "empathy_contact_get_name") + (return-type "const-gchar*") +) + +(define-method get_avatar + (of-object "EmpathyContact") + (c-name "empathy_contact_get_avatar") + (return-type "EmpathyAvatar*") +) + +(define-method get_account + (of-object "EmpathyContact") + (c-name "empathy_contact_get_account") + (return-type "McAccount*") +) + +(define-method get_presence + (of-object "EmpathyContact") + (c-name "empathy_contact_get_presence") + (return-type "EmpathyPresence*") +) + +(define-method get_groups + (of-object "EmpathyContact") + (c-name "empathy_contact_get_groups") + (return-type "GList*") +) + +(define-method get_subscription + (of-object "EmpathyContact") + (c-name "empathy_contact_get_subscription") + (return-type "EmpathySubscription") +) + +(define-method get_handle + (of-object "EmpathyContact") + (c-name "empathy_contact_get_handle") + (return-type "guint") +) + +(define-method is_user + (of-object "EmpathyContact") + (c-name "empathy_contact_is_user") + (return-type "gboolean") +) + +(define-method set_id + (of-object "EmpathyContact") + (c-name "empathy_contact_set_id") + (return-type "none") + (parameters + '("const-gchar*" "id") + ) +) + +(define-method set_name + (of-object "EmpathyContact") + (c-name "empathy_contact_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method set_avatar + (of-object "EmpathyContact") + (c-name "empathy_contact_set_avatar") + (return-type "none") + (parameters + '("EmpathyAvatar*" "avatar") + ) +) + +(define-method set_account + (of-object "EmpathyContact") + (c-name "empathy_contact_set_account") + (return-type "none") + (parameters + '("McAccount*" "account") + ) +) + +(define-method set_presence + (of-object "EmpathyContact") + (c-name "empathy_contact_set_presence") + (return-type "none") + (parameters + '("EmpathyPresence*" "presence") + ) +) + +(define-method set_groups + (of-object "EmpathyContact") + (c-name "empathy_contact_set_groups") + (return-type "none") + (parameters + '("GList*" "categories") + ) +) + +(define-method set_subscription + (of-object "EmpathyContact") + (c-name "empathy_contact_set_subscription") + (return-type "none") + (parameters + '("EmpathySubscription" "subscription") + ) +) + +(define-method set_handle + (of-object "EmpathyContact") + (c-name "empathy_contact_set_handle") + (return-type "none") + (parameters + '("guint" "handle") + ) +) + +(define-method set_is_user + (of-object "EmpathyContact") + (c-name "empathy_contact_set_is_user") + (return-type "none") + (parameters + '("gboolean" "is_user") + ) +) + +(define-method add_group + (of-object "EmpathyContact") + (c-name "empathy_contact_add_group") + (return-type "none") + (parameters + '("const-gchar*" "group") + ) +) + +(define-method remove_group + (of-object "EmpathyContact") + (c-name "empathy_contact_remove_group") + (return-type "none") + (parameters + '("const-gchar*" "group") + ) +) + +(define-method is_online + (of-object "EmpathyContact") + (c-name "empathy_contact_is_online") + (return-type "gboolean") +) + +(define-method is_in_group + (of-object "EmpathyContact") + (c-name "empathy_contact_is_in_group") + (return-type "gboolean") + (parameters + '("const-gchar*" "group") + ) +) + +(define-method get_status + (of-object "EmpathyContact") + (c-name "empathy_contact_get_status") + (return-type "const-gchar*") +) + +(define-function empathy_contact_equal + (c-name "empathy_contact_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function empathy_contact_hash + (c-name "empathy_contact_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + + + +;; From empathy-debug.h + +(define-function empathy_debug_impl + (c-name "empathy_debug_impl") + (return-type "none") + (parameters + '("const-gchar*" "domain") + '("const-gchar*" "msg") + ) + (varargs #t) +) + + + +;; From empathy-filter-glue.h + +(define-function dbus_glib_marshal_empathy_filter_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_UINT_POINTER + (c-name "dbus_glib_marshal_empathy_filter_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_UINT_POINTER") + (return-type "none") + (parameters + '("GClosure*" "closure") + '("GValue*" "return_value") + '("guint" "n_param_values") + '("const-GValue*" "param_values") + '("gpointer" "invocation_hint") + '("gpointer" "marshal_data") + ) +) + + + +;; From empathy-filter.h + +(define-function empathy_filter_get_type + (c-name "empathy_filter_get_type") + (return-type "GType") +) + +(define-function empathy_filter_new + (c-name "empathy_filter_new") + (is-constructor-of "EmpathyFilter") + (return-type "EmpathyFilter*") + (parameters + '("const-gchar*" "bus_name") + '("const-gchar*" "object_path") + '("const-gchar*" "channel_type") + '("guint" "priority") + '("guint" "flags") + ) +) + +(define-method process + (of-object "EmpathyFilter") + (c-name "empathy_filter_process") + (return-type "none") + (parameters + '("TpChan*" "tp_chan") + '("gboolean" "process") + ) +) + + + +;; From empathy-idle.h + +(define-function empathy_idle_get_type + (c-name "empathy_idle_get_type") + (return-type "GType") +) + +(define-function empathy_idle_new + (c-name "empathy_idle_new") + (is-constructor-of "EmpathyIdle") + (return-type "EmpathyIdle*") +) + +(define-method get_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_state") + (return-type "McPresence") +) + +(define-method set_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_state") + (return-type "none") + (parameters + '("McPresence" "state") + ) +) + +(define-method get_status + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_status") + (return-type "const-gchar*") +) + +(define-method set_status + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_status") + (return-type "none") + (parameters + '("const-gchar*" "status") + ) +) + +(define-method get_flash_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_flash_state") + (return-type "McPresence") +) + +(define-method set_flash_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_flash_state") + (return-type "none") + (parameters + '("McPresence" "state") + ) +) + +(define-method set_presence + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_presence") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + + + +;; From empathy-log-manager.h + +(define-function empathy_log_manager_get_type + (c-name "empathy_log_manager_get_type") + (return-type "GType") +) + +(define-function empathy_log_manager_new + (c-name "empathy_log_manager_new") + (is-constructor-of "EmpathyLogManager") + (return-type "EmpathyLogManager*") +) + +(define-method add_message + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_add_message") + (return-type "none") + (parameters + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("EmpathyMessage*" "message") + ) +) + +(define-method exists + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_exists") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_dates + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_dates") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_messages_for_date + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_messages_for_date") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("const-gchar*" "date") + ) +) + +(define-method get_last_messages + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_last_messages") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_chats + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_chats") + (return-type "GList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method search_new + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_search_new") + (return-type "GList*") + (parameters + '("const-gchar*" "text") + ) +) + +(define-function empathy_log_manager_search_free + (c-name "empathy_log_manager_search_free") + (return-type "none") + (parameters + '("GList*" "hits") + ) +) + +(define-function empathy_log_manager_get_date_readable + (c-name "empathy_log_manager_get_date_readable") + (return-type "gchar*") + (parameters + '("const-gchar*" "date") + ) +) + + + +;; From empathy-marshal.h + + + +;; From empathy-message.h + +(define-function empathy_message_get_gtype + (c-name "empathy_message_get_gtype") + (return-type "GType") +) + +(define-function empathy_message_new + (c-name "empathy_message_new") + (is-constructor-of "EmpathyMessage") + (return-type "EmpathyMessage*") + (parameters + '("const-gchar*" "body") + ) +) + +(define-method get_type + (of-object "EmpathyMessage") + (c-name "empathy_message_get_type") + (return-type "EmpathyMessageType") +) + +(define-method set_type + (of-object "EmpathyMessage") + (c-name "empathy_message_set_type") + (return-type "none") + (parameters + '("EmpathyMessageType" "type") + ) +) + +(define-method get_sender + (of-object "EmpathyMessage") + (c-name "empathy_message_get_sender") + (return-type "EmpathyContact*") +) + +(define-method set_sender + (of-object "EmpathyMessage") + (c-name "empathy_message_set_sender") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method get_receiver + (of-object "EmpathyMessage") + (c-name "empathy_message_get_receiver") + (return-type "EmpathyContact*") +) + +(define-method set_receiver + (of-object "EmpathyMessage") + (c-name "empathy_message_set_receiver") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method get_body + (of-object "EmpathyMessage") + (c-name "empathy_message_get_body") + (return-type "const-gchar*") +) + +(define-method set_body + (of-object "EmpathyMessage") + (c-name "empathy_message_set_body") + (return-type "none") + (parameters + '("const-gchar*" "body") + ) +) + +(define-method get_timestamp + (of-object "EmpathyMessage") + (c-name "empathy_message_get_timestamp") + (return-type "EmpathyTime") +) + +(define-method set_timestamp + (of-object "EmpathyMessage") + (c-name "empathy_message_set_timestamp") + (return-type "none") + (parameters + '("EmpathyTime" "timestamp") + ) +) + + + +;; From empathy-presence.h + +(define-function empathy_presence_get_type + (c-name "empathy_presence_get_type") + (return-type "GType") +) + +(define-function empathy_presence_new + (c-name "empathy_presence_new") + (is-constructor-of "EmpathyPresence") + (return-type "EmpathyPresence*") +) + +(define-function empathy_presence_new_full + (c-name "empathy_presence_new_full") + (return-type "EmpathyPresence*") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-method get_state + (of-object "EmpathyPresence") + (c-name "empathy_presence_get_state") + (return-type "McPresence") +) + +(define-method get_status + (of-object "EmpathyPresence") + (c-name "empathy_presence_get_status") + (return-type "const-gchar*") +) + +(define-method set_state + (of-object "EmpathyPresence") + (c-name "empathy_presence_set_state") + (return-type "none") + (parameters + '("McPresence" "state") + ) +) + +(define-method set_status + (of-object "EmpathyPresence") + (c-name "empathy_presence_set_status") + (return-type "none") + (parameters + '("const-gchar*" "status") + ) +) + +(define-function empathy_presence_sort_func + (c-name "empathy_presence_sort_func") + (return-type "gint") + (parameters + '("gconstpointer" "a") + '("gconstpointer" "b") + ) +) + +(define-function empathy_presence_state_get_default_status + (c-name "empathy_presence_state_get_default_status") + (return-type "const-gchar*") + (parameters + '("McPresence" "state") + ) +) + +(define-function empathy_presence_state_to_str + (c-name "empathy_presence_state_to_str") + (return-type "const-gchar*") + (parameters + '("McPresence" "state") + ) +) + +(define-function empathy_presence_state_from_str + (c-name "empathy_presence_state_from_str") + (return-type "McPresence") + (parameters + '("const-gchar*" "str") + ) +) + + + +;; From empathy-time.h + +(define-function empathy_time_get_current + (c-name "empathy_time_get_current") + (return-type "EmpathyTime") +) + +(define-function empathy_time_get_local_time + (c-name "empathy_time_get_local_time") + (return-type "time_t") + (parameters + '("struct-tm*" "tm") + ) +) + +(define-function empathy_time_parse + (c-name "empathy_time_parse") + (return-type "EmpathyTime") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function empathy_time_parse_format + (c-name "empathy_time_parse_format") + (return-type "EmpathyTime") + (parameters + '("const-gchar*" "str") + '("const-gchar*" "format") + ) +) + +(define-method to_string_utc + (of-object "EmpathyTime") + (c-name "empathy_time_to_string_utc") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) +) + +(define-method to_string_local + (of-object "EmpathyTime") + (c-name "empathy_time_to_string_local") + (return-type "gchar*") + (parameters + '("const-gchar*" "format") + ) +) + + + +;; From empathy-tp-chat.h + +(define-function empathy_tp_chat_get_type + (c-name "empathy_tp_chat_get_type") + (return-type "GType") +) + +(define-function empathy_tp_chat_new + (c-name "empathy_tp_chat_new") + (is-constructor-of "EmpathyTpChat") + (return-type "EmpathyTpChat*") + (parameters + '("McAccount*" "account") + '("TpChan*" "tp_chan") + ) +) + +(define-function empathy_tp_chat_new_with_contact + (c-name "empathy_tp_chat_new_with_contact") + (return-type "EmpathyTpChat*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method get_acknowledge + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_acknowledge") + (return-type "gboolean") +) + +(define-method set_acknowledge + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_set_acknowledge") + (return-type "none") + (parameters + '("gboolean" "acknowledge") + ) +) + +(define-method get_channel + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_channel") + (return-type "TpChan*") +) + +(define-method get_pendings + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_pendings") + (return-type "GList*") +) + +(define-method send + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_send") + (return-type "none") + (parameters + '("EmpathyMessage*" "message") + ) +) + +(define-method set_state + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_set_state") + (return-type "none") + (parameters + '("TelepathyChannelChatState" "state") + ) +) + +(define-method get_id + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_id") + (return-type "const-gchar*") +) + + + +;; From empathy-tp-chatroom.h + +(define-function empathy_tp_chatroom_get_type + (c-name "empathy_tp_chatroom_get_type") + (return-type "GType") +) + +(define-function empathy_tp_chatroom_new + (c-name "empathy_tp_chatroom_new") + (is-constructor-of "EmpathyTpChatroom") + (return-type "EmpathyTpChatroom*") + (parameters + '("McAccount*" "account") + '("TpChan*" "tp_chan") + ) +) + +(define-method get_invitation + (of-object "EmpathyTpChatroom") + (c-name "empathy_tp_chatroom_get_invitation") + (return-type "gboolean") + (parameters + '("EmpathyContact**" "contact") + '("const-gchar**" "message") + ) +) + +(define-method accept_invitation + (of-object "EmpathyTpChatroom") + (c-name "empathy_tp_chatroom_accept_invitation") + (return-type "none") +) + +(define-method set_topic + (of-object "EmpathyTpChatroom") + (c-name "empathy_tp_chatroom_set_topic") + (return-type "none") + (parameters + '("const-gchar*" "topic") + ) +) + + + +;; From empathy-tp-contact-list.h + +(define-function empathy_tp_contact_list_get_type + (c-name "empathy_tp_contact_list_get_type") + (return-type "GType") +) + +(define-function empathy_tp_contact_list_new + (c-name "empathy_tp_contact_list_new") + (is-constructor-of "EmpathyTpContactList") + (return-type "EmpathyTpContactList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_account + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_account") + (return-type "McAccount*") +) + +(define-method get_user + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_user") + (return-type "EmpathyContact*") +) + +(define-method get_from_id + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_from_id") + (return-type "EmpathyContact*") + (parameters + '("const-gchar*" "id") + ) +) + +(define-method get_from_handle + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_from_handle") + (return-type "EmpathyContact*") + (parameters + '("guint" "handle") + ) +) + +(define-method get_from_handles + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_from_handles") + (return-type "GList*") + (parameters + '("GArray*" "handles") + ) +) + +(define-method rename_group + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_rename_group") + (return-type "none") + (parameters + '("const-gchar*" "old_group") + '("const-gchar*" "new_group") + ) +) + +(define-method get_groups + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_groups") + (return-type "GList*") +) + + + +;; From empathy-tp-group.h + +(define-function empathy_tp_group_get_type + (c-name "empathy_tp_group_get_type") + (return-type "GType") +) + +(define-function empathy_tp_group_new + (c-name "empathy_tp_group_new") + (is-constructor-of "EmpathyTpGroup") + (return-type "EmpathyTpGroup*") + (parameters + '("TpChan*" "tp_chan") + '("TpConn*" "tp_conn") + ) +) + +(define-method add_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_add_members") + (return-type "none") + (parameters + '("GArray*" "handles") + '("const-gchar*" "message") + ) +) + +(define-method add_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_add_member") + (return-type "none") + (parameters + '("guint" "handle") + '("const-gchar*" "message") + ) +) + +(define-method remove_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_remove_members") + (return-type "none") + (parameters + '("GArray*" "handle") + '("const-gchar*" "message") + ) +) + +(define-method remove_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_remove_member") + (return-type "none") + (parameters + '("guint" "handle") + '("const-gchar*" "message") + ) +) + +(define-method get_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_members") + (return-type "GArray*") +) + +(define-method get_all_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_all_members") + (return-type "none") + (parameters + '("GArray**" "members") + '("GArray**" "local_pending") + '("GArray**" "remote_pending") + ) +) + +(define-method get_local_pending_members_with_info + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_local_pending_members_with_info") + (return-type "GList*") +) + +(define-function empathy_tp_group_info_list_free + (c-name "empathy_tp_group_info_list_free") + (return-type "none") + (parameters + '("GList*" "infos") + ) +) + +(define-method get_name + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_name") + (return-type "const-gchar*") +) + +(define-method get_self_handle + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_self_handle") + (return-type "guint") +) + +(define-method get_object_path + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_object_path") + (return-type "const-gchar*") +) + +(define-method is_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_is_member") + (return-type "gboolean") + (parameters + '("guint" "handle") + ) +) + + + +;; From empathy-utils.h + +(define-function empathy_substring + (c-name "empathy_substring") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gint" "start") + '("gint" "end") + ) +) + +(define-function empathy_regex_match + (c-name "empathy_regex_match") + (return-type "gint") + (parameters + '("EmpathyRegExType" "type") + '("const-gchar*" "msg") + '("GArray*" "start") + '("GArray*" "end") + ) +) + +(define-function empathy_strcasecmp + (c-name "empathy_strcasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + ) +) + +(define-function empathy_strncasecmp + (c-name "empathy_strncasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + '("gsize" "n") + ) +) + +(define-function empathy_xml_validate + (c-name "empathy_xml_validate") + (return-type "gboolean") + (parameters + '("xmlDoc*" "doc") + '("const-gchar*" "dtd_filename") + ) +) + +(define-function empathy_xml_node_get_child + (c-name "empathy_xml_node_get_child") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "child_name") + ) +) + +(define-function empathy_xml_node_get_child_content + (c-name "empathy_xml_node_get_child_content") + (return-type "xmlChar*") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "child_name") + ) +) + +(define-function empathy_xml_node_find_child_prop_value + (c-name "empathy_xml_node_find_child_prop_value") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "prop_name") + '("const-gchar*" "prop_value") + ) +) + +(define-function empathy_account_hash + (c-name "empathy_account_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-function empathy_account_equal + (c-name "empathy_account_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "a") + '("gconstpointer" "b") + ) +) + +(define-function empathy_mission_control_new + (c-name "empathy_mission_control_new") + (is-constructor-of "EmpathyMissionControl") + (return-type "MissionControl*") +) + +(define-function empathy_get_channel_id + (c-name "empathy_get_channel_id") + (return-type "gchar*") + (parameters + '("McAccount*" "account") + '("TpChan*" "tp_chan") + ) +) + diff --git a/python/pyempathy/pyempathy.override b/python/pyempathy/pyempathy.override new file mode 100644 index 000000000..824339273 --- /dev/null +++ b/python/pyempathy/pyempathy.override @@ -0,0 +1,84 @@ +%% +headers +#include <Python.h> +#include <pygobject.h> +#include "empathy-avatar.h" +#include "empathy-chandler.h" +#include "empathy-chatroom-manager.h" +#include "empathy-chatroom.h" +#include "empathy-conf.h" +#include "empathy-contact-list.h" +#include "empathy-contact-manager.h" +#include "empathy-contact.h" +#include "empathy-debug.h" +#include "empathy-filter.h" +#include "empathy-idle.h" +#include "empathy-log-manager.h" +#include "empathy-marshal.h" +#include "empathy-message.h" +#include "empathy-presence.h" +#include "empathy-time.h" +#include "empathy-tp-chat.h" +#include "empathy-tp-chatroom.h" +#include "empathy-tp-contact-list.h" +#include "empathy-tp-group.h" +#include "empathy-utils.h" + + +/* FIXME */ +#define MC_TYPE_PRESENCE 1 +#define EMPATHY_TYPE_SUBSCRIPTION 2 +#define EMPATHY_TYPE_MESSAGE_TYPE 3 +#define EMPATHY_TYPE_REG_EX_TYPE 4 + + +void empathy_add_constants(PyObject *module, const gchar *strip_prefix); +void empathy_register_classes(PyObject *d); + +%% +modulename empathy +%% +ignore-glob + *_get_type +%% +import gobject.GObject as PyGObject_Type +%% +override empathy_contact_list_get_members kwargs +static PyObject * +_wrap_empathy_contact_list_get_members(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + + PyObject *py_contacts = PyList_New(0); + GList *l, *contacts; + + contacts = empathy_contact_list_get_members(EMPATHY_CONTACT_LIST(self->obj)); + + for (l = contacts; l; l = l->next) { + EmpathyContact *contact; + contact = l->data; + PyList_Append(py_contacts, pygobject_new((GObject *) contact)); + } + + return py_contacts; + +} +%% +override empathy_contact_get_groups kwargs +static PyObject * +_wrap_empathy_contact_get_groups(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + + GList *groups = empathy_contact_get_groups(EMPATHY_CONTACT(self->obj)); + PyObject *py_groups = PyList_New(0); + GList *l; + + for(l = groups; l; l = l->next) { + const gchar *group; + group = l->data; + PyList_Append(py_groups, PyString_FromString(group)); + } + + return py_groups; + +} +%% diff --git a/python/pyempathy/pyempathymodule.c b/python/pyempathy/pyempathymodule.c new file mode 100644 index 000000000..118031366 --- /dev/null +++ b/python/pyempathy/pyempathymodule.c @@ -0,0 +1,24 @@ +#include <pygobject.h> + +void empathy_register_classes (PyObject *d); +DL_EXPORT(void) initempathy(void); +extern PyMethodDef empathy_functions[]; + +DL_EXPORT(void) +initempathy(void) +{ + PyObject *m, *d; + + init_pygobject (); + + m = Py_InitModule ("empathy", empathy_functions); + d = PyModule_GetDict (m); + + empathy_register_classes (d); + + if (PyErr_Occurred ()) { + PyErr_Print(); + Py_FatalError ("can't initialise module empathy"); + } +} + diff --git a/python/pyempathygtk/Makefile.am b/python/pyempathygtk/Makefile.am new file mode 100644 index 000000000..fa8f9f9dd --- /dev/null +++ b/python/pyempathygtk/Makefile.am @@ -0,0 +1,39 @@ +PYDEFS=`pkg-config --variable=defsdir pygtk-2.0` + +AM_CPPFLAGS = \ + -I. \ + -I$(top_srcdir)/libempathy-gtk \ + -I$(top_srcdir) \ + -DDATADIR=\""$(datadir)"\" \ + $(PYTHON_BINDING_CFLAGS) \ + `python-config --cflags` + +BUILT_SOURCES = \ + pyempathygtk.c + +pyempathygtkdir = $(prefix)/lib/`pyversions -d`/site-packages +pyempathygtk_LTLIBRARIES = empathygtk.la + +empathygtk_la_SOURCES = \ + pyempathygtkmodule.c \ + pyempathygtk.c + +empathygtk_la_LIBADD = \ + $(PYTHON_BINDING_LIBS) \ + $(top_builddir)/libempathy/libempathy.la \ + $(top_builddir)/libempathy-gtk/libempathy-gtk.la + +empathygtk_la_LDFLAGS = \ + `python-config --libs` \ + -module -avoid-version + +pyempathygtk.c: pyempathygtk.override pyempathygtk.defs + pygtk-codegen-2.0 --prefix empathy \ + --register $(PYDEFS)/gdk-types.defs \ + --register $(PYDEFS)/gtk-types.defs \ + --register ../pyempathy/pyempathy.defs \ + --override pyempathygtk.override \ + pyempathygtk.defs > $@ + +CLEANFILES = $(BUILT_SOURCES) + diff --git a/python/pyempathygtk/pyempathygtk.defs b/python/pyempathygtk/pyempathygtk.defs new file mode 100644 index 000000000..c41ea45c7 --- /dev/null +++ b/python/pyempathygtk/pyempathygtk.defs @@ -0,0 +1,1698 @@ +;; -*- scheme -*- +; object definitions ... +(define-object AccountChooser + (in-module "Empathy") + (parent "GtkComboBox") + (c-name "EmpathyAccountChooser") + (gtype-id "EMPATHY_TYPE_ACCOUNT_CHOOSER") +) + +(define-object CellRendererExpander + (in-module "Empathy") + (parent "GtkCellRenderer") + (c-name "EmpathyCellRendererExpander") + (gtype-id "EMPATHY_TYPE_CELL_RENDERER_EXPANDER") +) + +(define-object CellRendererText + (in-module "Empathy") + (parent "GtkCellRendererText") + (c-name "EmpathyCellRendererText") + (gtype-id "EMPATHY_TYPE_CELL_RENDERER_TEXT") +) + +(define-object Chat + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyChat") + (gtype-id "EMPATHY_TYPE_CHAT") +) + +(define-object ChatView + (in-module "Empathy") + (parent "GtkTextView") + (c-name "EmpathyChatView") + (gtype-id "EMPATHY_TYPE_CHAT_VIEW") +) + +(define-object ChatWindow + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyChatWindow") + (gtype-id "EMPATHY_TYPE_CHAT_WINDOW") +) + +(define-object ContactListStore + (in-module "Empathy") + (parent "GtkTreeStore") + (c-name "EmpathyContactListStore") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE") +) + +(define-object ContactListView + (in-module "Empathy") + (parent "GtkTreeView") + (c-name "EmpathyContactListView") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST_VIEW") +) + +(define-object GroupChat + (in-module "Empathy") + (parent "EmpathyChat") + (c-name "EmpathyGroupChat") + (gtype-id "EMPATHY_TYPE_GROUP_CHAT") +) + +(define-object PresenceChooser + (in-module "Empathy") + (parent "GtkToggleButton") + (c-name "EmpathyPresenceChooser") + (gtype-id "EMPATHY_TYPE_PRESENCE_CHOOSER") +) + +(define-object PrivateChat + (in-module "Empathy") + (parent "EmpathyChat") + (c-name "EmpathyPrivateChat") + (gtype-id "EMPATHY_TYPE_PRIVATE_CHAT") +) + +(define-object StatusIcon + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyStatusIcon") + (gtype-id "EMPATHY_TYPE_STATUS_ICON") +) + +(define-object ThemeManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyThemeManager") + (gtype-id "EMPATHY_TYPE_THEME_MANAGER") +) + +(define-object Spinner + (in-module "Ephy") + (parent "GtkWidget") + (c-name "EphySpinner") + (gtype-id "EPHY_TYPE_SPINNER") +) + +;; Enumerations and flags ... + +(define-enum Smiley + (in-module "Empathy") + (c-name "EmpathySmiley") + (gtype-id "EMPATHY_TYPE_SMILEY") + (values + '("normal" "EMPATHY_SMILEY_NORMAL") + '("wink" "EMPATHY_SMILEY_WINK") + '("bigeye" "EMPATHY_SMILEY_BIGEYE") + '("nose" "EMPATHY_SMILEY_NOSE") + '("cry" "EMPATHY_SMILEY_CRY") + '("sad" "EMPATHY_SMILEY_SAD") + '("sceptical" "EMPATHY_SMILEY_SCEPTICAL") + '("bigsmile" "EMPATHY_SMILEY_BIGSMILE") + '("indifferent" "EMPATHY_SMILEY_INDIFFERENT") + '("tounge" "EMPATHY_SMILEY_TOUNGE") + '("shocked" "EMPATHY_SMILEY_SHOCKED") + '("cool" "EMPATHY_SMILEY_COOL") + '("sorry" "EMPATHY_SMILEY_SORRY") + '("kiss" "EMPATHY_SMILEY_KISS") + '("shutup" "EMPATHY_SMILEY_SHUTUP") + '("yawn" "EMPATHY_SMILEY_YAWN") + '("confused" "EMPATHY_SMILEY_CONFUSED") + '("angel" "EMPATHY_SMILEY_ANGEL") + '("oooh" "EMPATHY_SMILEY_OOOH") + '("lookaway" "EMPATHY_SMILEY_LOOKAWAY") + '("blush" "EMPATHY_SMILEY_BLUSH") + '("coolbigsmile" "EMPATHY_SMILEY_COOLBIGSMILE") + '("angry" "EMPATHY_SMILEY_ANGRY") + '("boss" "EMPATHY_SMILEY_BOSS") + '("monkey" "EMPATHY_SMILEY_MONKEY") + '("silly" "EMPATHY_SMILEY_SILLY") + '("sick" "EMPATHY_SMILEY_SICK") + '("count" "EMPATHY_SMILEY_COUNT") + ) +) + +(define-enum ContactListStoreSort + (in-module "Empathy") + (c-name "EmpathyContactListStoreSort") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE_SORT") + (values + '("state" "EMPATHY_CONTACT_LIST_STORE_SORT_STATE") + '("name" "EMPATHY_CONTACT_LIST_STORE_SORT_NAME") + ) +) + +(define-enum ContactListStoreCol + (in-module "Empathy") + (c-name "EmpathyContactListStoreCol") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE_COL") + (values + '("icon-status" "COL_ICON_STATUS") + '("pixbuf-avatar" "COL_PIXBUF_AVATAR") + '("pixbuf-avatar-visible" "COL_PIXBUF_AVATAR_VISIBLE") + '("name" "COL_NAME") + '("status" "COL_STATUS") + '("status-visible" "COL_STATUS_VISIBLE") + '("contact" "COL_CONTACT") + '("is-group" "COL_IS_GROUP") + '("is-active" "COL_IS_ACTIVE") + '("is-online" "COL_IS_ONLINE") + '("is-separator" "COL_IS_SEPARATOR") + '("count" "COL_COUNT") + ) +) + +(define-enum ContactWidgetType + (in-module "Empathy") + (c-name "EmpathyContactWidgetType") + (gtype-id "EMPATHY_TYPE_CONTACT_WIDGET_TYPE") + (values + '("show" "CONTACT_WIDGET_TYPE_SHOW") + '("edit" "CONTACT_WIDGET_TYPE_EDIT") + '("add" "CONTACT_WIDGET_TYPE_ADD") + '("subscription" "CONTACT_WIDGET_TYPE_SUBSCRIPTION") + ) +) + + +;; From empathy-about-dialog.h + +(define-function empathy_about_dialog_new + (c-name "empathy_about_dialog_new") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-account-chooser.h + +(define-function empathy_account_chooser_get_type + (c-name "empathy_account_chooser_get_type") + (return-type "GType") +) + +(define-function empathy_account_chooser_new + (c-name "empathy_account_chooser_new") + (is-constructor-of "EmpathyAccountChooser") + (return-type "GtkWidget*") +) + +(define-method get_account + (of-object "EmpathyAccountChooser") + (c-name "empathy_account_chooser_get_account") + (return-type "McAccount*") +) + +(define-method set_account + (of-object "EmpathyAccountChooser") + (c-name "empathy_account_chooser_set_account") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_has_all_option + (of-object "EmpathyAccountChooser") + (c-name "empathy_account_chooser_get_has_all_option") + (return-type "gboolean") +) + +(define-method set_has_all_option + (of-object "EmpathyAccountChooser") + (c-name "empathy_account_chooser_set_has_all_option") + (return-type "none") + (parameters + '("gboolean" "has_all_option") + ) +) + +(define-method set_filter + (of-object "EmpathyAccountChooser") + (c-name "empathy_account_chooser_set_filter") + (return-type "none") + (parameters + '("EmpathyAccountChooserFilterFunc" "filter") + '("gpointer" "user_data") + ) +) + +(define-function empathy_account_chooser_filter_is_connected + (c-name "empathy_account_chooser_filter_is_connected") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-accounts-dialog.h + +(define-function empathy_accounts_dialog_show + (c-name "empathy_accounts_dialog_show") + (return-type "GtkWidget*") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-account-widget-generic.h + +(define-function empathy_account_widget_generic_new + (c-name "empathy_account_widget_generic_new") + (is-constructor-of "EmpathyAccountWidgetGeneric") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-account-widget-jabber.h + +(define-function empathy_account_widget_jabber_new + (c-name "empathy_account_widget_jabber_new") + (is-constructor-of "EmpathyAccountWidgetJabber") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-account-widget-msn.h + +(define-function empathy_account_widget_msn_new + (c-name "empathy_account_widget_msn_new") + (is-constructor-of "EmpathyAccountWidgetMsn") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-cell-renderer-expander.h + +(define-function empathy_cell_renderer_expander_get_type + (c-name "empathy_cell_renderer_expander_get_type") + (return-type "GType") +) + +(define-function empathy_cell_renderer_expander_new + (c-name "empathy_cell_renderer_expander_new") + (is-constructor-of "EmpathyCellRendererExpander") + (return-type "GtkCellRenderer*") +) + + + +;; From empathy-cell-renderer-text.h + +(define-function empathy_cell_renderer_text_get_type + (c-name "empathy_cell_renderer_text_get_type") + (return-type "GType") +) + +(define-function empathy_cell_renderer_text_new + (c-name "empathy_cell_renderer_text_new") + (is-constructor-of "EmpathyCellRendererText") + (return-type "GtkCellRenderer*") +) + + + +;; From empathy-chat.h + +(define-function empathy_chat_get_type + (c-name "empathy_chat_get_type") + (return-type "GType") +) + +(define-method get_view + (of-object "EmpathyChat") + (c-name "empathy_chat_get_view") + (return-type "EmpathyChatView*") +) + +(define-method get_window + (of-object "EmpathyChat") + (c-name "empathy_chat_get_window") + (return-type "EmpathyChatWindow*") +) + +(define-method set_window + (of-object "EmpathyChat") + (c-name "empathy_chat_set_window") + (return-type "none") + (parameters + '("EmpathyChatWindow*" "window") + ) +) + +(define-method present + (of-object "EmpathyChat") + (c-name "empathy_chat_present") + (return-type "none") +) + +(define-method clear + (of-object "EmpathyChat") + (c-name "empathy_chat_clear") + (return-type "none") +) + +(define-method scroll_down + (of-object "EmpathyChat") + (c-name "empathy_chat_scroll_down") + (return-type "none") +) + +(define-method cut + (of-object "EmpathyChat") + (c-name "empathy_chat_cut") + (return-type "none") +) + +(define-method copy + (of-object "EmpathyChat") + (c-name "empathy_chat_copy") + (return-type "none") +) + +(define-method paste + (of-object "EmpathyChat") + (c-name "empathy_chat_paste") + (return-type "none") +) + +(define-method get_name + (of-object "EmpathyChat") + (c-name "empathy_chat_get_name") + (return-type "const-gchar*") +) + +(define-method get_tooltip + (of-object "EmpathyChat") + (c-name "empathy_chat_get_tooltip") + (return-type "gchar*") +) + +(define-method get_status_icon_name + (of-object "EmpathyChat") + (c-name "empathy_chat_get_status_icon_name") + (return-type "const-gchar*") +) + +(define-method get_widget + (of-object "EmpathyChat") + (c-name "empathy_chat_get_widget") + (return-type "GtkWidget*") +) + +(define-method is_group_chat + (of-object "EmpathyChat") + (c-name "empathy_chat_is_group_chat") + (return-type "gboolean") +) + +(define-method is_connected + (of-object "EmpathyChat") + (c-name "empathy_chat_is_connected") + (return-type "gboolean") +) + +(define-method save_geometry + (of-object "EmpathyChat") + (c-name "empathy_chat_save_geometry") + (return-type "none") + (parameters + '("gint" "x") + '("gint" "y") + '("gint" "w") + '("gint" "h") + ) +) + +(define-method load_geometry + (of-object "EmpathyChat") + (c-name "empathy_chat_load_geometry") + (return-type "none") + (parameters + '("gint*" "x") + '("gint*" "y") + '("gint*" "w") + '("gint*" "h") + ) +) + +(define-method set_tp_chat + (of-object "EmpathyChat") + (c-name "empathy_chat_set_tp_chat") + (return-type "none") + (parameters + '("EmpathyTpChat*" "tp_chat") + ) +) + +(define-method get_id + (of-object "EmpathyChat") + (c-name "empathy_chat_get_id") + (return-type "const-gchar*") +) + +(define-function empathy_chat_get_is_command + (c-name "empathy_chat_get_is_command") + (return-type "gboolean") + (parameters + '("const-gchar*" "str") + ) +) + +(define-method correct_word + (of-object "EmpathyChat") + (c-name "empathy_chat_correct_word") + (return-type "none") + (parameters + '("GtkTextIter" "start") + '("GtkTextIter" "end") + '("const-gchar*" "new_word") + ) +) + +(define-method should_play_sound + (of-object "EmpathyChat") + (c-name "empathy_chat_should_play_sound") + (return-type "gboolean") +) + +(define-function empathy_chat_should_highlight_nick + (c-name "empathy_chat_should_highlight_nick") + (return-type "gboolean") + (parameters + '("EmpathyMessage*" "message") + ) +) + + + +;; From empathy-chatrooms-window.h + +(define-function empathy_chatrooms_window_show + (c-name "empathy_chatrooms_window_show") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-chat-view.h + +(define-function empathy_chat_view_get_type + (c-name "empathy_chat_view_get_type") + (return-type "GType") +) + +(define-function empathy_chat_view_new + (c-name "empathy_chat_view_new") + (is-constructor-of "EmpathyChatView") + (return-type "EmpathyChatView*") +) + +(define-method append_message + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_append_message") + (return-type "none") + (parameters + '("EmpathyMessage*" "msg") + ) +) + +(define-method append_event + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_append_event") + (return-type "none") + (parameters + '("const-gchar*" "str") + ) +) + +(define-method append_button + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_append_button") + (return-type "none") + (parameters + '("const-gchar*" "message") + '("GtkWidget*" "button1") + '("GtkWidget*" "button2") + ) +) + +(define-method set_margin + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_set_margin") + (return-type "none") + (parameters + '("gint" "margin") + ) +) + +(define-method scroll + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_scroll") + (return-type "none") + (parameters + '("gboolean" "allow_scrolling") + ) +) + +(define-method scroll_down + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_scroll_down") + (return-type "none") +) + +(define-method get_selection_bounds + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_get_selection_bounds") + (return-type "gboolean") + (parameters + '("GtkTextIter*" "start") + '("GtkTextIter*" "end") + ) +) + +(define-method clear + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_clear") + (return-type "none") +) + +(define-method find_previous + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_find_previous") + (return-type "gboolean") + (parameters + '("const-gchar*" "search_criteria") + '("gboolean" "new_search") + ) +) + +(define-method find_next + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_find_next") + (return-type "gboolean") + (parameters + '("const-gchar*" "search_criteria") + '("gboolean" "new_search") + ) +) + +(define-method find_abilities + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_find_abilities") + (return-type "none") + (parameters + '("const-gchar*" "search_criteria") + '("gboolean*" "can_do_previous") + '("gboolean*" "can_do_next") + ) +) + +(define-method highlight + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_highlight") + (return-type "none") + (parameters + '("const-gchar*" "text") + ) +) + +(define-method copy_clipboard + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_copy_clipboard") + (return-type "none") +) + +(define-method get_irc_style + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_get_irc_style") + (return-type "gboolean") +) + +(define-method set_irc_style + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_set_irc_style") + (return-type "none") + (parameters + '("gboolean" "irc_style") + ) +) + +(define-method set_margin + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_set_margin") + (return-type "none") + (parameters + '("gint" "margin") + ) +) + +(define-function empathy_chat_view_get_smiley_image + (c-name "empathy_chat_view_get_smiley_image") + (return-type "GdkPixbuf*") + (parameters + '("EmpathySmiley" "smiley") + ) +) + +(define-function empathy_chat_view_get_smiley_text + (c-name "empathy_chat_view_get_smiley_text") + (return-type "const-gchar*") + (parameters + '("EmpathySmiley" "smiley") + ) +) + +(define-function empathy_chat_view_get_smiley_menu + (c-name "empathy_chat_view_get_smiley_menu") + (return-type "GtkWidget*") + (parameters + '("GCallback" "callback") + '("gpointer" "user_data") + '("GtkTooltips*" "tooltips") + ) +) + +(define-method set_is_group_chat + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_set_is_group_chat") + (return-type "none") + (parameters + '("gboolean" "is_group_chat") + ) +) + + + +;; From empathy-chat-window.h + +(define-function empathy_chat_window_get_type + (c-name "empathy_chat_window_get_type") + (return-type "GType") +) + +(define-function empathy_chat_window_get_default + (c-name "empathy_chat_window_get_default") + (return-type "EmpathyChatWindow*") +) + +(define-function empathy_chat_window_new + (c-name "empathy_chat_window_new") + (is-constructor-of "EmpathyChatWindow") + (return-type "EmpathyChatWindow*") +) + +(define-method get_dialog + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_get_dialog") + (return-type "GtkWidget*") +) + +(define-method add_chat + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_add_chat") + (return-type "none") + (parameters + '("EmpathyChat*" "chat") + ) +) + +(define-method remove_chat + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_remove_chat") + (return-type "none") + (parameters + '("EmpathyChat*" "chat") + ) +) + +(define-method move_chat + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_move_chat") + (return-type "none") + (parameters + '("EmpathyChatWindow*" "new_window") + '("EmpathyChat*" "chat") + ) +) + +(define-method switch_to_chat + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_switch_to_chat") + (return-type "none") + (parameters + '("EmpathyChat*" "chat") + ) +) + +(define-method has_focus + (of-object "EmpathyChatWindow") + (c-name "empathy_chat_window_has_focus") + (return-type "gboolean") +) + +(define-function empathy_chat_window_find_chat + (c-name "empathy_chat_window_find_chat") + (return-type "EmpathyChat*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "id") + ) +) + + + +;; From empathy-contact-dialogs.h + +(define-function empathy_subscription_dialog_show + (c-name "empathy_subscription_dialog_show") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("GtkWindow*" "parent") + ) +) + +(define-method information_dialog_show + (of-object "EmpathyContact") + (c-name "empathy_contact_information_dialog_show") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + '("gboolean" "edit") + ) +) + +(define-function empathy_new_contact_dialog_show + (c-name "empathy_new_contact_dialog_show") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-contact-groups.h + +(define-function empathy_contact_groups_get_all + (c-name "empathy_contact_groups_get_all") + (return-type "none") +) + +(define-function empathy_contact_group_get_expanded + (c-name "empathy_contact_group_get_expanded") + (return-type "gboolean") + (parameters + '("const-gchar*" "group") + ) +) + +(define-function empathy_contact_group_set_expanded + (c-name "empathy_contact_group_set_expanded") + (return-type "none") + (parameters + '("const-gchar*" "group") + '("gboolean" "expanded") + ) +) + + + +;; From empathy-contact-list-store.h + +(define-function empathy_contact_list_store_get_type + (c-name "empathy_contact_list_store_get_type") + (return-type "GType") +) + +(define-method store_new + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_store_new") + (return-type "EmpathyContactListStore*") +) + +(define-method get_list_iface + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_list_iface") + (return-type "EmpathyContactList*") +) + +(define-method get_show_offline + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_show_offline") + (return-type "gboolean") +) + +(define-method set_show_offline + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_show_offline") + (return-type "none") + (parameters + '("gboolean" "show_offline") + ) +) + +(define-method get_show_avatars + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_show_avatars") + (return-type "gboolean") +) + +(define-method set_show_avatars + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_show_avatars") + (return-type "none") + (parameters + '("gboolean" "show_avatars") + ) +) + +(define-method get_is_compact + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_is_compact") + (return-type "gboolean") +) + +(define-method set_is_compact + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_is_compact") + (return-type "none") + (parameters + '("gboolean" "is_compact") + ) +) + +(define-method get_sort_criterium + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_sort_criterium") + (return-type "EmpathyContactListStoreSort") +) + +(define-method set_sort_criterium + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_sort_criterium") + (return-type "none") + (parameters + '("EmpathyContactListStoreSort" "sort_criterium") + ) +) + +(define-function empathy_contact_list_store_row_separator_func + (c-name "empathy_contact_list_store_row_separator_func") + (return-type "gboolean") + (parameters + '("GtkTreeModel*" "model") + '("GtkTreeIter*" "iter") + '("gpointer" "data") + ) +) + +(define-function empathy_contact_list_store_get_parent_group + (c-name "empathy_contact_list_store_get_parent_group") + (return-type "gchar*") + (parameters + '("GtkTreeModel*" "model") + '("GtkTreePath*" "path") + '("gboolean*" "path_is_group") + ) +) + +(define-function empathy_contact_list_store_search_equal_func + (c-name "empathy_contact_list_store_search_equal_func") + (return-type "gboolean") + (parameters + '("GtkTreeModel*" "model") + '("gint" "column") + '("const-gchar*" "key") + '("GtkTreeIter*" "iter") + '("gpointer" "search_data") + ) +) + +(define-method set_contact_groups_func + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_contact_groups_func") + (return-type "none") + (parameters + '("EmpathyContactGroupsFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method update_contact_groups + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_update_contact_groups") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + + + +;; From empathy-contact-list-view.h + +(define-function empathy_contact_list_view_get_type + (c-name "empathy_contact_list_view_get_type") + (return-type "GType") +) + +(define-function empathy_contact_list_view_new + (c-name "empathy_contact_list_view_new") + (is-constructor-of "EmpathyContactListView") + (return-type "EmpathyContactListView*") + (parameters + '("EmpathyContactListStore*" "store") + ) +) + +(define-method get_selected + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_get_selected") + (return-type "EmpathyContact*") +) + +(define-method get_selected_group + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_get_selected_group") + (return-type "gchar*") +) + +(define-method get_contact_menu + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_get_contact_menu") + (return-type "GtkWidget*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method get_group_menu + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_get_group_menu") + (return-type "GtkWidget*") +) + +(define-method set_filter + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_set_filter") + (return-type "none") + (parameters + '("const-gchar*" "filter") + ) +) + +(define-method set_drag_received_func + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_set_drag_received_func") + (return-type "none") + (parameters + '("EmpathyContactListViewDragReceivedFunc" "func") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-contact-widget.h + +(define-method widget_new + (of-object "EmpathyContact") + (c-name "empathy_contact_widget_new") + (return-type "GtkWidget*") + (parameters + '("EmpathyContactWidgetType" "type") + ) +) + +(define-function empathy_contact_widget_get_contact + (c-name "empathy_contact_widget_get_contact") + (return-type "EmpathyContact*") + (parameters + '("GtkWidget*" "widget") + ) +) + + + +;; From empathy-geometry.h + +(define-function empathy_geometry_save + (c-name "empathy_geometry_save") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("gint" "x") + '("gint" "y") + '("gint" "w") + '("gint" "h") + ) +) + +(define-function empathy_geometry_load + (c-name "empathy_geometry_load") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("gint*" "x") + '("gint*" "y") + '("gint*" "w") + '("gint*" "h") + ) +) + + + +;; From empathy-group-chat.h + +(define-function empathy_group_chat_get_type + (c-name "empathy_group_chat_get_type") + (return-type "GType") +) + +(define-function empathy_group_chat_new + (c-name "empathy_group_chat_new") + (is-constructor-of "EmpathyGroupChat") + (return-type "EmpathyGroupChat*") + (parameters + '("McAccount*" "account") + '("TpChan*" "tp_chan") + ) +) + +(define-method get_show_contacts + (of-object "EmpathyGroupChat") + (c-name "empathy_group_chat_get_show_contacts") + (return-type "gboolean") +) + +(define-method set_show_contacts + (of-object "EmpathyGroupChat") + (c-name "empathy_group_chat_set_show_contacts") + (return-type "none") + (parameters + '("gboolean" "show") + ) +) + +(define-method set_topic + (of-object "EmpathyGroupChat") + (c-name "empathy_group_chat_set_topic") + (return-type "none") +) + + + +;; From empathy-images.h + + + +;; From empathy-log-window.h + +(define-function empathy_log_window_show + (c-name "empathy_log_window_show") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-main-window.h + +(define-function empathy_main_window_show + (c-name "empathy_main_window_show") + (return-type "GtkWidget*") +) + + + +;; From empathy-new-chatroom-dialog.h + +(define-function empathy_new_chatroom_dialog_show + (c-name "empathy_new_chatroom_dialog_show") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-preferences.h + +(define-function empathy_preferences_show + (c-name "empathy_preferences_show") + (return-type "GtkWidget*") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-presence-chooser.h + +(define-function empathy_presence_chooser_get_type + (c-name "empathy_presence_chooser_get_type") + (return-type "GType") +) + +(define-function empathy_presence_chooser_new + (c-name "empathy_presence_chooser_new") + (is-constructor-of "EmpathyPresenceChooser") + (return-type "GtkWidget*") +) + +(define-function empathy_presence_chooser_create_menu + (c-name "empathy_presence_chooser_create_menu") + (return-type "GtkWidget*") +) + + + +;; From empathy-private-chat.h + +(define-function empathy_private_chat_get_type + (c-name "empathy_private_chat_get_type") + (return-type "GType") +) + +(define-function empathy_private_chat_new + (c-name "empathy_private_chat_new") + (is-constructor-of "EmpathyPrivateChat") + (return-type "EmpathyPrivateChat*") + (parameters + '("McAccount*" "account") + '("TpChan*" "tp_chan") + ) +) + +(define-function empathy_private_chat_new_with_contact + (c-name "empathy_private_chat_new_with_contact") + (return-type "EmpathyPrivateChat*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method get_contact + (of-object "EmpathyPrivateChat") + (c-name "empathy_private_chat_get_contact") + (return-type "EmpathyContact*") +) + + + +;; From empathy-profile-chooser.h + +(define-function empathy_profile_chooser_new + (c-name "empathy_profile_chooser_new") + (is-constructor-of "EmpathyProfileChooser") + (return-type "GtkWidget*") +) + +(define-function empathy_profile_chooser_get_selected + (c-name "empathy_profile_chooser_get_selected") + (return-type "McProfile*") + (parameters + '("GtkWidget*" "widget") + ) +) + + + +;; From empathy-spell-dialog.h + +(define-function empathy_spell_dialog_show + (c-name "empathy_spell_dialog_show") + (return-type "none") + (parameters + '("EmpathyChat*" "chat") + '("GtkTextIter" "start") + '("GtkTextIter" "end") + '("const-gchar*" "word") + ) +) + + + +;; From empathy-spell.h + +(define-function empathy_spell_supported + (c-name "empathy_spell_supported") + (return-type "gboolean") +) + +(define-function empathy_spell_get_language_name + (c-name "empathy_spell_get_language_name") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "code") + ) +) + +(define-function empathy_spell_get_language_codes + (c-name "empathy_spell_get_language_codes") + (return-type "GList*") +) + +(define-function empathy_spell_free_language_codes + (c-name "empathy_spell_free_language_codes") + (return-type "none") + (parameters + '("GList*" "codes") + ) +) + +(define-function empathy_spell_check + (c-name "empathy_spell_check") + (return-type "gboolean") + (parameters + '("const-gchar*" "word") + ) +) + +(define-function empathy_spell_get_suggestions + (c-name "empathy_spell_get_suggestions") + (return-type "GList*") + (parameters + '("const-gchar*" "word") + ) +) + +(define-function empathy_spell_free_suggestions + (c-name "empathy_spell_free_suggestions") + (return-type "none") + (parameters + '("GList*" "suggestions") + ) +) + + + +;; From empathy-status-icon.h + +(define-function empathy_status_icon_get_type + (c-name "empathy_status_icon_get_type") + (return-type "GType") +) + +(define-function empathy_status_icon_new + (c-name "empathy_status_icon_new") + (is-constructor-of "EmpathyStatusIcon") + (return-type "EmpathyStatusIcon*") + (parameters + '("GtkWindow*" "window") + ) +) + + + +;; From empathy-status-presets.h + +(define-function empathy_status_presets_get_all + (c-name "empathy_status_presets_get_all") + (return-type "none") +) + +(define-function empathy_status_presets_get + (c-name "empathy_status_presets_get") + (return-type "GList*") + (parameters + '("McPresence" "state") + '("gint" "max_number") + ) +) + +(define-function empathy_status_presets_set_last + (c-name "empathy_status_presets_set_last") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_remove + (c-name "empathy_status_presets_remove") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_reset + (c-name "empathy_status_presets_reset") + (return-type "none") +) + +(define-function empathy_status_presets_get_default_state + (c-name "empathy_status_presets_get_default_state") + (return-type "McPresence") +) + +(define-function empathy_status_presets_get_default_status + (c-name "empathy_status_presets_get_default_status") + (return-type "const-gchar*") +) + +(define-function empathy_status_presets_set_default + (c-name "empathy_status_presets_set_default") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_clear_default + (c-name "empathy_status_presets_clear_default") + (return-type "none") +) + + + +;; From empathy-theme-manager.h + +(define-function empathy_theme_manager_get_type + (c-name "empathy_theme_manager_get_type") + (return-type "GType") +) + +(define-function empathy_theme_manager_get + (c-name "empathy_theme_manager_get") + (return-type "EmpathyThemeManager*") +) + +(define-function empathy_theme_manager_get_themes + (c-name "empathy_theme_manager_get_themes") + (return-type "const-gchar**") +) + +(define-method apply + (of-object "EmpathyThemeManager") + (c-name "empathy_theme_manager_apply") + (return-type "none") + (parameters + '("EmpathyChatView*" "view") + '("const-gchar*" "theme") + ) +) + +(define-method apply_saved + (of-object "EmpathyThemeManager") + (c-name "empathy_theme_manager_apply_saved") + (return-type "none") + (parameters + '("EmpathyChatView*" "view") + ) +) + +(define-method update_show_avatars + (of-object "EmpathyThemeManager") + (c-name "empathy_theme_manager_update_show_avatars") + (return-type "none") + (parameters + '("EmpathyChatView*" "view") + '("gboolean" "show") + ) +) + + + +;; From empathy-ui-utils.h + +(define-function empathy_glade_get_file_simple + (c-name "empathy_glade_get_file_simple") + (return-type "none") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "root") + '("const-gchar*" "domain") + '("const-gchar*" "first_required_widget") + ) + (varargs #t) +) + +(define-function empathy_glade_get_file + (c-name "empathy_glade_get_file") + (return-type "GladeXML*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "root") + '("const-gchar*" "domain") + '("const-gchar*" "first_required_widget") + ) + (varargs #t) +) + +(define-function empathy_glade_connect + (c-name "empathy_glade_connect") + (return-type "none") + (parameters + '("GladeXML*" "gui") + '("gpointer" "user_data") + '("gchar*" "first_widget") + ) + (varargs #t) +) + +(define-function empathy_glade_setup_size_group + (c-name "empathy_glade_setup_size_group") + (return-type "none") + (parameters + '("GladeXML*" "gui") + '("GtkSizeGroupMode" "mode") + '("gchar*" "first_widget") + ) + (varargs #t) +) + +(define-function empathy_pixbuf_from_icon_name + (c-name "empathy_pixbuf_from_icon_name") + (return-type "GdkPixbuf*") + (parameters + '("const-gchar*" "icon_name") + '("GtkIconSize" "icon_size") + ) +) + +(define-function empathy_pixbuf_from_smiley + (c-name "empathy_pixbuf_from_smiley") + (return-type "GdkPixbuf*") + (parameters + '("EmpathySmiley" "type") + '("GtkIconSize" "icon_size") + ) +) + +(define-function empathy_icon_name_from_account + (c-name "empathy_icon_name_from_account") + (return-type "const-gchar*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function empathy_icon_name_for_presence_state + (c-name "empathy_icon_name_for_presence_state") + (return-type "const-gchar*") + (parameters + '("McPresence" "state") + ) +) + +(define-function empathy_icon_name_for_presence + (c-name "empathy_icon_name_for_presence") + (return-type "const-gchar*") + (parameters + '("EmpathyPresence*" "presence") + ) +) + +(define-function empathy_icon_name_for_contact + (c-name "empathy_icon_name_for_contact") + (return-type "const-gchar*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function empathy_pixbuf_from_avatar_scaled + (c-name "empathy_pixbuf_from_avatar_scaled") + (return-type "GdkPixbuf*") + (parameters + '("EmpathyAvatar*" "avatar") + '("gint" "width") + '("gint" "height") + ) +) + +(define-function empathy_pixbuf_avatar_from_contact_scaled + (c-name "empathy_pixbuf_avatar_from_contact_scaled") + (return-type "GdkPixbuf*") + (parameters + '("EmpathyContact*" "contact") + '("gint" "width") + '("gint" "height") + ) +) + +(define-function empathy_text_iter_forward_search + (c-name "empathy_text_iter_forward_search") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "iter") + '("const-gchar*" "str") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + '("const-GtkTextIter*" "limit") + ) +) + +(define-function empathy_text_iter_backward_search + (c-name "empathy_text_iter_backward_search") + (return-type "gboolean") + (parameters + '("const-GtkTextIter*" "iter") + '("const-gchar*" "str") + '("GtkTextIter*" "match_start") + '("GtkTextIter*" "match_end") + '("const-GtkTextIter*" "limit") + ) +) + +(define-function empathy_window_get_is_visible + (c-name "empathy_window_get_is_visible") + (return-type "gboolean") + (parameters + '("GtkWindow*" "window") + ) +) + +(define-function empathy_window_present + (c-name "empathy_window_present") + (return-type "none") + (parameters + '("GtkWindow*" "window") + '("gboolean" "steal_focus") + ) +) + +(define-function empathy_window_iconify + (c-name "empathy_window_iconify") + (return-type "none") + (parameters + '("GtkWindow*" "window") + '("GtkStatusIcon*" "status_icon") + ) +) + +(define-function empathy_get_toplevel_window + (c-name "empathy_get_toplevel_window") + (return-type "GtkWindow*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-function empathy_url_show + (c-name "empathy_url_show") + (return-type "none") + (parameters + '("const-char*" "url") + ) +) + +(define-function empathy_toggle_button_set_state_quietly + (c-name "empathy_toggle_button_set_state_quietly") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("GCallback" "callback") + '("gpointer" "user_data") + '("gboolean" "active") + ) +) + +(define-function empathy_link_button_new + (c-name "empathy_link_button_new") + (is-constructor-of "EmpathyLinkButton") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "url") + '("const-gchar*" "title") + ) +) + + + +;; From ephy-spinner.h + +(define-function ephy_spinner_get_type + (c-name "ephy_spinner_get_type") + (return-type "GType") +) + +(define-function ephy_spinner_new + (c-name "ephy_spinner_new") + (is-constructor-of "EphySpinner") + (return-type "GtkWidget*") +) + +(define-method start + (of-object "EphySpinner") + (c-name "ephy_spinner_start") + (return-type "none") +) + +(define-method stop + (of-object "EphySpinner") + (c-name "ephy_spinner_stop") + (return-type "none") +) + +(define-method set_size + (of-object "EphySpinner") + (c-name "ephy_spinner_set_size") + (return-type "none") + (parameters + '("GtkIconSize" "size") + ) +) + + diff --git a/python/pyempathygtk/pyempathygtk.override b/python/pyempathygtk/pyempathygtk.override new file mode 100644 index 000000000..8b3f22d5e --- /dev/null +++ b/python/pyempathygtk/pyempathygtk.override @@ -0,0 +1,77 @@ +%% +headers +#include <Python.h> +#include <pygobject.h> +#include "empathy-about-dialog.h" +#include "empathy-account-chooser.h" +#include "empathy-accounts-dialog.h" +#include "empathy-account-widget-generic.h" +#include "empathy-account-widget-jabber.h" +#include "empathy-account-widget-msn.h" +#include "empathy-cell-renderer-expander.h" +#include "empathy-cell-renderer-text.h" +#include "empathy-chat.h" +#include "empathy-chatrooms-window.h" +#include "empathy-chat-view.h" +#include "empathy-chat-window.h" +#include "empathy-contact-dialogs.h" +#include "empathy-contact-groups.h" +#include "empathy-contact-list-store.h" +#include "empathy-contact-list-view.h" +#include "empathy-contact-widget.h" +#include "empathy-geometry.h" +#include "empathy-group-chat.h" +#include "empathy-images.h" +#include "empathy-log-window.h" +#include "empathy-main-window.h" +#include "empathy-new-chatroom-dialog.h" +#include "empathy-preferences.h" +#include "empathy-presence-chooser.h" +#include "empathy-private-chat.h" +#include "empathy-profile-chooser.h" +#include "empathy-spell-dialog.h" +#include "empathy-spell.h" +#include "empathy-status-icon.h" +#include "empathy-status-presets.h" +#include "empathy-theme-manager.h" +#include "empathy-ui-utils.h" +#include "ephy-spinner.h" + +/* FIXME */ +#define EMPATHY_TYPE_SMILEY 1 +#define EMPATHY_TYPE_CONTACT_LIST_STORE_COL 2 +#define EMPATHY_TYPE_CONTACT_LIST_STORE_SORT 3 +#define EMPATHY_TYPE_CONTACT_WIDGET_TYPE 4 + +void empathy_add_constants(PyObject *module, const gchar *strip_prefix); +void empathy_register_classes(PyObject *d); +%% +modulename empathygtk +%% +import gobject.GObject as PyGObject_Type +import gtk.Widget as PyGtkWidget_Type +import gtk.Window as PyGtkWindow_Type +import gtk.CellRenderer as PyGtkCellRenderer_Type +import gtk.CellRendererText as PyGtkCellRendererText_Type +import gtk.TextView as PyGtkTextView_Type +import gtk.TreeView as PyGtkTreeView_Type +import gtk.TreeStore as PyGtkTreeStore_Type +import gtk.ToggleButton as PyGtkToggleButton_Type +import gtk.ComboBox as PyGtkComboBox_Type +import gtk.StatusIcon as PyGtkStatusIcon_Type +import empathy.Contact as PyEmpathyContact_Type +import empathy.ContactList as PyEmpathyContactList_Type +import empathy.TpChat as PyEmpathyTpChat_Type +import empathy.Presence as PyEmpathyPresence_Type +import empathy.Message as PyEmpathyMessage_Type +%% +ignore-glob + *_get_type +%% +ignore + empathy_chat_correct_word + empathy_chat_view_set_margin + empathy_chat_get_view + empathy_spell_dialog_show + empathy_window_iconify +%% diff --git a/python/pyempathygtk/pyempathygtkmodule.c b/python/pyempathygtk/pyempathygtkmodule.c new file mode 100644 index 000000000..4f751f08d --- /dev/null +++ b/python/pyempathygtk/pyempathygtkmodule.c @@ -0,0 +1,23 @@ +#include <pygobject.h> + +void empathy_register_classes (PyObject *d); +DL_EXPORT(void) initempathygtk(void); +extern PyMethodDef empathy_functions[]; + +DL_EXPORT(void) initempathygtk(void) +{ + PyObject *m, *d; + + init_pygobject (); + + m = Py_InitModule ("empathygtk", empathy_functions); + d = PyModule_GetDict (m); + + empathy_register_classes (d); + + if (PyErr_Occurred ()) { + PyErr_Print(); + Py_FatalError ("can't initialise module empathygtk"); + } +} + |