diff options
author | Xavier Claessens <xclaesse@src.gnome.org> | 2009-03-17 02:34:54 +0800 |
---|---|---|
committer | Xavier Claessens <xclaesse@src.gnome.org> | 2009-03-17 02:34:54 +0800 |
commit | 2baaa7ae3c3ac983a8019cd93a73426c7e081735 (patch) | |
tree | 482c49b5b4f5b3d6b4427642ba8609114503fade /gnome-2-26/python | |
parent | bbacde3ff32a1983e7f37eea2986ccfe8f660f3f (diff) | |
download | gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar.gz gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar.bz2 gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar.lz gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar.xz gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.tar.zst gsoc2013-empathy-2baaa7ae3c3ac983a8019cd93a73426c7e081735.zip |
Tagged for release 2.26.0.
svn path=/tags/EMPATHY_2_26_0/; revision=2700
Diffstat (limited to 'gnome-2-26/python')
-rw-r--r-- | gnome-2-26/python/.gitignore | 2 | ||||
-rw-r--r-- | gnome-2-26/python/Makefile.am | 2 | ||||
-rwxr-xr-x | gnome-2-26/python/example.py | 31 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathy.patch | 18 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathy/Makefile.am | 45 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathy/pyempathy.defs | 2904 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathy/pyempathy.override | 90 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathy/pyempathymodule.c | 28 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathygtk.patch | 18 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathygtk/Makefile.am | 46 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathygtk/pyempathygtk.defs | 2010 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathygtk/pyempathygtk.override | 79 | ||||
-rw-r--r-- | gnome-2-26/python/pyempathygtk/pyempathygtkmodule.c | 27 | ||||
-rwxr-xr-x | gnome-2-26/python/update-binding.sh | 106 |
14 files changed, 5406 insertions, 0 deletions
diff --git a/gnome-2-26/python/.gitignore b/gnome-2-26/python/.gitignore new file mode 100644 index 000000000..19cea19bb --- /dev/null +++ b/gnome-2-26/python/.gitignore @@ -0,0 +1,2 @@ +pyempathy.c +pyempathygtk.c diff --git a/gnome-2-26/python/Makefile.am b/gnome-2-26/python/Makefile.am new file mode 100644 index 000000000..5050f1b86 --- /dev/null +++ b/gnome-2-26/python/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS = pyempathy pyempathygtk + diff --git a/gnome-2-26/python/example.py b/gnome-2-26/python/example.py new file mode 100755 index 000000000..cffd5fffb --- /dev/null +++ b/gnome-2-26/python/example.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python + +import gtk +import empathy +import empathygtk + +class HelloWorld: + + def destroy(self, widget, data=None): + print "destroy signal occurred" + gtk.main_quit() + + def __init__(self): + self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) + self.window.connect("destroy", self.destroy) + + manager = empathy.ContactManager() + store = empathygtk.ContactListStore(manager) + view = empathygtk.ContactListView(store, 0) + + self.window.add (view) + view.show() + self.window.show() + + def main(self): + gtk.main() + +if __name__ == "__main__": + hello = HelloWorld() + hello.main() + diff --git a/gnome-2-26/python/pyempathy.patch b/gnome-2-26/python/pyempathy.patch new file mode 100644 index 000000000..06c4692c8 --- /dev/null +++ b/gnome-2-26/python/pyempathy.patch @@ -0,0 +1,18 @@ +--- /home/zdra/Desktop/pyempathy.defs 2008-04-02 11:08:02.000000000 +0200 ++++ pyempathy/pyempathy.defs 2008-04-02 11:28:00.000000000 +0200 +@@ -44,6 +44,7 @@ + (define-object ContactManager + (in-module "Empathy") + (parent "GObject") ++ (implements "EmpathyContactList") + (c-name "EmpathyContactManager") + (gtype-id "EMPATHY_TYPE_CONTACT_MANAGER") + ) +@@ -121,6 +122,7 @@ + (define-object TpContactList + (in-module "Empathy") + (parent "GObject") ++ (implements "EmpathyContactList") + (c-name "EmpathyTpContactList") + (gtype-id "EMPATHY_TYPE_TP_CONTACT_LIST") + ) diff --git a/gnome-2-26/python/pyempathy/Makefile.am b/gnome-2-26/python/pyempathy/Makefile.am new file mode 100644 index 000000000..fa973bf03 --- /dev/null +++ b/gnome-2-26/python/pyempathy/Makefile.am @@ -0,0 +1,45 @@ +PYDEFS=`pkg-config --variable=defsdir pygtk-2.0` + +AM_CPPFLAGS = \ + -I. \ + -I$(top_srcdir)/libempathy \ + -I$(top_builddir)/libempathy \ + -I$(top_srcdir) \ + -DDATADIR=\""$(datadir)"\" \ + $(PYTHON_BINDING_CFLAGS) \ + $(PYTHON_INCLUDES) \ + $(WARN_CFLAGS) + +BUILT_SOURCES = \ + pyempathy.c + +pyempathydir = $(pyexecdir) +pyempathy_LTLIBRARIES = empathy.la + +empathy_la_SOURCES = \ + pyempathymodule.c + +nodist_empathy_la_SOURCES = \ + pyempathy.c + +empathy_la_LIBADD = \ + $(PYTHON_BINDING_LIBS) \ + $(top_builddir)/libempathy/libempathy.la + +empathy_la_LDFLAGS = \ + -module -avoid-version + +pyempathy.c: pyempathy.override pyempathy.defs + $(PYGOBJECTCODEGEN) \ + --prefix empathy \ + --register $(PYDEFS)/gdk-types.defs \ + --register $(PYDEFS)/gtk-types.defs \ + --override $(srcdir)/pyempathy.override \ + $(srcdir)/pyempathy.defs > $@ + +EXTRA_DIST = \ + pyempathy.override \ + pyempathy.defs + +CLEANFILES = $(BUILT_SOURCES) + diff --git a/gnome-2-26/python/pyempathy/pyempathy.defs b/gnome-2-26/python/pyempathy/pyempathy.defs new file mode 100644 index 000000000..66a269784 --- /dev/null +++ b/gnome-2-26/python/pyempathy/pyempathy.defs @@ -0,0 +1,2904 @@ +;; -*- scheme -*- +; object definitions ... +(define-object AccountManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyAccountManager") + (gtype-id "EMPATHY_TYPE_ACCOUNT_MANAGER") +) + +(define-object CallFactory + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyCallFactory") + (gtype-id "EMPATHY_TYPE_CALL_FACTORY") +) + +(define-object CallHandler + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyCallHandler") + (gtype-id "EMPATHY_TYPE_CALL_HANDLER") +) + +(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 Contact + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyContact") + (gtype-id "EMPATHY_TYPE_CONTACT") +) + +(define-object ContactFactory + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyContactFactory") + (gtype-id "EMPATHY_TYPE_CONTACT_FACTORY") +) + +(define-interface ContactList + (in-module "Empathy") + (c-name "EmpathyContactList") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST") +) + +(define-object ContactManager + (in-module "Empathy") + (parent "GObject") + (implements "EmpathyContactList") + (c-name "EmpathyContactManager") + (gtype-id "EMPATHY_TYPE_CONTACT_MANAGER") +) + +(define-object ContactMonitor + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyContactMonitor") + (gtype-id "EMPATHY_TYPE_CONTACT_MONITOR") +) + +(define-object DispatchOperation + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyDispatchOperation") + (gtype-id "EMPATHY_TYPE_DISPATCH_OPERATION") +) + +(define-object Dispatcher + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyDispatcher") + (gtype-id "EMPATHY_TYPE_DISPATCHER") +) + +(define-object Idle + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyIdle") + (gtype-id "EMPATHY_TYPE_IDLE") +) + +(define-object IrcNetwork + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyIrcNetwork") + (gtype-id "EMPATHY_TYPE_IRC_NETWORK") +) + +(define-object IrcNetworkManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyIrcNetworkManager") + (gtype-id "EMPATHY_TYPE_IRC_NETWORK_MANAGER") +) + +(define-object IrcServer + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyIrcServer") + (gtype-id "EMPATHY_TYPE_IRC_SERVER") +) + +(define-object LogManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyLogManager") + (gtype-id "EMPATHY_TYPE_LOG_MANAGER") +) + +(define-object LogStoreEmpathy + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyLogStoreEmpathy") + (gtype-id "EMPATHY_TYPE_LOG_STORE_EMPATHY") +) + +(define-object Message + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyMessage") + (gtype-id "EMPATHY_TYPE_MESSAGE") +) + +(define-object TpCall + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpCall") + (gtype-id "EMPATHY_TYPE_TP_CALL") +) + +(define-object TpChat + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpChat") + (gtype-id "EMPATHY_TYPE_TP_CHAT") +) + +(define-object TpContactFactory + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpContactFactory") + (gtype-id "EMPATHY_TYPE_TP_CONTACT_FACTORY") +) + +(define-object TpContactList + (in-module "Empathy") + (parent "GObject") + (implements "EmpathyContactList") + (c-name "EmpathyTpContactList") + (gtype-id "EMPATHY_TYPE_TP_CONTACT_LIST") +) + +(define-object TpFile + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpFile") + (gtype-id "EMPATHY_TYPE_TP_FILE") +) + +(define-object TpGroup + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpGroup") + (gtype-id "EMPATHY_TYPE_TP_GROUP") +) + +(define-object TpRoomlist + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpRoomlist") + (gtype-id "EMPATHY_TYPE_TP_ROOMLIST") +) + +(define-object TpTube + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTpTube") + (gtype-id "EMPATHY_TYPE_TP_TUBE") +) + +(define-object TubeHandler + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyTubeHandler") + (gtype-id "EMPATHY_TYPE_TUBE_HANDLER") +) + +;; Enumerations and flags ... + +(define-flags Capabilities + (in-module "Empathy") + (c-name "EmpathyCapabilities") + (gtype-id "EMPATHY_TYPE_CAPABILITIES") + (values + '("none" "EMPATHY_CAPABILITIES_NONE") + '("audio" "EMPATHY_CAPABILITIES_AUDIO") + '("video" "EMPATHY_CAPABILITIES_VIDEO") + '("ft" "EMPATHY_CAPABILITIES_FT") + '("unknown" "EMPATHY_CAPABILITIES_UNKNOWN") + ) +) + +(define-flags ContactReady + (in-module "Empathy") + (c-name "EmpathyContactReady") + (gtype-id "EMPATHY_TYPE_CONTACT_READY") + (values + '("none" "EMPATHY_CONTACT_READY_NONE") + '("id" "EMPATHY_CONTACT_READY_ID") + '("handle" "EMPATHY_CONTACT_READY_HANDLE") + '("name" "EMPATHY_CONTACT_READY_NAME") + '("all" "EMPATHY_CONTACT_READY_ALL") + ) +) + +(define-flags DebugFlags + (in-module "Empathy") + (c-name "EmpathyDebugFlags") + (gtype-id "EMPATHY_TYPE_DEBUG_FLAGS") + (values + '("tp" "EMPATHY_DEBUG_TP") + '("chat" "EMPATHY_DEBUG_CHAT") + '("contact" "EMPATHY_DEBUG_CONTACT") + '("account" "EMPATHY_DEBUG_ACCOUNT") + '("irc" "EMPATHY_DEBUG_IRC") + '("dispatcher" "EMPATHY_DEBUG_DISPATCHER") + '("ft" "EMPATHY_DEBUG_FT") + '("other" "EMPATHY_DEBUG_OTHER") + ) +) + +(define-enum DispatchOperationState + (in-module "Empathy") + (c-name "EmpathyDispatchOperationState") + (gtype-id "EMPATHY_TYPE_DISPATCH_OPERATION_STATE") + (values + '("preparing" "EMPATHY_DISPATCHER_OPERATION_STATE_PREPARING") + '("pending" "EMPATHY_DISPATCHER_OPERATION_STATE_PENDING") + '("approving" "EMPATHY_DISPATCHER_OPERATION_STATE_APPROVING") + '("dispatching" "EMPATHY_DISPATCHER_OPERATION_STATE_DISPATCHING") + '("claimed" "EMPATHY_DISPATCHER_OPERATION_STATE_CLAIMED") + '("invalidated" "EMPATHY_DISPATCHER_OPERATION_STATE_INVALIDATED") + ) +) + +(define-enum TpCallStatus + (in-module "Empathy") + (c-name "EmpathyTpCallStatus") + (gtype-id "EMPATHY_TYPE_TP_CALL_STATUS") + (values + '("readying" "EMPATHY_TP_CALL_STATUS_READYING") + '("pending" "EMPATHY_TP_CALL_STATUS_PENDING") + '("accepted" "EMPATHY_TP_CALL_STATUS_ACCEPTED") + '("closed" "EMPATHY_TP_CALL_STATUS_CLOSED") + ) +) + + +;; From empathy-account-manager.h + +(define-function account_manager_get_type + (c-name "empathy_account_manager_get_type") + (return-type "GType") +) + +(define-function account_manager_dup_singleton + (c-name "empathy_account_manager_dup_singleton") + (return-type "EmpathyAccountManager*") +) + +(define-method get_connected_accounts + (of-object "EmpathyAccountManager") + (c-name "empathy_account_manager_get_connected_accounts") + (return-type "int") +) + +(define-method get_connecting_accounts + (of-object "EmpathyAccountManager") + (c-name "empathy_account_manager_get_connecting_accounts") + (return-type "int") +) + +(define-method is_account_just_connected + (of-object "EmpathyAccountManager") + (c-name "empathy_account_manager_is_account_just_connected") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_count + (of-object "EmpathyAccountManager") + (c-name "empathy_account_manager_get_count") + (return-type "int") +) + + + +;; From empathy-chatroom.h + +(define-function chatroom_get_type + (c-name "empathy_chatroom_get_type") + (return-type "GType") +) + +(define-function chatroom_new + (c-name "empathy_chatroom_new") + (is-constructor-of "EmpathyChatroom") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function 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 chatroom_equal + (c-name "empathy_chatroom_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-method get_tp_chat + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_tp_chat") + (return-type "EmpathyTpChat*") +) + + + +;; From empathy-chatroom-manager.h + +(define-function chatroom_manager_get_type + (c-name "empathy_chatroom_manager_get_type") + (return-type "GType") +) + +(define-function chatroom_manager_dup_singleton + (c-name "empathy_chatroom_manager_dup_singleton") + (return-type "EmpathyChatroomManager*") + (parameters + '("const-gchar*" "file") + ) +) + +(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 observe + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_observe") + (return-type "none") + (parameters + '("EmpathyDispatcher*" "dispatcher") + ) +) + + + +;; From empathy-call-factory.h + +(define-function call_factory_get_type + (c-name "empathy_call_factory_get_type") + (return-type "GType") +) + +(define-function call_factory_initialise + (c-name "empathy_call_factory_initialise") + (return-type "EmpathyCallFactory*") +) + +(define-function call_factory_get + (c-name "empathy_call_factory_get") + (return-type "EmpathyCallFactory*") +) + +(define-method new_call + (of-object "EmpathyCallFactory") + (c-name "empathy_call_factory_new_call") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method claim_channel + (of-object "EmpathyCallFactory") + (c-name "empathy_call_factory_claim_channel") + (return-type "none") + (parameters + '("EmpathyDispatchOperation*" "operation") + ) +) + + + +;; From empathy-call-handler.h + +(define-function call_handler_get_type + (c-name "empathy_call_handler_get_type") + (return-type "GType") +) + +(define-function call_handler_new_for_contact + (c-name "empathy_call_handler_new_for_contact") + (return-type "EmpathyCallHandler*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function call_handler_new_for_channel + (c-name "empathy_call_handler_new_for_channel") + (return-type "EmpathyCallHandler*") + (parameters + '("EmpathyTpCall*" "call") + ) +) + +(define-method start_call + (of-object "EmpathyCallHandler") + (c-name "empathy_call_handler_start_call") + (return-type "none") +) + +(define-method bus_message + (of-object "EmpathyCallHandler") + (c-name "empathy_call_handler_bus_message") + (return-type "none") + (parameters + '("GstBus*" "bus") + '("GstMessage*" "message") + ) +) + + + +;; From empathy-contact.h + +(define-function contact_get_type + (c-name "empathy_contact_get_type") + (return-type "GType") +) + +(define-function contact_new + (c-name "empathy_contact_new") + (is-constructor-of "EmpathyContact") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function 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 set_id + (of-object "EmpathyContact") + (c-name "empathy_contact_set_id") + (return-type "none") + (parameters + '("const-gchar*" "id") + ) +) + +(define-method get_name + (of-object "EmpathyContact") + (c-name "empathy_contact_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "EmpathyContact") + (c-name "empathy_contact_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_avatar + (of-object "EmpathyContact") + (c-name "empathy_contact_get_avatar") + (return-type "EmpathyAvatar*") +) + +(define-method set_avatar + (of-object "EmpathyContact") + (c-name "empathy_contact_set_avatar") + (return-type "none") + (parameters + '("EmpathyAvatar*" "avatar") + ) +) + +(define-method get_account + (of-object "EmpathyContact") + (c-name "empathy_contact_get_account") + (return-type "McAccount*") +) + +(define-method set_account + (of-object "EmpathyContact") + (c-name "empathy_contact_set_account") + (return-type "none") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_presence + (of-object "EmpathyContact") + (c-name "empathy_contact_get_presence") + (return-type "McPresence") +) + +(define-method set_presence + (of-object "EmpathyContact") + (c-name "empathy_contact_set_presence") + (return-type "none") + (parameters + '("McPresence" "presence") + ) +) + +(define-method get_presence_message + (of-object "EmpathyContact") + (c-name "empathy_contact_get_presence_message") + (return-type "const-gchar*") +) + +(define-method set_presence_message + (of-object "EmpathyContact") + (c-name "empathy_contact_set_presence_message") + (return-type "none") + (parameters + '("const-gchar*" "message") + ) +) + +(define-method get_handle + (of-object "EmpathyContact") + (c-name "empathy_contact_get_handle") + (return-type "guint") +) + +(define-method set_handle + (of-object "EmpathyContact") + (c-name "empathy_contact_set_handle") + (return-type "none") + (parameters + '("guint" "handle") + ) +) + +(define-method get_capabilities + (of-object "EmpathyContact") + (c-name "empathy_contact_get_capabilities") + (return-type "EmpathyCapabilities") +) + +(define-method set_capabilities + (of-object "EmpathyContact") + (c-name "empathy_contact_set_capabilities") + (return-type "none") + (parameters + '("EmpathyCapabilities" "capabilities") + ) +) + +(define-method get_ready + (of-object "EmpathyContact") + (c-name "empathy_contact_get_ready") + (return-type "EmpathyContactReady") +) + +(define-method is_user + (of-object "EmpathyContact") + (c-name "empathy_contact_is_user") + (return-type "gboolean") +) + +(define-method set_is_user + (of-object "EmpathyContact") + (c-name "empathy_contact_set_is_user") + (return-type "none") + (parameters + '("gboolean" "is_user") + ) +) + +(define-method is_online + (of-object "EmpathyContact") + (c-name "empathy_contact_is_online") + (return-type "gboolean") +) + +(define-method get_status + (of-object "EmpathyContact") + (c-name "empathy_contact_get_status") + (return-type "const-gchar*") +) + +(define-method can_voip + (of-object "EmpathyContact") + (c-name "empathy_contact_can_voip") + (return-type "gboolean") +) + +(define-method can_send_files + (of-object "EmpathyContact") + (c-name "empathy_contact_can_send_files") + (return-type "gboolean") +) + +(define-function contact_equal + (c-name "empathy_contact_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function contact_hash + (c-name "empathy_contact_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method call_when_ready + (of-object "EmpathyContact") + (c-name "empathy_contact_call_when_ready") + (return-type "none") + (parameters + '("EmpathyContactReady" "ready") + '("EmpathyContactReadyCb*" "callback") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy") + '("GObject*" "weak_object") + ) +) + +(define-method run_until_ready + (of-object "EmpathyContact") + (c-name "empathy_contact_run_until_ready") + (return-type "none") + (parameters + '("EmpathyContactReady" "ready") + '("GMainLoop**" "loop") + ) +) + +(define-method load_avatar_data + (of-object "EmpathyContact") + (c-name "empathy_contact_load_avatar_data") + (return-type "none") + (parameters + '("const-guchar*" "data") + '("const-gsize" "len") + '("const-gchar*" "format") + '("const-gchar*" "token") + ) +) + +(define-method load_avatar_cache + (of-object "EmpathyContact") + (c-name "empathy_contact_load_avatar_cache") + (return-type "gboolean") + (parameters + '("const-gchar*" "token") + ) +) + +(define-function avatar_get_type + (c-name "empathy_avatar_get_type") + (return-type "GType") +) + +(define-function avatar_new + (c-name "empathy_avatar_new") + (is-constructor-of "EmpathyAvatar") + (return-type "EmpathyAvatar*") + (parameters + '("guchar*" "data") + '("gsize" "len") + '("gchar*" "format") + '("gchar*" "token") + ) +) + +(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") +) + +(define-method save_to_file + (of-object "EmpathyAvatar") + (c-name "empathy_avatar_save_to_file") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("GError**" "error") + ) +) + + + +;; From empathy-contact-factory.h + +(define-function contact_factory_get_type + (c-name "empathy_contact_factory_get_type") + (return-type "GType") +) + +(define-function contact_factory_dup_singleton + (c-name "empathy_contact_factory_dup_singleton") + (return-type "EmpathyContactFactory*") +) + +(define-method get_tp_factory + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_get_tp_factory") + (return-type "EmpathyTpContactFactory*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_user + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_get_user") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_from_id + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_get_from_id") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "id") + ) +) + +(define-method get_from_handle + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_get_from_handle") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + '("guint" "handle") + ) +) + +(define-method get_from_handles + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_get_from_handles") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-GArray*" "handles") + ) +) + +(define-method set_alias + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_set_alias") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "alias") + ) +) + +(define-method set_avatar + (of-object "EmpathyContactFactory") + (c-name "empathy_contact_factory_set_avatar") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "data") + '("gsize" "size") + '("const-gchar*" "mime_type") + ) +) + + + +;; From empathy-contact-groups.h + +(define-function contact_groups_get_all + (c-name "empathy_contact_groups_get_all") + (return-type "none") +) + +(define-function contact_group_get_expanded + (c-name "empathy_contact_group_get_expanded") + (return-type "gboolean") + (parameters + '("const-gchar*" "group") + ) +) + +(define-function contact_group_set_expanded + (c-name "empathy_contact_group_set_expanded") + (return-type "none") + (parameters + '("const-gchar*" "group") + '("gboolean" "expanded") + ) +) + + + +;; From empathy-contact-list.h + +(define-function contact_list_get_type + (c-name "empathy_contact_list_get_type") + (return-type "GType") +) + +(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_pendings + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_pendings") + (return-type "GList*") +) + +(define-method get_all_groups + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_all_groups") + (return-type "GList*") +) + +(define-method get_groups + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_groups") + (return-type "GList*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method add_to_group + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_add_to_group") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "group") + ) +) + +(define-method remove_from_group + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_remove_from_group") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "group") + ) +) + +(define-method rename_group + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_rename_group") + (return-type "none") + (parameters + '("const-gchar*" "old_group") + '("const-gchar*" "new_group") + ) +) + +(define-method remove_group + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_remove_group") + (return-type "none") + (parameters + '("const-gchar*" "group") + ) +) + +(define-method get_monitor + (of-object "EmpathyContactList") + (c-name "empathy_contact_list_get_monitor") + (return-type "EmpathyContactMonitor*") +) + + + +;; From empathy-contact-manager.h + +(define-function contact_manager_get_type + (c-name "empathy_contact_manager_get_type") + (return-type "GType") +) + +(define-function contact_manager_dup_singleton + (c-name "empathy_contact_manager_dup_singleton") + (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 can_add + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_can_add") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-contact-monitor.h + +(define-function contact_monitor_get_type + (c-name "empathy_contact_monitor_get_type") + (return-type "GType") +) + +(define-method set_iface + (of-object "EmpathyContactMonitor") + (c-name "empathy_contact_monitor_set_iface") + (return-type "none") + (parameters + '("EmpathyContactList*" "iface") + ) +) + +(define-function contact_monitor_new_for_iface + (c-name "empathy_contact_monitor_new_for_iface") + (return-type "EmpathyContactMonitor*") + (parameters + '("EmpathyContactList*" "iface") + ) +) + + + +;; From empathy-debug.h + +(define-function debug_flag_is_set + (c-name "empathy_debug_flag_is_set") + (return-type "gboolean") + (parameters + '("EmpathyDebugFlags" "flag") + ) +) + +(define-function debug + (c-name "empathy_debug") + (return-type "none") + (parameters + '("EmpathyDebugFlags" "flag") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function debug_set_flags + (c-name "empathy_debug_set_flags") + (return-type "none") + (parameters + '("const-gchar*" "flags_string") + ) +) + + + +;; From empathy-dispatcher.h + +(define-function dispatcher_get_type + (c-name "empathy_dispatcher_get_type") + (return-type "GType") +) + +(define-method create_channel + (of-object "EmpathyDispatcher") + (c-name "empathy_dispatcher_create_channel") + (return-type "none") + (parameters + '("McAccount*" "account") + '("GHashTable*" "request") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-function dispatcher_call_with_contact + (c-name "empathy_dispatcher_call_with_contact") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-function dispatcher_chat_with_contact_id + (c-name "empathy_dispatcher_chat_with_contact_id") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "contact_id") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-function dispatcher_chat_with_contact + (c-name "empathy_dispatcher_chat_with_contact") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-function dispatcher_send_file_to_contact + (c-name "empathy_dispatcher_send_file_to_contact") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "filename") + '("guint64" "size") + '("guint64" "date") + '("const-gchar*" "content_type") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-function dispatcher_join_muc + (c-name "empathy_dispatcher_join_muc") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "roomname") + '("EmpathyDispatcherRequestCb*" "callback") + '("gpointer" "user_data") + ) +) + +(define-method find_channel_class + (of-object "EmpathyDispatcher") + (c-name "empathy_dispatcher_find_channel_class") + (return-type "GStrv") + (parameters + '("McAccount*" "account") + '("const-gchar*" "channel_type") + '("guint" "handle_type") + ) +) + +(define-function dispatcher_dup_singleton + (c-name "empathy_dispatcher_dup_singleton") + (return-type "EmpathyDispatcher*") +) + + + +;; From empathy-dispatch-operation.h + +(define-function dispatch_operation_get_type + (c-name "empathy_dispatch_operation_get_type") + (return-type "GType") +) + +(define-function dispatch_operation_new + (c-name "empathy_dispatch_operation_new") + (is-constructor-of "EmpathyDispatchOperation") + (return-type "EmpathyDispatchOperation*") + (parameters + '("TpConnection*" "connection") + '("TpChannel*" "channel") + '("EmpathyContact*" "contact") + '("gboolean" "incoming") + ) +) + +(define-function dispatch_operation_new_with_wrapper + (c-name "empathy_dispatch_operation_new_with_wrapper") + (return-type "EmpathyDispatchOperation*") + (parameters + '("TpConnection*" "connection") + '("TpChannel*" "channel") + '("EmpathyContact*" "contact") + '("gboolean" "incoming") + '("GObject*" "channel_wrapper") + ) +) + +(define-method start + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_start") + (return-type "none") +) + +(define-method approve + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_approve") + (return-type "none") +) + +(define-method claim + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_claim") + (return-type "gboolean") +) + +(define-method get_channel + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_channel") + (return-type "TpChannel*") +) + +(define-method get_channel_wrapper + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_channel_wrapper") + (return-type "GObject*") +) + +(define-method get_tp_connection + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_tp_connection") + (return-type "TpConnection*") +) + +(define-method get_channel_type + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_channel_type") + (return-type "const-gchar*") +) + +(define-method get_channel_type_id + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_channel_type_id") + (return-type "GQuark") +) + +(define-method get_object_path + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_object_path") + (return-type "const-gchar*") +) + +(define-method get_status + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_get_status") + (return-type "EmpathyDispatchOperationState") +) + +(define-method is_incoming + (of-object "EmpathyDispatchOperation") + (c-name "empathy_dispatch_operation_is_incoming") + (return-type "gboolean") +) + + + +;; From empathy-idle.h + +(define-function idle_get_type + (c-name "empathy_idle_get_type") + (return-type "GType") +) + +(define-function idle_dup_singleton + (c-name "empathy_idle_dup_singleton") + (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") + ) +) + +(define-method get_auto_away + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_auto_away") + (return-type "gboolean") +) + +(define-method set_auto_away + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_auto_away") + (return-type "none") + (parameters + '("gboolean" "auto_away") + ) +) + +(define-method get_use_nm + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_use_nm") + (return-type "gboolean") +) + +(define-method set_use_nm + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_use_nm") + (return-type "none") + (parameters + '("gboolean" "use_nm") + ) +) + + + +;; From empathy-irc-network.h + +(define-function irc_network_get_type + (c-name "empathy_irc_network_get_type") + (return-type "GType") +) + +(define-function irc_network_new + (c-name "empathy_irc_network_new") + (is-constructor-of "EmpathyIrcNetwork") + (return-type "EmpathyIrcNetwork*") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_servers + (of-object "EmpathyIrcNetwork") + (c-name "empathy_irc_network_get_servers") + (return-type "GSList*") +) + +(define-method append_server + (of-object "EmpathyIrcNetwork") + (c-name "empathy_irc_network_append_server") + (return-type "none") + (parameters + '("EmpathyIrcServer*" "server") + ) +) + +(define-method remove_server + (of-object "EmpathyIrcNetwork") + (c-name "empathy_irc_network_remove_server") + (return-type "none") + (parameters + '("EmpathyIrcServer*" "server") + ) +) + +(define-method set_server_position + (of-object "EmpathyIrcNetwork") + (c-name "empathy_irc_network_set_server_position") + (return-type "none") + (parameters + '("EmpathyIrcServer*" "server") + '("gint" "pos") + ) +) + + + +;; From empathy-irc-network-manager.h + +(define-function irc_network_manager_get_type + (c-name "empathy_irc_network_manager_get_type") + (return-type "GType") +) + +(define-function irc_network_manager_new + (c-name "empathy_irc_network_manager_new") + (is-constructor-of "EmpathyIrcNetworkManager") + (return-type "EmpathyIrcNetworkManager*") + (parameters + '("const-gchar*" "global_file") + '("const-gchar*" "user_file") + ) +) + +(define-method add + (of-object "EmpathyIrcNetworkManager") + (c-name "empathy_irc_network_manager_add") + (return-type "none") + (parameters + '("EmpathyIrcNetwork*" "network") + ) +) + +(define-method remove + (of-object "EmpathyIrcNetworkManager") + (c-name "empathy_irc_network_manager_remove") + (return-type "none") + (parameters + '("EmpathyIrcNetwork*" "network") + ) +) + +(define-method get_networks + (of-object "EmpathyIrcNetworkManager") + (c-name "empathy_irc_network_manager_get_networks") + (return-type "GSList*") +) + +(define-method find_network_by_address + (of-object "EmpathyIrcNetworkManager") + (c-name "empathy_irc_network_manager_find_network_by_address") + (return-type "EmpathyIrcNetwork*") + (parameters + '("const-gchar*" "address") + ) +) + + + +;; From empathy-irc-server.h + +(define-function irc_server_get_type + (c-name "empathy_irc_server_get_type") + (return-type "GType") +) + +(define-function irc_server_new + (c-name "empathy_irc_server_new") + (is-constructor-of "EmpathyIrcServer") + (return-type "EmpathyIrcServer*") + (parameters + '("const-gchar*" "address") + '("guint" "port") + '("gboolean" "ssl") + ) +) + + + +;; From empathy-log-manager.h + +(define-function log_manager_get_type + (c-name "empathy_log_manager_get_type") + (return-type "GType") +) + +(define-function log_manager_dup_singleton + (c-name "empathy_log_manager_dup_singleton") + (return-type "EmpathyLogManager*") +) + +(define-method add_message + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_add_message") + (return-type "gboolean") + (parameters + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("EmpathyMessage*" "message") + '("GError**" "error") + ) +) + +(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_filtered_messages + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_filtered_messages") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("guint" "num_messages") + '("EmpathyLogMessageFilter" "filter") + '("gpointer" "user_data") + ) +) + +(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 log_manager_search_free + (c-name "empathy_log_manager_search_free") + (return-type "none") + (parameters + '("GList*" "hits") + ) +) + +(define-function log_manager_get_date_readable + (c-name "empathy_log_manager_get_date_readable") + (return-type "gchar*") + (parameters + '("const-gchar*" "date") + ) +) + +(define-function log_manager_search_hit_free + (c-name "empathy_log_manager_search_hit_free") + (return-type "none") + (parameters + '("EmpathyLogSearchHit*" "hit") + ) +) + +(define-method observe + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_observe") + (return-type "none") + (parameters + '("EmpathyDispatcher*" "dispatcher") + ) +) + + + +;; From empathy-log-store.h + +(define-function log_store_get_type + (c-name "empathy_log_store_get_type") + (return-type "GType") +) + +(define-method get_name + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_get_name") + (return-type "const-gchar*") +) + +(define-method exists + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_exists") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method add_message + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_add_message") + (return-type "gboolean") + (parameters + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("EmpathyMessage*" "message") + '("GError**" "error") + ) +) + +(define-method get_dates + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_get_dates") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_messages_for_date + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_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 "EmpathyLogStore") + (c-name "empathy_log_store_get_last_messages") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_chats + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_get_chats") + (return-type "GList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method search_new + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_search_new") + (return-type "GList*") + (parameters + '("const-gchar*" "text") + ) +) + +(define-method ack_message + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_ack_message") + (return-type "none") + (parameters + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("EmpathyMessage*" "message") + ) +) + +(define-method get_filtered_messages + (of-object "EmpathyLogStore") + (c-name "empathy_log_store_get_filtered_messages") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("guint" "num_messages") + '("EmpathyLogMessageFilter" "filter") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-log-store-empathy.h + +(define-function log_store_empathy_get_type + (c-name "empathy_log_store_empathy_get_type") + (return-type "GType") +) + + + +;; From empathy-message.h + +(define-function message_get_type + (c-name "empathy_message_get_type") + (return-type "GType") +) + +(define-function message_new + (c-name "empathy_message_new") + (is-constructor-of "EmpathyMessage") + (return-type "EmpathyMessage*") + (parameters + '("const-gchar*" "body") + ) +) + +(define-method get_tptype + (of-object "EmpathyMessage") + (c-name "empathy_message_get_tptype") + (return-type "TpChannelTextMessageType") +) + +(define-method set_tptype + (of-object "EmpathyMessage") + (c-name "empathy_message_set_tptype") + (return-type "none") + (parameters + '("TpChannelTextMessageType" "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 "time_t") +) + +(define-method set_timestamp + (of-object "EmpathyMessage") + (c-name "empathy_message_set_timestamp") + (return-type "none") + (parameters + '("time_t" "timestamp") + ) +) + +(define-method should_highlight + (of-object "EmpathyMessage") + (c-name "empathy_message_should_highlight") + (return-type "gboolean") +) + +(define-function message_type_from_str + (c-name "empathy_message_type_from_str") + (return-type "TpChannelTextMessageType") + (parameters + '("const-gchar*" "type_str") + ) +) + +(define-function message_type_to_str + (c-name "empathy_message_type_to_str") + (return-type "const-gchar*") + (parameters + '("TpChannelTextMessageType" "type") + ) +) + +(define-method get_id + (of-object "EmpathyMessage") + (c-name "empathy_message_get_id") + (return-type "guint") +) + +(define-method set_id + (of-object "EmpathyMessage") + (c-name "empathy_message_set_id") + (return-type "none") + (parameters + '("guint" "id") + ) +) + +(define-method equal + (of-object "EmpathyMessage") + (c-name "empathy_message_equal") + (return-type "gboolean") + (parameters + '("EmpathyMessage*" "message2") + ) +) + + + +;; From empathy-status-presets.h + +(define-function status_presets_get_all + (c-name "empathy_status_presets_get_all") + (return-type "none") +) + +(define-function status_presets_get + (c-name "empathy_status_presets_get") + (return-type "GList*") + (parameters + '("McPresence" "state") + '("gint" "max_number") + ) +) + +(define-function status_presets_set_last + (c-name "empathy_status_presets_set_last") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function status_presets_remove + (c-name "empathy_status_presets_remove") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function status_presets_reset + (c-name "empathy_status_presets_reset") + (return-type "none") +) + +(define-function status_presets_get_default_state + (c-name "empathy_status_presets_get_default_state") + (return-type "McPresence") +) + +(define-function status_presets_get_default_status + (c-name "empathy_status_presets_get_default_status") + (return-type "const-gchar*") +) + +(define-function status_presets_set_default + (c-name "empathy_status_presets_set_default") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function status_presets_clear_default + (c-name "empathy_status_presets_clear_default") + (return-type "none") +) + + + +;; From empathy-time.h + +(define-function time_get_current + (c-name "empathy_time_get_current") + (return-type "time_t") +) + +(define-function time_get_local_time + (c-name "empathy_time_get_local_time") + (return-type "time_t") + (parameters + '("struct-tm*" "tm") + ) +) + +(define-function time_parse + (c-name "empathy_time_parse") + (return-type "time_t") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function time_to_string_utc + (c-name "empathy_time_to_string_utc") + (return-type "gchar*") + (parameters + '("time_t" "t") + '("const-gchar*" "format") + ) +) + +(define-function time_to_string_local + (c-name "empathy_time_to_string_local") + (return-type "gchar*") + (parameters + '("time_t" "t") + '("const-gchar*" "format") + ) +) + + + +;; From empathy-tp-call.h + +(define-function tp_call_get_type + (c-name "empathy_tp_call_get_type") + (return-type "GType") +) + +(define-function tp_call_new + (c-name "empathy_tp_call_new") + (is-constructor-of "EmpathyTpCall") + (return-type "EmpathyTpCall*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-method close + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_close") + (return-type "none") +) + +(define-method to + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_to") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method accept_incoming_call + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_accept_incoming_call") + (return-type "none") +) + +(define-method request_video_stream_direction + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_request_video_stream_direction") + (return-type "none") + (parameters + '("gboolean" "is_sending") + ) +) + +(define-method start_tone + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_start_tone") + (return-type "none") + (parameters + '("TpDTMFEvent" "event") + ) +) + +(define-method stop_tone + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_stop_tone") + (return-type "none") +) + +(define-method has_dtmf + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_has_dtmf") + (return-type "gboolean") +) + + + +;; From empathy-tp-chat.h + +(define-function tp_chat_get_type + (c-name "empathy_tp_chat_get_type") + (return-type "GType") +) + +(define-function tp_chat_new + (c-name "empathy_tp_chat_new") + (is-constructor-of "EmpathyTpChat") + (return-type "EmpathyTpChat*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-method close + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_close") + (return-type "none") +) + +(define-method get_id + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_id") + (return-type "const-gchar*") +) + +(define-method get_remote_contact + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_remote_contact") + (return-type "EmpathyContact*") +) + +(define-method get_account + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_account") + (return-type "McAccount*") +) + +(define-method get_channel + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_channel") + (return-type "TpChannel*") +) + +(define-method is_ready + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_is_ready") + (return-type "gboolean") +) + +(define-method get_members_count + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_members_count") + (return-type "guint") +) + +(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 + '("TpChannelChatState" "state") + ) +) + +(define-method set_property + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_set_property") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("const-GValue*" "value") + ) +) + +(define-method get_pending_messages + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_get_pending_messages") + (return-type "const-GList*") +) + +(define-method acknowledge_message + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_acknowledge_message") + (return-type "none") + (parameters + '("EmpathyMessage*" "message") + ) +) + +(define-method acknowledge_messages + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_acknowledge_messages") + (return-type "none") + (parameters + '("const-GList*" "messages") + ) +) + + + +;; From empathy-tp-contact-factory.h + +(define-function tp_contact_factory_get_type + (c-name "empathy_tp_contact_factory_get_type") + (return-type "GType") +) + +(define-function tp_contact_factory_new + (c-name "empathy_tp_contact_factory_new") + (is-constructor-of "EmpathyTpContactFactory") + (return-type "EmpathyTpContactFactory*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_user + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_get_user") + (return-type "EmpathyContact*") +) + +(define-method get_from_id + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_get_from_id") + (return-type "EmpathyContact*") + (parameters + '("const-gchar*" "id") + ) +) + +(define-method get_from_handle + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_get_from_handle") + (return-type "EmpathyContact*") + (parameters + '("guint" "handle") + ) +) + +(define-method get_from_handles + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_get_from_handles") + (return-type "GList*") + (parameters + '("const-GArray*" "handles") + ) +) + +(define-method set_alias + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_set_alias") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "alias") + ) +) + +(define-method set_avatar + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_set_avatar") + (return-type "none") + (parameters + '("const-gchar*" "data") + '("gsize" "size") + '("const-gchar*" "mime_type") + ) +) + +(define-method is_ready + (of-object "EmpathyTpContactFactory") + (c-name "empathy_tp_contact_factory_is_ready") + (return-type "gboolean") +) + + + +;; From empathy-tp-contact-list.h + +(define-function tp_contact_list_get_type + (c-name "empathy_tp_contact_list_get_type") + (return-type "GType") +) + +(define-function 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 can_add + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_can_add") + (return-type "gboolean") +) + + + +;; From empathy-tp-file.h + +(define-function tp_file_get_type + (c-name "empathy_tp_file_get_type") + (return-type "GType") +) + +(define-function tp_file_new + (c-name "empathy_tp_file_new") + (is-constructor-of "EmpathyTpFile") + (return-type "EmpathyTpFile*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-method get_channel + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_channel") + (return-type "TpChannel*") +) + +(define-method accept + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_accept") + (return-type "none") + (parameters + '("guint64" "offset") + '("GFile*" "gfile") + '("GError**" "error") + ) +) + +(define-method cancel + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_cancel") + (return-type "none") +) + +(define-method close + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_close") + (return-type "none") +) + +(define-method offer + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_offer") + (return-type "none") + (parameters + '("GFile*" "gfile") + '("GError**" "error") + ) +) + +(define-method get_contact + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_contact") + (return-type "EmpathyContact*") +) + +(define-method get_filename + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_filename") + (return-type "const-gchar*") +) + +(define-method is_incoming + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_is_incoming") + (return-type "gboolean") +) + +(define-method get_state + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_state") + (return-type "TpFileTransferState") + (parameters + '("TpFileTransferStateChangeReason*" "reason") + ) +) + +(define-method get_size + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_size") + (return-type "guint64") +) + +(define-method get_transferred_bytes + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_transferred_bytes") + (return-type "guint64") +) + +(define-method get_remaining_time + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_remaining_time") + (return-type "gint") +) + +(define-method get_content_type + (of-object "EmpathyTpFile") + (c-name "empathy_tp_file_get_content_type") + (return-type "const-gchar*") +) + + + +;; From empathy-tp-group.h + +(define-function tp_group_get_type + (c-name "empathy_tp_group_get_type") + (return-type "GType") +) + +(define-function tp_group_new + (c-name "empathy_tp_group_new") + (is-constructor-of "EmpathyTpGroup") + (return-type "EmpathyTpGroup*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-method close + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_close") + (return-type "none") +) + +(define-method add_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_add_members") + (return-type "none") + (parameters + '("GList*" "contacts") + '("const-gchar*" "message") + ) +) + +(define-method add_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_add_member") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-method remove_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_remove_members") + (return-type "none") + (parameters + '("GList*" "contacts") + '("const-gchar*" "message") + ) +) + +(define-method remove_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_remove_member") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + '("const-gchar*" "message") + ) +) + +(define-method get_members + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_members") + (return-type "GList*") +) + +(define-method get_local_pendings + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_local_pendings") + (return-type "GList*") +) + +(define-method get_remote_pendings + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_remote_pendings") + (return-type "GList*") +) + +(define-method get_name + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_name") + (return-type "const-gchar*") +) + +(define-method get_self_contact + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_self_contact") + (return-type "EmpathyContact*") +) + +(define-method is_member + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_is_member") + (return-type "gboolean") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-method is_ready + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_is_ready") + (return-type "gboolean") +) + +(define-method get_invitation + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_invitation") + (return-type "EmpathyPendingInfo*") + (parameters + '("EmpathyContact**" "remote_contact") + ) +) + +(define-function pending_info_new + (c-name "empathy_pending_info_new") + (is-constructor-of "EmpathyPendingInfo") + (return-type "EmpathyPendingInfo*") + (parameters + '("EmpathyContact*" "member") + '("EmpathyContact*" "actor") + '("const-gchar*" "message") + ) +) + +(define-method free + (of-object "EmpathyPendingInfo") + (c-name "empathy_pending_info_free") + (return-type "none") +) + +(define-method get_flags + (of-object "EmpathyTpGroup") + (c-name "empathy_tp_group_get_flags") + (return-type "TpChannelGroupFlags") +) + + + +;; From empathy-tp-roomlist.h + +(define-function tp_roomlist_get_type + (c-name "empathy_tp_roomlist_get_type") + (return-type "GType") +) + +(define-function tp_roomlist_new + (c-name "empathy_tp_roomlist_new") + (is-constructor-of "EmpathyTpRoomlist") + (return-type "EmpathyTpRoomlist*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method is_listing + (of-object "EmpathyTpRoomlist") + (c-name "empathy_tp_roomlist_is_listing") + (return-type "gboolean") +) + +(define-method start + (of-object "EmpathyTpRoomlist") + (c-name "empathy_tp_roomlist_start") + (return-type "none") +) + +(define-method stop + (of-object "EmpathyTpRoomlist") + (c-name "empathy_tp_roomlist_stop") + (return-type "none") +) + + + +;; From empathy-tp-tube.h + +(define-function tp_tube_get_type + (c-name "empathy_tp_tube_get_type") + (return-type "GType") +) + +(define-function tp_tube_new + (c-name "empathy_tp_tube_new") + (is-constructor-of "EmpathyTpTube") + (return-type "EmpathyTpTube*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-function tp_tube_new_stream_tube + (c-name "empathy_tp_tube_new_stream_tube") + (return-type "EmpathyTpTube*") + (parameters + '("EmpathyContact*" "contact") + '("TpSocketAddressType" "type") + '("const-gchar*" "hostname") + '("guint" "port") + '("const-gchar*" "service") + '("GHashTable*" "parameters") + ) +) + +(define-method accept_stream_tube + (of-object "EmpathyTpTube") + (c-name "empathy_tp_tube_accept_stream_tube") + (return-type "none") + (parameters + '("TpSocketAddressType" "type") + '("EmpatyTpTubeAcceptStreamTubeCb*" "callback") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-tube-handler.h + +(define-function tube_handler_get_type + (c-name "empathy_tube_handler_get_type") + (return-type "GType") +) + +(define-function tube_handler_new + (c-name "empathy_tube_handler_new") + (is-constructor-of "EmpathyTubeHandler") + (return-type "EmpathyTubeHandler*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + +(define-function tube_handler_build_bus_name + (c-name "empathy_tube_handler_build_bus_name") + (return-type "gchar*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + +(define-function tube_handler_build_object_path + (c-name "empathy_tube_handler_build_object_path") + (return-type "gchar*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + + + +;; From empathy-types.h + + + +;; From empathy-utils.h + +(define-function init + (c-name "empathy_init") + (return-type "none") +) + +(define-function substring + (c-name "empathy_substring") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gint" "start") + '("gint" "end") + ) +) + +(define-function strcasecmp + (c-name "empathy_strcasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + ) +) + +(define-function strncasecmp + (c-name "empathy_strncasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + '("gsize" "n") + ) +) + +(define-function xml_validate + (c-name "empathy_xml_validate") + (return-type "gboolean") + (parameters + '("xmlDoc*" "doc") + '("const-gchar*" "dtd_filename") + ) +) + +(define-function xml_node_get_child + (c-name "empathy_xml_node_get_child") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "child_name") + ) +) + +(define-function 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 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 account_hash + (c-name "empathy_account_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-function account_equal + (c-name "empathy_account_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "a") + '("gconstpointer" "b") + ) +) + +(define-function mission_control_dup_singleton + (c-name "empathy_mission_control_dup_singleton") + (return-type "MissionControl*") +) + +(define-function presence_get_default_message + (c-name "empathy_presence_get_default_message") + (return-type "const-gchar*") + (parameters + '("McPresence" "presence") + ) +) + +(define-function presence_to_str + (c-name "empathy_presence_to_str") + (return-type "const-gchar*") + (parameters + '("McPresence" "presence") + ) +) + +(define-function presence_from_str + (c-name "empathy_presence_from_str") + (return-type "McPresence") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function file_lookup + (c-name "empathy_file_lookup") + (return-type "gchar*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "subdir") + ) +) + +(define-function run_until_ready + (c-name "empathy_run_until_ready") + (return-type "none") + (parameters + '("gpointer" "object") + ) +) + +(define-function run_until_ready_full + (c-name "empathy_run_until_ready_full") + (return-type "none") + (parameters + '("gpointer" "object") + '("const-gchar*" "signal") + '("EmpathyRunUntilReadyFunc" "func") + '("gpointer" "user_data") + '("GMainLoop**" "loop") + ) +) + +(define-function channel_get_account + (c-name "empathy_channel_get_account") + (return-type "McAccount*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-function proxy_equal + (c-name "empathy_proxy_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "a") + '("gconstpointer" "b") + ) +) + +(define-function proxy_hash + (c-name "empathy_proxy_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-function check_available_state + (c-name "empathy_check_available_state") + (return-type "gboolean") +) + + diff --git a/gnome-2-26/python/pyempathy/pyempathy.override b/gnome-2-26/python/pyempathy/pyempathy.override new file mode 100644 index 000000000..72d7ccb0e --- /dev/null +++ b/gnome-2-26/python/pyempathy/pyempathy.override @@ -0,0 +1,90 @@ +%% +headers +#include <Python.h> +#include <pygobject.h> +#include "empathy-account-manager.h" +#include "empathy-call-factory.h" +#include "empathy-chatroom.h" +#include "empathy-chatroom-manager.h" +#include "empathy-contact.h" +#include "empathy-contact-factory.h" +#include "empathy-contact-groups.h" +#include "empathy-contact-list.h" +#include "empathy-contact-manager.h" +#include "empathy-contact-monitor.h" +#include "empathy-debug.h" +#include "empathy-dispatcher.h" +#include "empathy-enum-types.h" +#include "empathy-idle.h" +#include "empathy-irc-network.h" +#include "empathy-irc-network-manager.h" +#include "empathy-irc-server.h" +#include "empathy-log-manager.h" +#include "empathy-log-store-empathy.h" +#include "empathy-message.h" +#include "empathy-status-presets.h" +#include "empathy-time.h" +#include "empathy-tp-call.h" +#include "empathy-tp-chat.h" +#include "empathy-tp-contact-factory.h" +#include "empathy-tp-contact-list.h" +#include "empathy-tp-file.h" +#include "empathy-tp-group.h" +#include "empathy-tp-roomlist.h" +#include "empathy-tp-tube.h" +#include "empathy-tube-handler.h" +#include "empathy-utils.h" + +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_dispatcher_chat_with_contact_id kwargs +static PyObject * +_wrap_empathy_dispatcher_chat_with_contact_id(PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "account_id", "contact_id", NULL }; + char *account_id, *contact_id; + McAccount *account; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:dispatcher_chat_with_contact_id", kwlist, &account_id, &contact_id)) + return NULL; + + account = mc_account_lookup (account_id); + if (account) { + empathy_dispatcher_chat_with_contact_id(account, contact_id, + NULL, NULL); + g_object_unref (account); + } + + Py_INCREF(Py_None); + return Py_None; +} +%% diff --git a/gnome-2-26/python/pyempathy/pyempathymodule.c b/gnome-2-26/python/pyempathy/pyempathymodule.c new file mode 100644 index 000000000..59c093c83 --- /dev/null +++ b/gnome-2-26/python/pyempathy/pyempathymodule.c @@ -0,0 +1,28 @@ +#define NO_IMPORT_PYGOBJECT + +#include <pygobject.h> + +void empathy_register_classes (PyObject *d); +void empathy_add_constants(PyObject *module, const gchar *strip_prefix); +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); + empathy_add_constants(m, "EMPATHY_"); + + if (PyErr_Occurred ()) { + PyErr_Print(); + Py_FatalError ("can't initialise module empathy"); + } +} + diff --git a/gnome-2-26/python/pyempathygtk.patch b/gnome-2-26/python/pyempathygtk.patch new file mode 100644 index 000000000..a0730a181 --- /dev/null +++ b/gnome-2-26/python/pyempathygtk.patch @@ -0,0 +1,18 @@ +--- /home/zdra/Desktop/pyempathygtk.defs 2008-04-02 11:19:27.000000000 +0200 ++++ pyempathygtk/pyempathygtk.defs 2008-04-02 11:29:23.000000000 +0200 +@@ -1042,10 +1042,13 @@ + (return-type "GType") + ) + +-(define-method store_new +- (of-object "EmpathyContactList") ++(define-function empathy_contact_list_store_new ++ (is-constructor-of "EmpathyContactListStore") + (c-name "empathy_contact_list_store_new") + (return-type "EmpathyContactListStore*") ++ (parameters ++ '("EmpathyContactList*" "list_iface") ++ ) + ) + + (define-method get_list_iface diff --git a/gnome-2-26/python/pyempathygtk/Makefile.am b/gnome-2-26/python/pyempathygtk/Makefile.am new file mode 100644 index 000000000..ba0ee11df --- /dev/null +++ b/gnome-2-26/python/pyempathygtk/Makefile.am @@ -0,0 +1,46 @@ +PYDEFS=`pkg-config --variable=defsdir pygtk-2.0` + +AM_CPPFLAGS = \ + -I. \ + -I$(top_srcdir)/libempathy-gtk \ + -I$(top_builddir)/libempathy-gtk \ + -I$(top_srcdir) \ + -DDATADIR=\""$(datadir)"\" \ + $(PYTHON_BINDING_CFLAGS) \ + $(PYTHON_INCLUDES) + +BUILT_SOURCES = \ + pyempathygtk.c + +pyempathygtkdir = $(pyexecdir) +pyempathygtk_LTLIBRARIES = empathygtk.la + +empathygtk_la_SOURCES = \ + pyempathygtkmodule.c + +nodist_empathygtk_la_SOURCES = \ + pyempathygtk.c + +empathygtk_la_LIBADD = \ + $(PYTHON_BINDING_LIBS) \ + $(top_builddir)/libempathy/libempathy.la \ + $(top_builddir)/libempathy-gtk/libempathy-gtk.la + +empathygtk_la_LDFLAGS = \ + -module -avoid-version + +pyempathygtk.c: pyempathygtk.override pyempathygtk.defs + $(PYGOBJECTCODEGEN) \ + --prefix empathy \ + --register $(PYDEFS)/gdk-types.defs \ + --register $(PYDEFS)/gtk-types.defs \ + --register $(srcdir)/../pyempathy/pyempathy.defs \ + --override $(srcdir)/pyempathygtk.override \ + $(srcdir)/pyempathygtk.defs > $@ + +EXTRA_DIST = \ + pyempathygtk.override \ + pyempathygtk.defs + +CLEANFILES = $(BUILT_SOURCES) + diff --git a/gnome-2-26/python/pyempathygtk/pyempathygtk.defs b/gnome-2-26/python/pyempathygtk/pyempathygtk.defs new file mode 100644 index 000000000..c75c93efd --- /dev/null +++ b/gnome-2-26/python/pyempathygtk/pyempathygtk.defs @@ -0,0 +1,2010 @@ +;; -*- scheme -*- +; object definitions ... +(define-object AccountChooser + (in-module "Empathy") + (parent "GtkComboBox") + (c-name "EmpathyAccountChooser") + (gtype-id "EMPATHY_TYPE_ACCOUNT_CHOOSER") +) + +(define-object AvatarChooser + (in-module "Empathy") + (parent "GtkButton") + (c-name "EmpathyAvatarChooser") + (gtype-id "EMPATHY_TYPE_AVATAR_CHOOSER") +) + +(define-object AvatarImage + (in-module "Empathy") + (parent "GtkEventBox") + (c-name "EmpathyAvatarImage") + (gtype-id "EMPATHY_TYPE_AVATAR_IMAGE") +) + +(define-object CellRendererActivatable + (in-module "Empathy") + (parent "GtkCellRendererPixbuf") + (c-name "EmpathyCellRendererActivatable") + (gtype-id "EMPATHY_TYPE_CELL_RENDERER_ACTIVATABLE") +) + +(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 "GtkBin") + (c-name "EmpathyChat") + (gtype-id "EMPATHY_TYPE_CHAT") +) + +(define-object ChatTextView + (in-module "Empathy") + (parent "GtkTextView") + (c-name "EmpathyChatTextView") + (gtype-id "EMPATHY_TYPE_CHAT_TEXT_VIEW") +) + +(define-interface ChatView + (in-module "Empathy") + (c-name "EmpathyChatView") + (gtype-id "EMPATHY_TYPE_CHAT_VIEW") +) + +(define-object Conf + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyConf") + (gtype-id "EMPATHY_TYPE_CONF") +) + +(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 ContactSelector + (in-module "Empathy") + (parent "GtkComboBox") + (c-name "EmpathyContactSelector") + (gtype-id "EMPATHY_TYPE_CONTACT_SELECTOR") +) + +(define-object GstAudioSink + (in-module "Empathy") + (parent "GstBin") + (c-name "EmpathyGstAudioSink") + (gtype-id "EMPATHY_TYPE_GST_AUDIO_SINK") +) + +(define-object GstAudioSrc + (in-module "Empathy") + (parent "GstBin") + (c-name "EmpathyGstAudioSrc") + (gtype-id "EMPATHY_TYPE_GST_AUDIO_SRC") +) + +(define-object GstVideoSrc + (in-module "Empathy") + (parent "GstBin") + (c-name "EmpathyGstVideoSrc") + (gtype-id "EMPATHY_TYPE_GST_VIDEO_SRC") +) + +(define-object PresenceChooser + (in-module "Empathy") + (parent "GtkToggleButton") + (c-name "EmpathyPresenceChooser") + (gtype-id "EMPATHY_TYPE_PRESENCE_CHOOSER") +) + +(define-object SmileyManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathySmileyManager") + (gtype-id "EMPATHY_TYPE_SMILEY_MANAGER") +) + +(define-object ThemeBoxes + (in-module "Empathy") + (parent "EmpathyChatTextView") + (c-name "EmpathyThemeBoxes") + (gtype-id "EMPATHY_TYPE_THEME_BOXES") +) + +(define-object ThemeIrc + (in-module "Empathy") + (parent "EmpathyChatTextView") + (c-name "EmpathyThemeIrc") + (gtype-id "EMPATHY_TYPE_THEME_IRC") +) + +(define-object ThemeManager + (in-module "Empathy") + (parent "GObject") + (c-name "EmpathyThemeManager") + (gtype-id "EMPATHY_TYPE_THEME_MANAGER") +) + +(define-object VideoWidget + (in-module "Empathy") + (parent "GtkDrawingArea") + (c-name "EmpathyVideoWidget") + (gtype-id "EMPATHY_TYPE_VIDEO_WIDGET") +) + +;; Enumerations and flags ... + +(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" "EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS") + '("pixbuf-avatar" "EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR") + '("pixbuf-avatar-visible" "EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE") + '("name" "EMPATHY_CONTACT_LIST_STORE_COL_NAME") + '("status" "EMPATHY_CONTACT_LIST_STORE_COL_STATUS") + '("status-visible" "EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE") + '("contact" "EMPATHY_CONTACT_LIST_STORE_COL_CONTACT") + '("is-group" "EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP") + '("is-active" "EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE") + '("is-online" "EMPATHY_CONTACT_LIST_STORE_COL_IS_ONLINE") + '("is-separator" "EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR") + '("can-voip" "EMPATHY_CONTACT_LIST_STORE_COL_CAN_VOIP") + '("count" "EMPATHY_CONTACT_LIST_STORE_COL_COUNT") + ) +) + +(define-flags ContactListFeatureFlags + (in-module "Empathy") + (c-name "EmpathyContactListFeatureFlags") + (gtype-id "EMPATHY_TYPE_CONTACT_LIST_FEATURE_FLAGS") + (values + '("none" "EMPATHY_CONTACT_LIST_FEATURE_NONE") + '("groups-save" "EMPATHY_CONTACT_LIST_FEATURE_GROUPS_SAVE") + '("groups-rename" "EMPATHY_CONTACT_LIST_FEATURE_GROUPS_RENAME") + '("groups-remove" "EMPATHY_CONTACT_LIST_FEATURE_GROUPS_REMOVE") + '("contact-remove" "EMPATHY_CONTACT_LIST_FEATURE_CONTACT_REMOVE") + '("contact-drop" "EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DROP") + '("contact-drag" "EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DRAG") + '("contact-tooltip" "EMPATHY_CONTACT_LIST_FEATURE_CONTACT_TOOLTIP") + '("all" "EMPATHY_CONTACT_LIST_FEATURE_ALL") + ) +) + +(define-flags ContactFeatureFlags + (in-module "Empathy") + (c-name "EmpathyContactFeatureFlags") + (gtype-id "EMPATHY_TYPE_CONTACT_FEATURE_FLAGS") + (values + '("none" "EMPATHY_CONTACT_FEATURE_NONE") + '("chat" "EMPATHY_CONTACT_FEATURE_CHAT") + '("call" "EMPATHY_CONTACT_FEATURE_CALL") + '("log" "EMPATHY_CONTACT_FEATURE_LOG") + '("edit" "EMPATHY_CONTACT_FEATURE_EDIT") + '("info" "EMPATHY_CONTACT_FEATURE_INFO") + '("all" "EMPATHY_CONTACT_FEATURE_ALL") + ) +) + +(define-flags ContactWidgetFlags + (in-module "Empathy") + (c-name "EmpathyContactWidgetFlags") + (gtype-id "EMPATHY_TYPE_CONTACT_WIDGET_FLAGS") + (values + '("edit-none" "EMPATHY_CONTACT_WIDGET_EDIT_NONE") + '("edit-alias" "EMPATHY_CONTACT_WIDGET_EDIT_ALIAS") + '("edit-avatar" "EMPATHY_CONTACT_WIDGET_EDIT_AVATAR") + '("edit-account" "EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT") + '("edit-id" "EMPATHY_CONTACT_WIDGET_EDIT_ID") + '("edit-groups" "EMPATHY_CONTACT_WIDGET_EDIT_GROUPS") + '("for-tooltip" "EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP") + ) +) + +(define-enum GstVideoSrcChannel + (in-module "Empathy") + (c-name "EmpathyGstVideoSrcChannel") + (gtype-id "EMPATHY_TYPE_GST_VIDEO_SRC_CHANNEL") + (values + '("empathy-gst-video-src-channel-contrast" "EMPATHY_GST_VIDEO_SRC_CHANNEL_CONTRAST") + '("empathy-gst-video-src-channel-brightness" "EMPATHY_GST_VIDEO_SRC_CHANNEL_BRIGHTNESS") + '("empathy-gst-video-src-channel-gamma" "EMPATHY_GST_VIDEO_SRC_CHANNEL_GAMMA") + '("nr-empathy-gst-video-src-channels" "NR_EMPATHY_GST_VIDEO_SRC_CHANNELS") + ) +) + +(define-enum Sound + (in-module "Empathy") + (c-name "EmpathySound") + (gtype-id "EMPATHY_TYPE_SOUND") + (values + '("empathy-sound-message-incoming" "EMPATHY_SOUND_MESSAGE_INCOMING") + '("empathy-sound-message-outgoing" "EMPATHY_SOUND_MESSAGE_OUTGOING") + '("empathy-sound-conversation-new" "EMPATHY_SOUND_CONVERSATION_NEW") + '("empathy-sound-contact-connected" "EMPATHY_SOUND_CONTACT_CONNECTED") + '("empathy-sound-contact-disconnected" "EMPATHY_SOUND_CONTACT_DISCONNECTED") + '("empathy-sound-account-connected" "EMPATHY_SOUND_ACCOUNT_CONNECTED") + '("empathy-sound-account-disconnected" "EMPATHY_SOUND_ACCOUNT_DISCONNECTED") + '("empathy-sound-phone-incoming" "EMPATHY_SOUND_PHONE_INCOMING") + '("empathy-sound-phone-outgoing" "EMPATHY_SOUND_PHONE_OUTGOING") + '("empathy-sound-phone-hangup" "EMPATHY_SOUND_PHONE_HANGUP") + '("last-empathy-sound" "LAST_EMPATHY_SOUND") + ) +) + + +;; From empathy-account-chooser.h + +(define-function account_chooser_get_type + (c-name "empathy_account_chooser_get_type") + (return-type "GType") +) + +(define-function 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 account_chooser_filter_is_connected + (c-name "empathy_account_chooser_filter_is_connected") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-account-widget.h + +(define-function account_widget_handle_params + (c-name "empathy_account_widget_handle_params") + (return-type "none") + (parameters + '("McAccount*" "account") + '("GladeXML*" "glade") + '("const-gchar*" "first_widget_name") + ) + (varargs #t) +) + +(define-function account_widget_add_forget_button + (c-name "empathy_account_widget_add_forget_button") + (return-type "none") + (parameters + '("McAccount*" "account") + '("GladeXML*" "glade") + '("const-gchar*" "button") + '("const-gchar*" "entry") + ) +) + +(define-function account_widget_generic_new + (c-name "empathy_account_widget_generic_new") + (is-constructor-of "EmpathyAccountWidgetGeneric") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_salut_new + (c-name "empathy_account_widget_salut_new") + (is-constructor-of "EmpathyAccountWidgetSalut") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_msn_new + (c-name "empathy_account_widget_msn_new") + (is-constructor-of "EmpathyAccountWidgetMsn") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_jabber_new + (c-name "empathy_account_widget_jabber_new") + (is-constructor-of "EmpathyAccountWidgetJabber") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_icq_new + (c-name "empathy_account_widget_icq_new") + (is-constructor-of "EmpathyAccountWidgetIcq") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_aim_new + (c-name "empathy_account_widget_aim_new") + (is-constructor-of "EmpathyAccountWidgetAim") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_yahoo_new + (c-name "empathy_account_widget_yahoo_new") + (is-constructor-of "EmpathyAccountWidgetYahoo") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function account_widget_groupwise_new + (c-name "empathy_account_widget_groupwise_new") + (is-constructor-of "EmpathyAccountWidgetGroupwise") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-account-widget-irc.h + +(define-function account_widget_irc_new + (c-name "empathy_account_widget_irc_new") + (is-constructor-of "EmpathyAccountWidgetIrc") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-account-widget-sip.h + +(define-function account_widget_sip_new + (c-name "empathy_account_widget_sip_new") + (is-constructor-of "EmpathyAccountWidgetSip") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-avatar-chooser.h + +(define-function avatar_chooser_get_type + (c-name "empathy_avatar_chooser_get_type") + (return-type "GType") +) + +(define-function avatar_chooser_new + (c-name "empathy_avatar_chooser_new") + (is-constructor-of "EmpathyAvatarChooser") + (return-type "GtkWidget*") +) + +(define-method set + (of-object "EmpathyAvatarChooser") + (c-name "empathy_avatar_chooser_set") + (return-type "none") + (parameters + '("EmpathyAvatar*" "avatar") + ) +) + +(define-method get_image_data + (of-object "EmpathyAvatarChooser") + (c-name "empathy_avatar_chooser_get_image_data") + (return-type "none") + (parameters + '("const-gchar**" "data") + '("gsize*" "data_size") + '("const-gchar**" "mime_type") + ) +) + + + +;; From empathy-avatar-image.h + +(define-function avatar_image_get_type + (c-name "empathy_avatar_image_get_type") + (return-type "GType") +) + +(define-function avatar_image_new + (c-name "empathy_avatar_image_new") + (is-constructor-of "EmpathyAvatarImage") + (return-type "GtkWidget*") +) + +(define-method set + (of-object "EmpathyAvatarImage") + (c-name "empathy_avatar_image_set") + (return-type "none") + (parameters + '("EmpathyAvatar*" "avatar") + ) +) + + + +;; From empathy-cell-renderer-activatable.h + +(define-function cell_renderer_activatable_get_type + (c-name "empathy_cell_renderer_activatable_get_type") + (return-type "GType") +) + +(define-function cell_renderer_activatable_new + (c-name "empathy_cell_renderer_activatable_new") + (is-constructor-of "EmpathyCellRendererActivatable") + (return-type "GtkCellRenderer*") +) + + + +;; From empathy-cell-renderer-expander.h + +(define-function cell_renderer_expander_get_type + (c-name "empathy_cell_renderer_expander_get_type") + (return-type "GType") +) + +(define-function 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 cell_renderer_text_get_type + (c-name "empathy_cell_renderer_text_get_type") + (return-type "GType") +) + +(define-function cell_renderer_text_new + (c-name "empathy_cell_renderer_text_new") + (is-constructor-of "EmpathyCellRendererText") + (return-type "GtkCellRenderer*") +) + + + +;; From empathy-chat.h + +(define-function chat_get_type + (c-name "empathy_chat_get_type") + (return-type "GType") +) + +(define-function chat_new + (c-name "empathy_chat_new") + (is-constructor-of "EmpathyChat") + (return-type "EmpathyChat*") + (parameters + '("EmpathyTpChat*" "tp_chat") + ) +) + +(define-method get_tp_chat + (of-object "EmpathyChat") + (c-name "empathy_chat_get_tp_chat") + (return-type "EmpathyTpChat*") +) + +(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_account + (of-object "EmpathyChat") + (c-name "empathy_chat_get_account") + (return-type "McAccount*") +) + +(define-method get_id + (of-object "EmpathyChat") + (c-name "empathy_chat_get_id") + (return-type "const-gchar*") +) + +(define-method get_name + (of-object "EmpathyChat") + (c-name "empathy_chat_get_name") + (return-type "const-gchar*") +) + +(define-method get_subject + (of-object "EmpathyChat") + (c-name "empathy_chat_get_subject") + (return-type "const-gchar*") +) + +(define-method get_remote_contact + (of-object "EmpathyChat") + (c-name "empathy_chat_get_remote_contact") + (return-type "EmpathyContact*") +) + +(define-method get_members_count + (of-object "EmpathyChat") + (c-name "empathy_chat_get_members_count") + (return-type "guint") +) + +(define-method get_contact_menu + (of-object "EmpathyChat") + (c-name "empathy_chat_get_contact_menu") + (return-type "GtkWidget*") +) + +(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 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 is_room + (of-object "EmpathyChat") + (c-name "empathy_chat_is_room") + (return-type "gboolean") +) + + + +;; From empathy-chat-text-view.h + +(define-function chat_text_view_get_type + (c-name "empathy_chat_text_view_get_type") + (return-type "GType") +) + +(define-method get_last_contact + (of-object "EmpathyChatTextView") + (c-name "empathy_chat_text_view_get_last_contact") + (return-type "EmpathyContact*") +) + +(define-method set_only_if_date + (of-object "EmpathyChatTextView") + (c-name "empathy_chat_text_view_set_only_if_date") + (return-type "none") + (parameters + '("gboolean" "only_if_date") + ) +) + +(define-method append_body + (of-object "EmpathyChatTextView") + (c-name "empathy_chat_text_view_append_body") + (return-type "none") + (parameters + '("const-gchar*" "body") + '("const-gchar*" "tag") + ) +) + +(define-method append_spacing + (of-object "EmpathyChatTextView") + (c-name "empathy_chat_text_view_append_spacing") + (return-type "none") +) + +(define-method tag_set + (of-object "EmpathyChatTextView") + (c-name "empathy_chat_text_view_tag_set") + (return-type "GtkTextTag*") + (parameters + '("const-gchar*" "tag_name") + '("const-gchar*" "first_property_name") + ) + (varargs #t) +) + + + +;; From empathy-chat-view.h + +(define-function chat_view_get_type + (c-name "empathy_chat_view_get_type") + (return-type "GType") +) + +(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 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_has_selection + (of-object "EmpathyChatView") + (c-name "empathy_chat_view_get_has_selection") + (return-type "gboolean") +) + +(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") +) + + + +;; From empathy-conf.h + +(define-function conf_get_type + (c-name "empathy_conf_get_type") + (return-type "GType") +) + +(define-function conf_get + (c-name "empathy_conf_get") + (return-type "EmpathyConf*") +) + +(define-function 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-dialogs.h + +(define-function 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") + '("gboolean" "is_user") + ) +) + +(define-function new_contact_dialog_show + (c-name "empathy_new_contact_dialog_show") + (return-type "none") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-contact-list-store.h + +(define-function contact_list_store_get_type + (c-name "empathy_contact_list_store_get_type") + (return-type "GType") +) + +(define-function empathy_contact_list_store_new + (is-constructor-of "EmpathyContactListStore") + (c-name "empathy_contact_list_store_new") + (return-type "EmpathyContactListStore*") + (parameters + '("EmpathyContactList*" "list_iface") + ) +) + +(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_show_groups + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_get_show_groups") + (return-type "gboolean") +) + +(define-method set_show_groups + (of-object "EmpathyContactListStore") + (c-name "empathy_contact_list_store_set_show_groups") + (return-type "none") + (parameters + '("gboolean" "show_groups") + ) +) + +(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 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 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 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") + ) +) + + + +;; From empathy-contact-list-view.h + +(define-function contact_list_view_get_type + (c-name "empathy_contact_list_view_get_type") + (return-type "GType") +) + +(define-function contact_list_view_new + (c-name "empathy_contact_list_view_new") + (is-constructor-of "EmpathyContactListView") + (return-type "EmpathyContactListView*") + (parameters + '("EmpathyContactListStore*" "store") + '("EmpathyContactListFeatureFlags" "list_features") + '("EmpathyContactFeatureFlags" "contact_features") + ) +) + +(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*") +) + +(define-method get_group_menu + (of-object "EmpathyContactListView") + (c-name "empathy_contact_list_view_get_group_menu") + (return-type "GtkWidget*") +) + + + +;; From empathy-contact-menu.h + +(define-method menu_new + (of-object "EmpathyContact") + (c-name "empathy_contact_menu_new") + (return-type "GtkWidget*") + (parameters + '("EmpathyContactFeatureFlags" "features") + ) +) + +(define-method chat_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_chat_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method call_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_call_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method log_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_log_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method info_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_info_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method edit_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_edit_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method invite_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_invite_menu_item_new") + (return-type "GtkWidget*") +) + +(define-method file_transfer_menu_item_new + (of-object "EmpathyContact") + (c-name "empathy_contact_file_transfer_menu_item_new") + (return-type "GtkWidget*") +) + + + +;; From empathy-contact-selector.h + +(define-function contact_selector_get_type + (c-name "empathy_contact_selector_get_type") + (return-type "GType") +) + +(define-function contact_selector_new + (c-name "empathy_contact_selector_new") + (is-constructor-of "EmpathyContactSelector") + (return-type "GtkWidget*") + (parameters + '("EmpathyContactList*" "contact_list") + ) +) + +(define-method dup_selected + (of-object "EmpathyContactSelector") + (c-name "empathy_contact_selector_dup_selected") + (return-type "EmpathyContact*") +) + + + +;; From empathy-contact-widget.h + +(define-method widget_new + (of-object "EmpathyContact") + (c-name "empathy_contact_widget_new") + (return-type "GtkWidget*") + (parameters + '("EmpathyContactWidgetFlags" "flags") + ) +) + +(define-function contact_widget_get_contact + (c-name "empathy_contact_widget_get_contact") + (return-type "EmpathyContact*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-function contact_widget_set_contact + (c-name "empathy_contact_widget_set_contact") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("EmpathyContact*" "contact") + ) +) + +(define-function contact_widget_set_account_filter + (c-name "empathy_contact_widget_set_account_filter") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("EmpathyAccountChooserFilterFunc" "filter") + '("gpointer" "user_data") + ) +) + + + +;; From empathy-geometry.h + +(define-function geometry_save + (c-name "empathy_geometry_save") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("gint" "x") + '("gint" "y") + '("gint" "w") + '("gint" "h") + ) +) + +(define-function geometry_load + (c-name "empathy_geometry_load") + (return-type "none") + (parameters + '("const-gchar*" "name") + '("gint*" "x") + '("gint*" "y") + '("gint*" "w") + '("gint*" "h") + ) +) + + + +;; From empathy-audio-sink.h + +(define-function audio_sink_get_type + (c-name "empathy_audio_sink_get_type") + (return-type "GType") +) + +(define-function audio_sink_new + (c-name "empathy_audio_sink_new") + (is-constructor-of "EmpathyAudioSink") + (return-type "GstElement*") +) + +(define-function audio_sink_set_volume + (c-name "empathy_audio_sink_set_volume") + (return-type "none") + (parameters + '("EmpathyGstAudioSink*" "sink") + '("gdouble" "volume") + ) +) + +(define-function audio_sink_get_volume + (c-name "empathy_audio_sink_get_volume") + (return-type "gdouble") + (parameters + '("EmpathyGstAudioSink*" "sink") + ) +) + + + +;; From empathy-audio-src.h + +(define-function audio_src_get_type + (c-name "empathy_audio_src_get_type") + (return-type "GType") +) + +(define-function audio_src_new + (c-name "empathy_audio_src_new") + (is-constructor-of "EmpathyAudioSrc") + (return-type "GstElement*") +) + +(define-function audio_src_set_volume + (c-name "empathy_audio_src_set_volume") + (return-type "none") + (parameters + '("EmpathyGstAudioSrc*" "src") + '("gdouble" "volume") + ) +) + +(define-function audio_src_get_volume + (c-name "empathy_audio_src_get_volume") + (return-type "gdouble") + (parameters + '("EmpathyGstAudioSrc*" "src") + ) +) + + + +;; From empathy-video-src.h + +(define-function video_src_get_type + (c-name "empathy_video_src_get_type") + (return-type "GType") +) + +(define-function video_src_new + (c-name "empathy_video_src_new") + (is-constructor-of "EmpathyVideoSrc") + (return-type "GstElement*") +) + +(define-function video_src_get_supported_channels + (c-name "empathy_video_src_get_supported_channels") + (return-type "guint") + (parameters + '("GstElement*" "src") + ) +) + +(define-function video_src_set_channel + (c-name "empathy_video_src_set_channel") + (return-type "none") + (parameters + '("GstElement*" "src") + '("EmpathyGstVideoSrcChannel" "channel") + '("guint" "percent") + ) +) + +(define-function video_src_get_channel + (c-name "empathy_video_src_get_channel") + (return-type "guint") + (parameters + '("GstElement*" "src") + '("EmpathyGstVideoSrcChannel" "channel") + ) +) + + + +;; From empathy-video-widget.h + +(define-function video_widget_get_type + (c-name "empathy_video_widget_get_type") + (return-type "GType") +) + +(define-function video_widget_new + (c-name "empathy_video_widget_new") + (is-constructor-of "EmpathyVideoWidget") + (return-type "GtkWidget*") + (parameters + '("GstBus*" "bus") + ) +) + +(define-function video_widget_new_with_size + (c-name "empathy_video_widget_new_with_size") + (return-type "GtkWidget*") + (parameters + '("GstBus*" "bus") + '("gint" "width") + '("gint" "height") + ) +) + +(define-method get_element + (of-object "EmpathyVideoWidget") + (c-name "empathy_video_widget_get_element") + (return-type "GstElement*") +) + +(define-method get_sink + (of-object "EmpathyVideoWidget") + (c-name "empathy_video_widget_get_sink") + (return-type "GstPad*") +) + + + +;; From empathy-images.h + + + +;; From empathy-irc-network-dialog.h + +(define-method dialog_show + (of-object "EmpathyIrcNetwork") + (c-name "empathy_irc_network_dialog_show") + (return-type "GtkWidget*") + (parameters + '("GtkWidget*" "parent") + ) +) + + + +;; From empathy-log-window.h + +(define-function log_window_show + (c-name "empathy_log_window_show") + (return-type "GtkWidget*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-new-message-dialog.h + +(define-function new_message_dialog_show + (c-name "empathy_new_message_dialog_show") + (return-type "GtkWidget*") + (parameters + '("GtkWindow*" "parent") + ) +) + + + +;; From empathy-presence-chooser.h + +(define-function presence_chooser_get_type + (c-name "empathy_presence_chooser_get_type") + (return-type "GType") +) + +(define-function presence_chooser_new + (c-name "empathy_presence_chooser_new") + (is-constructor-of "EmpathyPresenceChooser") + (return-type "GtkWidget*") +) + +(define-function presence_chooser_create_menu + (c-name "empathy_presence_chooser_create_menu") + (return-type "GtkWidget*") +) + + + +;; From empathy-profile-chooser.h + +(define-function profile_chooser_new + (c-name "empathy_profile_chooser_new") + (is-constructor-of "EmpathyProfileChooser") + (return-type "GtkWidget*") +) + +(define-function profile_chooser_get_selected + (c-name "empathy_profile_chooser_get_selected") + (return-type "McProfile*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-function profile_chooser_n_profiles + (c-name "empathy_profile_chooser_n_profiles") + (return-type "gint") + (parameters + '("GtkWidget*" "widget") + ) +) + + + +;; From empathy-smiley-manager.h + +(define-function smiley_manager_get_type + (c-name "empathy_smiley_manager_get_type") + (return-type "GType") +) + +(define-function smiley_manager_dup_singleton + (c-name "empathy_smiley_manager_dup_singleton") + (return-type "EmpathySmileyManager*") +) + +(define-method load + (of-object "EmpathySmileyManager") + (c-name "empathy_smiley_manager_load") + (return-type "none") +) + +(define-method add + (of-object "EmpathySmileyManager") + (c-name "empathy_smiley_manager_add") + (return-type "none") + (parameters + '("const-gchar*" "icon_name") + '("const-gchar*" "first_str") + ) + (varargs #t) +) + +(define-method add_from_pixbuf + (of-object "EmpathySmileyManager") + (c-name "empathy_smiley_manager_add_from_pixbuf") + (return-type "none") + (parameters + '("GdkPixbuf*" "smiley") + '("const-gchar*" "first_str") + ) + (varargs #t) +) + +(define-method get_all + (of-object "EmpathySmileyManager") + (c-name "empathy_smiley_manager_get_all") + (return-type "GSList*") +) + +(define-method parse + (of-object "EmpathySmileyManager") + (c-name "empathy_smiley_manager_parse") + (return-type "GSList*") + (parameters + '("const-gchar*" "text") + ) +) + +(define-function smiley_menu_new + (c-name "empathy_smiley_menu_new") + (is-constructor-of "EmpathySmileyMenu") + (return-type "GtkWidget*") + (parameters + '("EmpathySmileyManager*" "manager") + '("EmpathySmileyMenuFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method free + (of-object "EmpathySmiley") + (c-name "empathy_smiley_free") + (return-type "none") +) + + + +;; From empathy-spell.h + +(define-function spell_supported + (c-name "empathy_spell_supported") + (return-type "gboolean") +) + +(define-function spell_get_language_name + (c-name "empathy_spell_get_language_name") + (return-type "const-gchar*") + (parameters + '("const-gchar*" "code") + ) +) + +(define-function spell_get_language_codes + (c-name "empathy_spell_get_language_codes") + (return-type "GList*") +) + +(define-function spell_free_language_codes + (c-name "empathy_spell_free_language_codes") + (return-type "none") + (parameters + '("GList*" "codes") + ) +) + +(define-function spell_check + (c-name "empathy_spell_check") + (return-type "gboolean") + (parameters + '("const-gchar*" "word") + ) +) + +(define-function spell_get_suggestions + (c-name "empathy_spell_get_suggestions") + (return-type "GList*") + (parameters + '("const-gchar*" "word") + ) +) + +(define-function spell_free_suggestions + (c-name "empathy_spell_free_suggestions") + (return-type "none") + (parameters + '("GList*" "suggestions") + ) +) + + + +;; From empathy-spell-dialog.h + +(define-function spell_dialog_show + (c-name "empathy_spell_dialog_show") + (return-type "none") + (parameters + '("EmpathyChat*" "chat") + '("GtkTextIter*" "start") + '("GtkTextIter*" "end") + '("const-gchar*" "word") + ) +) + + + +;; From empathy-theme-boxes.h + +(define-function theme_boxes_get_type + (c-name "empathy_theme_boxes_get_type") + (return-type "GType") +) + +(define-function theme_boxes_new + (c-name "empathy_theme_boxes_new") + (is-constructor-of "EmpathyThemeBoxes") + (return-type "EmpathyThemeBoxes*") +) + + + +;; From empathy-theme-irc.h + +(define-function theme_irc_get_type + (c-name "empathy_theme_irc_get_type") + (return-type "GType") +) + +(define-function theme_irc_new + (c-name "empathy_theme_irc_new") + (is-constructor-of "EmpathyThemeIrc") + (return-type "EmpathyThemeIrc*") +) + + + +;; From empathy-theme-manager.h + +(define-function theme_manager_get_type + (c-name "empathy_theme_manager_get_type") + (return-type "GType") +) + +(define-function theme_manager_get + (c-name "empathy_theme_manager_get") + (return-type "EmpathyThemeManager*") +) + +(define-function theme_manager_get_themes + (c-name "empathy_theme_manager_get_themes") + (return-type "const-gchar**") +) + +(define-method create_view + (of-object "EmpathyThemeManager") + (c-name "empathy_theme_manager_create_view") + (return-type "EmpathyChatView*") +) + + + +;; From empathy-ui-utils.h + +(define-function gtk_init + (c-name "empathy_gtk_init") + (return-type "none") +) + +(define-function uri_regex_dup_singleton + (c-name "empathy_uri_regex_dup_singleton") + (return-type "GRegex*") +) + +(define-function 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 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 glade_connect + (c-name "empathy_glade_connect") + (return-type "none") + (parameters + '("GladeXML*" "gui") + '("gpointer" "user_data") + '("gchar*" "first_widget") + ) + (varargs #t) +) + +(define-function 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 icon_name_from_account + (c-name "empathy_icon_name_from_account") + (return-type "const-gchar*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function icon_name_for_presence + (c-name "empathy_icon_name_for_presence") + (return-type "const-gchar*") + (parameters + '("McPresence" "presence") + ) +) + +(define-function icon_name_for_contact + (c-name "empathy_icon_name_for_contact") + (return-type "const-gchar*") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function pixbuf_from_data + (c-name "empathy_pixbuf_from_data") + (return-type "GdkPixbuf*") + (parameters + '("gchar*" "data") + '("gsize" "data_size") + ) +) + +(define-function pixbuf_from_data_and_mime + (c-name "empathy_pixbuf_from_data_and_mime") + (return-type "GdkPixbuf*") + (parameters + '("gchar*" "data") + '("gsize" "data_size") + '("gchar**" "mime_type") + ) +) + +(define-function pixbuf_from_avatar_scaled + (c-name "empathy_pixbuf_from_avatar_scaled") + (return-type "GdkPixbuf*") + (parameters + '("EmpathyAvatar*" "avatar") + '("gint" "width") + '("gint" "height") + ) +) + +(define-function 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 pixbuf_scale_down_if_necessary + (c-name "empathy_pixbuf_scale_down_if_necessary") + (return-type "GdkPixbuf*") + (parameters + '("GdkPixbuf*" "pixbuf") + '("gint" "max_size") + ) +) + +(define-function pixbuf_from_icon_name + (c-name "empathy_pixbuf_from_icon_name") + (return-type "GdkPixbuf*") + (parameters + '("const-gchar*" "icon_name") + '("GtkIconSize" "icon_size") + ) +) + +(define-function pixbuf_from_icon_name_sized + (c-name "empathy_pixbuf_from_icon_name_sized") + (return-type "GdkPixbuf*") + (parameters + '("const-gchar*" "icon_name") + '("gint" "size") + ) +) + +(define-function 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 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 window_get_is_visible + (c-name "empathy_window_get_is_visible") + (return-type "gboolean") + (parameters + '("GtkWindow*" "window") + ) +) + +(define-function window_present + (c-name "empathy_window_present") + (return-type "none") + (parameters + '("GtkWindow*" "window") + '("gboolean" "steal_focus") + ) +) + +(define-function window_iconify + (c-name "empathy_window_iconify") + (return-type "none") + (parameters + '("GtkWindow*" "window") + '("GtkStatusIcon*" "status_icon") + ) +) + +(define-function get_toplevel_window + (c-name "empathy_get_toplevel_window") + (return-type "GtkWindow*") + (parameters + '("GtkWidget*" "widget") + ) +) + +(define-function url_show + (c-name "empathy_url_show") + (return-type "none") + (parameters + '("GtkWidget*" "parent") + '("const-char*" "url") + ) +) + +(define-function 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 link_button_new + (c-name "empathy_link_button_new") + (is-constructor-of "EmpathyLinkButton") + (return-type "GtkWidget*") + (parameters + '("const-gchar*" "url") + '("const-gchar*" "title") + ) +) + +(define-function send_file_with_file_chooser + (c-name "empathy_send_file_with_file_chooser") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function sound_play + (c-name "empathy_sound_play") + (return-type "none") + (parameters + '("GtkWidget*" "widget") + '("EmpathySound" "sound_id") + ) +) + +(define-function sound_play_full + (c-name "empathy_sound_play_full") + (return-type "gboolean") + (parameters + '("GtkWidget*" "widget") + '("EmpathySound" "sound_id") + '("ca_finish_callback_t" "callback") + '("gpointer" "user_data") + ) +) + +(define-method stop + (of-object "EmpathySound") + (c-name "empathy_sound_stop") + (return-type "none") +) + + diff --git a/gnome-2-26/python/pyempathygtk/pyempathygtk.override b/gnome-2-26/python/pyempathygtk/pyempathygtk.override new file mode 100644 index 000000000..7493c42bc --- /dev/null +++ b/gnome-2-26/python/pyempathygtk/pyempathygtk.override @@ -0,0 +1,79 @@ +%% +headers +#include <Python.h> +#include <pygobject.h> +#include "empathy-account-chooser.h" +#include "empathy-account-widget.h" +#include "empathy-account-widget-irc.h" +#include "empathy-audio-sink.h" +#include "empathy-audio-src.h" +#include "empathy-avatar-chooser.h" +#include "empathy-avatar-image.h" +#include "empathy-cell-renderer-activatable.h" +#include "empathy-cell-renderer-expander.h" +#include "empathy-cell-renderer-text.h" +#include "empathy-chat.h" +#include "empathy-chat-view.h" +#include "empathy-conf.h" +#include "empathy-contact-dialogs.h" +#include "empathy-contact-list-store.h" +#include "empathy-contact-list-view.h" +#include "empathy-contact-selector.h" +#include "empathy-contact-widget.h" +#include "empathy-geometry.h" +#include "empathy-gtk-enum-types.h" +#include "empathy-images.h" +#include "empathy-irc-network-dialog.h" +#include "empathy-log-window.h" +#include "empathy-new-message-dialog.h" +#include "empathy-presence-chooser.h" +#include "empathy-profile-chooser.h" +#include "empathy-smiley-manager.h" +#include "empathy-spell-dialog.h" +#include "empathy-spell.h" +#include "empathy-theme-boxes.h" +#include "empathy-theme-irc.h" +#include "empathy-theme-manager.h" +#include "empathy-ui-utils.h" +#include "empathy-video-src.h" +#include "empathy-video-widget.h" + +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 gtk.Button as PyGtkButton_Type +import gtk.EventBox as PyGtkEventBox_Type +import gtk.CellRendererPixbuf as PyGtkCellRendererPixbuf_Type +import gtk.gdk.Pixbuf as PyGdkPixbuf_Type +import gtk.Bin as PyGtkBin_Type +import gtk.DrawingArea as PyGtkDrawingArea_Type +import gst.GstBin as PyGstBin_Type +import empathy.Contact as PyEmpathyContact_Type +import empathy.ContactList as PyEmpathyContactList_Type +import empathy.TpChat as PyEmpathyTpChat_Type +import empathy.Message as PyEmpathyMessage_Type +import empathy.TpCall as PyEmpathyTpCall_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/gnome-2-26/python/pyempathygtk/pyempathygtkmodule.c b/gnome-2-26/python/pyempathygtk/pyempathygtkmodule.c new file mode 100644 index 000000000..20e09e3f3 --- /dev/null +++ b/gnome-2-26/python/pyempathygtk/pyempathygtkmodule.c @@ -0,0 +1,27 @@ +#define NO_IMPORT_PYGOBJECT + +#include <pygobject.h> + +void empathy_register_classes (PyObject *d); +void empathy_add_constants(PyObject *module, const gchar *strip_prefix); +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); + empathy_add_constants(m, "EMPATHY_"); + + if (PyErr_Occurred ()) { + PyErr_Print(); + Py_FatalError ("can't initialise module empathygtk"); + } +} + diff --git a/gnome-2-26/python/update-binding.sh b/gnome-2-26/python/update-binding.sh new file mode 100755 index 000000000..19c8f10b0 --- /dev/null +++ b/gnome-2-26/python/update-binding.sh @@ -0,0 +1,106 @@ +#! /bin/sh +#Manually update headers in pyempathy.override and pyempathygtk.override. + +# Update the list of headers from Makefile.am +cd ../libempathy +python /usr/share/pygobject/2.0/codegen/h2def.py \ + -m empathy \ + empathy-account-manager.h \ + empathy-chatroom.h \ + empathy-chatroom-manager.h \ + empathy-call-factory.h \ + empathy-call-handler.h \ + empathy-contact.h \ + empathy-contact-factory.h \ + empathy-contact-groups.h \ + empathy-contact-list.h \ + empathy-contact-manager.h \ + empathy-contact-monitor.h \ + empathy-debug.h \ + empathy-dispatcher.h \ + empathy-dispatch-operation.h \ + empathy-idle.h \ + empathy-irc-network.h \ + empathy-irc-network-manager.h \ + empathy-irc-server.h \ + empathy-log-manager.h \ + empathy-log-store.h \ + empathy-log-store-empathy.h \ + empathy-message.h \ + empathy-status-presets.h \ + empathy-time.h \ + empathy-tp-call.h \ + empathy-tp-chat.h \ + empathy-tp-contact-factory.h \ + empathy-tp-contact-list.h \ + empathy-tp-file.h \ + empathy-tp-group.h \ + empathy-tp-roomlist.h \ + empathy-tp-tube.h \ + empathy-tube-handler.h \ + empathy-types.h \ + empathy-utils.h \ + > ../python/pyempathy/pyempathy.defs + +# Update the list of headers from Makefile.am +cd ../libempathy-gtk +python /usr/share/pygobject/2.0/codegen/h2def.py \ + -m empathy \ + empathy-account-chooser.h \ + empathy-account-widget.h \ + empathy-account-widget-irc.h \ + empathy-account-widget-sip.h \ + empathy-avatar-chooser.h \ + empathy-avatar-image.h \ + empathy-cell-renderer-activatable.h \ + empathy-cell-renderer-expander.h \ + empathy-cell-renderer-text.h \ + empathy-chat.h \ + empathy-chat-text-view.h \ + empathy-chat-view.h \ + empathy-conf.h \ + empathy-contact-dialogs.h \ + empathy-contact-list-store.h \ + empathy-contact-list-view.h \ + empathy-contact-menu.h \ + empathy-contact-selector.h \ + empathy-contact-widget.h \ + empathy-geometry.h \ + empathy-audio-sink.h \ + empathy-audio-src.h \ + empathy-video-src.h \ + empathy-video-widget.h \ + empathy-images.h \ + empathy-irc-network-dialog.h \ + empathy-log-window.h \ + empathy-new-message-dialog.h \ + empathy-presence-chooser.h \ + empathy-profile-chooser.h \ + empathy-smiley-manager.h \ + empathy-spell.h \ + empathy-spell-dialog.h \ + empathy-theme-boxes.h \ + empathy-theme-irc.h \ + empathy-theme-manager.h \ + empathy-ui-utils.h \ + > ../python/pyempathygtk/pyempathygtk.defs + +# Keep original version +cd ../python +cp pyempathy/pyempathy.defs /tmp +cp pyempathygtk/pyempathygtk.defs /tmp + +# Apply patches +patch -p0 < pyempathy.patch +patch -p0 < pyempathygtk.patch + +# Fix define of interfaces, they are not objects +sed -e 's/define-object \(ChatView$\)/define-interface \1/' \ + -i pyempathygtk/pyempathygtk.defs +sed -e 's/define-object \(ContactList$\)/define-interface \1/' \ + -i pyempathy/pyempathy.defs + +# Make modification then run that: +#diff -up /tmp/pyempathy.defs pyempathy/pyempathy.defs > pyempathy.patch +#diff -up /tmp/pyempathygtk.defs pyempathygtk/pyempathygtk.defs > pyempathygtk.patch + |