diff options
Diffstat (limited to 'trunk/python/pyempathy/pyempathy.defs')
| -rw-r--r-- | trunk/python/pyempathy/pyempathy.defs | 2305 |
1 files changed, 2305 insertions, 0 deletions
diff --git a/trunk/python/pyempathy/pyempathy.defs b/trunk/python/pyempathy/pyempathy.defs new file mode 100644 index 000000000..cc9ef339e --- /dev/null +++ b/trunk/python/pyempathy/pyempathy.defs @@ -0,0 +1,2305 @@ +;; -*- scheme -*- +; object definitions ... +(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 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 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 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 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") + '("other" "EMPATHY_DEBUG_OTHER") + ) +) + +(define-enum RegExType + (in-module "Empathy") + (c-name "EmpathyRegExType") + (gtype-id "EMPATHY_TYPE_REG_EX_TYPE") + (values + '("as-is" "EMPATHY_REGEX_AS_IS") + '("browser" "EMPATHY_REGEX_BROWSER") + '("apt" "EMPATHY_REGEX_APT") + '("email" "EMPATHY_REGEX_EMAIL") + '("other" "EMPATHY_REGEX_OTHER") + '("all" "EMPATHY_REGEX_ALL") + ) +) + +(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") + '("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-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-avatar.h + +(define-function empathy_avatar_get_type + (c-name "empathy_avatar_get_type") + (return-type "GType") +) + +(define-function empathy_avatar_new + (c-name "empathy_avatar_new") + (is-constructor-of "EmpathyAvatar") + (return-type "EmpathyAvatar*") + (parameters + '("const-guchar*" "avatar") + '("const-gsize" "len") + '("const-gchar*" "format") + '("const-gchar*" "token") + ) +) + +(define-function empathy_avatar_new_from_cache + (c-name "empathy_avatar_new_from_cache") + (return-type "EmpathyAvatar*") + (parameters + '("const-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") +) + + + +;; From empathy-time.h + +(define-function empathy_time_get_current + (c-name "empathy_time_get_current") + (return-type "time_t") +) + +(define-function empathy_time_get_local_time + (c-name "empathy_time_get_local_time") + (return-type "time_t") + (parameters + '("struct-tm*" "tm") + ) +) + +(define-function empathy_time_parse + (c-name "empathy_time_parse") + (return-type "time_t") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function empathy_time_to_string_utc + (c-name "empathy_time_to_string_utc") + (return-type "gchar*") + (parameters + '("time_t" "t") + '("const-gchar*" "format") + ) +) + +(define-function empathy_time_to_string_local + (c-name "empathy_time_to_string_local") + (return-type "gchar*") + (parameters + '("time_t" "t") + '("const-gchar*" "format") + ) +) + + + +;; From empathy-status-presets.h + +(define-function empathy_status_presets_get_all + (c-name "empathy_status_presets_get_all") + (return-type "none") +) + +(define-function empathy_status_presets_get + (c-name "empathy_status_presets_get") + (return-type "GList*") + (parameters + '("McPresence" "state") + '("gint" "max_number") + ) +) + +(define-function empathy_status_presets_set_last + (c-name "empathy_status_presets_set_last") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_remove + (c-name "empathy_status_presets_remove") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_reset + (c-name "empathy_status_presets_reset") + (return-type "none") +) + +(define-function empathy_status_presets_get_default_state + (c-name "empathy_status_presets_get_default_state") + (return-type "McPresence") +) + +(define-function empathy_status_presets_get_default_status + (c-name "empathy_status_presets_get_default_status") + (return-type "const-gchar*") +) + +(define-function empathy_status_presets_set_default + (c-name "empathy_status_presets_set_default") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(define-function empathy_status_presets_clear_default + (c-name "empathy_status_presets_clear_default") + (return-type "none") +) + + + +;; From empathy-debug.h + +(define-function empathy_debug_flag_is_set + (c-name "empathy_debug_flag_is_set") + (return-type "gboolean") + (parameters + '("EmpathyDebugFlags" "flag") + ) +) + +(define-function empathy_debug + (c-name "empathy_debug") + (return-type "none") + (parameters + '("EmpathyDebugFlags" "flag") + '("const-gchar*" "format") + ) + (varargs #t) +) + +(define-function empathy_debug_set_flags + (c-name "empathy_debug_set_flags") + (return-type "none") + (parameters + '("const-gchar*" "flags_string") + ) +) + + + +;; From empathy-utils.h + +(define-function empathy_substring + (c-name "empathy_substring") + (return-type "gchar*") + (parameters + '("const-gchar*" "str") + '("gint" "start") + '("gint" "end") + ) +) + +(define-function empathy_regex_match + (c-name "empathy_regex_match") + (return-type "gint") + (parameters + '("EmpathyRegExType" "type") + '("const-gchar*" "msg") + '("GArray*" "start") + '("GArray*" "end") + ) +) + +(define-function empathy_strcasecmp + (c-name "empathy_strcasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + ) +) + +(define-function empathy_strncasecmp + (c-name "empathy_strncasecmp") + (return-type "gint") + (parameters + '("const-gchar*" "s1") + '("const-gchar*" "s2") + '("gsize" "n") + ) +) + +(define-function empathy_xml_validate + (c-name "empathy_xml_validate") + (return-type "gboolean") + (parameters + '("xmlDoc*" "doc") + '("const-gchar*" "dtd_filename") + ) +) + +(define-function empathy_xml_node_get_child + (c-name "empathy_xml_node_get_child") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "child_name") + ) +) + +(define-function empathy_xml_node_get_child_content + (c-name "empathy_xml_node_get_child_content") + (return-type "xmlChar*") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "child_name") + ) +) + +(define-function empathy_xml_node_find_child_prop_value + (c-name "empathy_xml_node_find_child_prop_value") + (return-type "xmlNodePtr") + (parameters + '("xmlNodePtr" "node") + '("const-gchar*" "prop_name") + '("const-gchar*" "prop_value") + ) +) + +(define-function empathy_account_hash + (c-name "empathy_account_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-function empathy_account_equal + (c-name "empathy_account_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "a") + '("gconstpointer" "b") + ) +) + +(define-function empathy_mission_control_new + (c-name "empathy_mission_control_new") + (is-constructor-of "EmpathyMissionControl") + (return-type "MissionControl*") +) + +(define-function empathy_call_with_contact + (c-name "empathy_call_with_contact") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function empathy_call_with_contact_id + (c-name "empathy_call_with_contact_id") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "contact_id") + ) +) + +(define-function empathy_chat_with_contact + (c-name "empathy_chat_with_contact") + (return-type "none") + (parameters + '("EmpathyContact*" "contact") + ) +) + +(define-function empathy_chat_with_contact_id + (c-name "empathy_chat_with_contact_id") + (return-type "none") + (parameters + '("McAccount*" "account") + '("const-gchar*" "contact_id") + ) +) + +(define-function empathy_presence_get_default_message + (c-name "empathy_presence_get_default_message") + (return-type "const-gchar*") + (parameters + '("McPresence" "presence") + ) +) + +(define-function empathy_presence_to_str + (c-name "empathy_presence_to_str") + (return-type "const-gchar*") + (parameters + '("McPresence" "presence") + ) +) + +(define-function empathy_presence_from_str + (c-name "empathy_presence_from_str") + (return-type "McPresence") + (parameters + '("const-gchar*" "str") + ) +) + +(define-function empathy_file_lookup + (c-name "empathy_file_lookup") + (return-type "gchar*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "subdir") + ) +) + +(define-function empathy_run_until_ready + (c-name "empathy_run_until_ready") + (return-type "none") + (parameters + '("gpointer" "object") + ) +) + +(define-function empathy_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 empathy_channel_get_account + (c-name "empathy_channel_get_account") + (return-type "McAccount*") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-function empathy_connect_to_account_status_changed + (c-name "empathy_connect_to_account_status_changed") + (return-type "gpointer") + (parameters + '("MissionControl*" "mc") + '("GCallback" "handler") + '("gpointer" "user_data") + '("GClosureNotify" "free_func") + ) +) + +(define-function empathy_disconnect_account_status_changed + (c-name "empathy_disconnect_account_status_changed") + (return-type "none") + (parameters + '("gpointer" "token") + ) +) + + + +;; From empathy-message.h + +(define-function empathy_message_get_type + (c-name "empathy_message_get_type") + (return-type "GType") +) + +(define-function empathy_message_new + (c-name "empathy_message_new") + (is-constructor-of "EmpathyMessage") + (return-type "EmpathyMessage*") + (parameters + '("const-gchar*" "body") + ) +) + +(define-method get_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 get_date_and_time + (of-object "EmpathyMessage") + (c-name "empathy_message_get_date_and_time") + (return-type "GDate*") + (parameters + '("time_t*" "timestamp") + ) +) + +(define-method should_highlight + (of-object "EmpathyMessage") + (c-name "empathy_message_should_highlight") + (return-type "gboolean") +) + +(define-function empathy_message_type_from_str + (c-name "empathy_message_type_from_str") + (return-type "TpChannelTextMessageType") + (parameters + '("const-gchar*" "type_str") + ) +) + +(define-function empathy_message_type_to_str + (c-name "empathy_message_type_to_str") + (return-type "const-gchar*") + (parameters + '("TpChannelTextMessageType" "type") + ) +) + + + +;; From empathy-chatroom-manager.h + +(define-function empathy_chatroom_manager_get_type + (c-name "empathy_chatroom_manager_get_type") + (return-type "GType") +) + +(define-function empathy_chatroom_manager_new + (c-name "empathy_chatroom_manager_new") + (is-constructor-of "EmpathyChatroomManager") + (return-type "EmpathyChatroomManager*") +) + +(define-method add + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_add") + (return-type "gboolean") + (parameters + '("EmpathyChatroom*" "chatroom") + ) +) + +(define-method remove + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_remove") + (return-type "none") + (parameters + '("EmpathyChatroom*" "chatroom") + ) +) + +(define-method find + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_find") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + ) +) + +(define-method get_chatrooms + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_get_chatrooms") + (return-type "GList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_count + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_get_count") + (return-type "guint") + (parameters + '("McAccount*" "account") + ) +) + +(define-method store + (of-object "EmpathyChatroomManager") + (c-name "empathy_chatroom_manager_store") + (return-type "none") +) + + + +;; From empathy-chatroom.h + +(define-function empathy_chatroom_get_type + (c-name "empathy_chatroom_get_type") + (return-type "GType") +) + +(define-function empathy_chatroom_new + (c-name "empathy_chatroom_new") + (is-constructor-of "EmpathyChatroom") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + ) +) + +(define-function empathy_chatroom_new_full + (c-name "empathy_chatroom_new_full") + (return-type "EmpathyChatroom*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "room") + '("const-gchar*" "name") + '("gboolean" "auto_connect") + ) +) + +(define-method get_account + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_account") + (return-type "McAccount*") +) + +(define-method set_account + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_account") + (return-type "none") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_room + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_room") + (return-type "const-gchar*") +) + +(define-method set_room + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_room") + (return-type "none") + (parameters + '("const-gchar*" "room") + ) +) + +(define-method get_name + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_name") + (return-type "const-gchar*") +) + +(define-method set_name + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_name") + (return-type "none") + (parameters + '("const-gchar*" "name") + ) +) + +(define-method get_auto_connect + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_get_auto_connect") + (return-type "gboolean") +) + +(define-method set_auto_connect + (of-object "EmpathyChatroom") + (c-name "empathy_chatroom_set_auto_connect") + (return-type "none") + (parameters + '("gboolean" "auto_connect") + ) +) + +(define-function empathy_chatroom_equal + (c-name "empathy_chatroom_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + + + +;; From empathy-contact.h + +(define-function empathy_contact_get_type + (c-name "empathy_contact_get_type") + (return-type "GType") +) + +(define-function empathy_contact_new + (c-name "empathy_contact_new") + (is-constructor-of "EmpathyContact") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + ) +) + +(define-function empathy_contact_new_full + (c-name "empathy_contact_new_full") + (return-type "EmpathyContact*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "id") + '("const-gchar*" "name") + ) +) + +(define-method get_id + (of-object "EmpathyContact") + (c-name "empathy_contact_get_id") + (return-type "const-gchar*") +) + +(define-method 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-function empathy_contact_equal + (c-name "empathy_contact_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function empathy_contact_hash + (c-name "empathy_contact_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-method run_until_ready + (of-object "EmpathyContact") + (c-name "empathy_contact_run_until_ready") + (return-type "none") + (parameters + '("EmpathyContactReady" "ready") + '("GMainLoop**" "loop") + ) +) + + + +;; From empathy-contact-groups.h + +(define-function empathy_contact_groups_get_all + (c-name "empathy_contact_groups_get_all") + (return-type "none") +) + +(define-function empathy_contact_group_get_expanded + (c-name "empathy_contact_group_get_expanded") + (return-type "gboolean") + (parameters + '("const-gchar*" "group") + ) +) + +(define-function empathy_contact_group_set_expanded + (c-name "empathy_contact_group_set_expanded") + (return-type "none") + (parameters + '("const-gchar*" "group") + '("gboolean" "expanded") + ) +) + + + +;; From empathy-contact-list.h + +(define-function empathy_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") + ) +) + + + +;; From empathy-contact-manager.h + +(define-function empathy_contact_manager_get_type + (c-name "empathy_contact_manager_get_type") + (return-type "GType") +) + +(define-function empathy_contact_manager_new + (c-name "empathy_contact_manager_new") + (is-constructor-of "EmpathyContactManager") + (return-type "EmpathyContactManager*") +) + +(define-method get_list + (of-object "EmpathyContactManager") + (c-name "empathy_contact_manager_get_list") + (return-type "EmpathyTpContactList*") + (parameters + '("McAccount*" "account") + ) +) + + + +;; From empathy-contact-factory.h + +(define-function empathy_contact_factory_get_type + (c-name "empathy_contact_factory_get_type") + (return-type "GType") +) + +(define-function empathy_contact_factory_new + (c-name "empathy_contact_factory_new") + (is-constructor-of "EmpathyContactFactory") + (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-tp-contact-factory.h + +(define-function empathy_tp_contact_factory_get_type + (c-name "empathy_tp_contact_factory_get_type") + (return-type "GType") +) + +(define-function empathy_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-group.h + +(define-function empathy_tp_group_get_type + (c-name "empathy_tp_group_get_type") + (return-type "GType") +) + +(define-function empathy_tp_group_new + (c-name "empathy_tp_group_new") + (is-constructor-of "EmpathyTpGroup") + (return-type "EmpathyTpGroup*") + (parameters + '("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 empathy_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") +) + + + +;; From empathy-tp-contact-list.h + +(define-function empathy_tp_contact_list_get_type + (c-name "empathy_tp_contact_list_get_type") + (return-type "GType") +) + +(define-function empathy_tp_contact_list_new + (c-name "empathy_tp_contact_list_new") + (is-constructor-of "EmpathyTpContactList") + (return-type "EmpathyTpContactList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method get_account + (of-object "EmpathyTpContactList") + (c-name "empathy_tp_contact_list_get_account") + (return-type "McAccount*") +) + + + +;; From empathy-tp-chat.h + +(define-function empathy_tp_chat_get_type + (c-name "empathy_tp_chat_get_type") + (return-type "GType") +) + +(define-function empathy_tp_chat_new + (c-name "empathy_tp_chat_new") + (is-constructor-of "EmpathyTpChat") + (return-type "EmpathyTpChat*") + (parameters + '("TpChannel*" "channel") + ) +) + +(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 set_acknowledge + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_set_acknowledge") + (return-type "none") + (parameters + '("gboolean" "acknowledge") + ) +) + +(define-method emit_pendings + (of-object "EmpathyTpChat") + (c-name "empathy_tp_chat_emit_pendings") + (return-type "none") +) + +(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") + ) +) + + + +;; From empathy-tp-roomlist.h + +(define-function empathy_tp_roomlist_get_type + (c-name "empathy_tp_roomlist_get_type") + (return-type "GType") +) + +(define-function empathy_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-call.h + +(define-function empathy_tp_call_get_type + (c-name "empathy_tp_call_get_type") + (return-type "GType") +) + +(define-function empathy_tp_call_new + (c-name "empathy_tp_call_new") + (is-constructor-of "EmpathyTpCall") + (return-type "EmpathyTpCall*") + (parameters + '("TpChannel*" "channel") + ) +) + +(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 add_preview_video + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_add_preview_video") + (return-type "none") + (parameters + '("guint" "preview_video_socket_id") + ) +) + +(define-method remove_preview_video + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_remove_preview_video") + (return-type "none") + (parameters + '("guint" "preview_video_socket_id") + ) +) + +(define-method add_output_video + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_add_output_video") + (return-type "none") + (parameters + '("guint" "output_video_socket_id") + ) +) + +(define-method set_output_volume + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_set_output_volume") + (return-type "none") + (parameters + '("guint" "volume") + ) +) + +(define-method mute_output + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_mute_output") + (return-type "none") + (parameters + '("gboolean" "is_muted") + ) +) + +(define-method mute_input + (of-object "EmpathyTpCall") + (c-name "empathy_tp_call_mute_input") + (return-type "none") + (parameters + '("gboolean" "is_muted") + ) +) + +(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") +) + + + +;; From empathy-tp-tube.h + +(define-function empathy_tp_tube_get_type + (c-name "empathy_tp_tube_get_type") + (return-type "GType") +) + +(define-function empathy_tp_tube_new + (c-name "empathy_tp_tube_new") + (is-constructor-of "EmpathyTpTube") + (return-type "EmpathyTpTube*") + (parameters + '("TpChannel*" "channel") + '("guint" "tube_id") + ) +) + +(define-function empathy_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") + ) +) + +(define-method accept_stream_tube + (of-object "EmpathyTpTube") + (c-name "empathy_tp_tube_accept_stream_tube") + (return-type "none") + (parameters + '("TpSocketAddressType" "type") + ) +) + +(define-method get_socket + (of-object "EmpathyTpTube") + (c-name "empathy_tp_tube_get_socket") + (return-type "none") + (parameters + '("gchar**" "hostname") + '("guint*" "port") + ) +) + + + +;; From empathy-idle.h + +(define-function empathy_idle_get_type + (c-name "empathy_idle_get_type") + (return-type "GType") +) + +(define-function empathy_idle_new + (c-name "empathy_idle_new") + (is-constructor-of "EmpathyIdle") + (return-type "EmpathyIdle*") +) + +(define-method get_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_state") + (return-type "McPresence") +) + +(define-method set_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_state") + (return-type "none") + (parameters + '("McPresence" "state") + ) +) + +(define-method get_status + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_status") + (return-type "const-gchar*") +) + +(define-method set_status + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_status") + (return-type "none") + (parameters + '("const-gchar*" "status") + ) +) + +(define-method get_flash_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_get_flash_state") + (return-type "McPresence") +) + +(define-method set_flash_state + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_flash_state") + (return-type "none") + (parameters + '("McPresence" "state") + ) +) + +(define-method set_presence + (of-object "EmpathyIdle") + (c-name "empathy_idle_set_presence") + (return-type "none") + (parameters + '("McPresence" "state") + '("const-gchar*" "status") + ) +) + +(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-log-manager.h + +(define-function empathy_log_manager_get_type + (c-name "empathy_log_manager_get_type") + (return-type "GType") +) + +(define-function empathy_log_manager_new + (c-name "empathy_log_manager_new") + (is-constructor-of "EmpathyLogManager") + (return-type "EmpathyLogManager*") +) + +(define-method add_message + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_add_message") + (return-type "none") + (parameters + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("EmpathyMessage*" "message") + ) +) + +(define-method exists + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_exists") + (return-type "gboolean") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_dates + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_dates") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_messages_for_file + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_messages_for_file") + (return-type "GList*") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-method get_messages_for_date + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_messages_for_date") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + '("const-gchar*" "date") + ) +) + +(define-method get_last_messages + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_last_messages") + (return-type "GList*") + (parameters + '("McAccount*" "account") + '("const-gchar*" "chat_id") + '("gboolean" "chatroom") + ) +) + +(define-method get_messages_for_file + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_messages_for_file") + (return-type "GList*") + (parameters + '("const-gchar*" "filename") + ) +) + +(define-method get_chats + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_get_chats") + (return-type "GList*") + (parameters + '("McAccount*" "account") + ) +) + +(define-method search_new + (of-object "EmpathyLogManager") + (c-name "empathy_log_manager_search_new") + (return-type "GList*") + (parameters + '("const-gchar*" "text") + ) +) + +(define-function empathy_log_manager_search_free + (c-name "empathy_log_manager_search_free") + (return-type "none") + (parameters + '("GList*" "hits") + ) +) + +(define-function empathy_log_manager_get_date_readable + (c-name "empathy_log_manager_get_date_readable") + (return-type "gchar*") + (parameters + '("const-gchar*" "date") + ) +) + + + +;; From empathy-irc-network-manager.h + +(define-function empathy_irc_network_manager_get_type + (c-name "empathy_irc_network_manager_get_type") + (return-type "GType") +) + +(define-function empathy_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-network.h + +(define-function empathy_irc_network_get_type + (c-name "empathy_irc_network_get_type") + (return-type "GType") +) + +(define-function empathy_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-server.h + +(define-function empathy_irc_server_get_type + (c-name "empathy_irc_server_get_type") + (return-type "GType") +) + +(define-function empathy_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-tube-handler.h + +(define-function empathy_tube_handler_get_type + (c-name "empathy_tube_handler_get_type") + (return-type "GType") +) + +(define-function empathy_tube_handler_new + (c-name "empathy_tube_handler_new") + (is-constructor-of "EmpathyTubeHandler") + (return-type "EmpathyTubeHandler*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + +(define-function empathy_tube_handler_build_bus_name + (c-name "empathy_tube_handler_build_bus_name") + (return-type "gchar*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + +(define-function empathy_tube_handler_build_object_path + (c-name "empathy_tube_handler_build_object_path") + (return-type "gchar*") + (parameters + '("TpTubeType" "type") + '("const-gchar*" "service") + ) +) + + + +;; From empathy-dispatcher.h + +(define-function empathy_dispatcher_get_type + (c-name "empathy_dispatcher_get_type") + (return-type "GType") +) + +(define-function empathy_dispatcher_new + (c-name "empathy_dispatcher_new") + (is-constructor-of "EmpathyDispatcher") + (return-type "EmpathyDispatcher*") +) + +(define-method channel_process + (of-object "EmpathyDispatcher") + (c-name "empathy_dispatcher_channel_process") + (return-type "none") + (parameters + '("TpChannel*" "channel") + ) +) + +(define-function empathy_dispatcher_tube_get_type + (c-name "empathy_dispatcher_tube_get_type") + (return-type "GType") +) + +(define-method ref + (of-object "EmpathyDispatcherTube") + (c-name "empathy_dispatcher_tube_ref") + (return-type "EmpathyDispatcherTube*") +) + +(define-method unref + (of-object "EmpathyDispatcherTube") + (c-name "empathy_dispatcher_tube_unref") + (return-type "none") +) + +(define-method tube_process + (of-object "EmpathyDispatcher") + (c-name "empathy_dispatcher_tube_process") + (return-type "none") + (parameters + '("EmpathyDispatcherTube*" "tube") + ) +) + + |