soc.2009.penguin.visualstudio: d6710035: First big run of the C# wrapper. Mostly ...
wade at soc.pidgin.im
wade at soc.pidgin.im
Wed Jun 24 11:15:41 EDT 2009
-----------------------------------------------------------------
Revision: d67100357ff7bd33d18402600550bef7624fea1d
Ancestor: c23f9c9e295282179e95329afa3bbdd7d72d2a7b
Author: wade at soc.pidgin.im
Date: 2009-06-24T15:13:04
Branch: im.pidgin.soc.2009.penguin.visualstudio
URL: http://d.pidgin.im/viewmtn/revision/info/d67100357ff7bd33d18402600550bef7624fea1d
Added files:
libpurple/wrapper/Account.cs libpurple/wrapper/Accountopt.cs
libpurple/wrapper/Blist.cs libpurple/wrapper/Buddyicon.cs
libpurple/wrapper/Certificate.cs libpurple/wrapper/Cipher.cs
libpurple/wrapper/Circbuffer.cs libpurple/wrapper/Cmds.cs
libpurple/wrapper/Config.cs libpurple/wrapper/Connection.cs
libpurple/wrapper/Conversation.cs libpurple/wrapper/Core.cs
libpurple/wrapper/Debug.cs libpurple/wrapper/Desktopitem.cs
libpurple/wrapper/Dnsquery.cs libpurple/wrapper/Dnssrv.cs
libpurple/wrapper/Eventloop.cs libpurple/wrapper/Ft.cs
libpurple/wrapper/Idle.cs libpurple/wrapper/Imgstore.cs
libpurple/wrapper/Log.cs libpurple/wrapper/Media.cs
libpurple/wrapper/Mediamanager.cs libpurple/wrapper/Mime.cs
libpurple/wrapper/NatPmp.cs libpurple/wrapper/Network.cs
libpurple/wrapper/Notify.cs libpurple/wrapper/Ntlm.cs
libpurple/wrapper/Plugin.cs libpurple/wrapper/Pluginpref.cs
libpurple/wrapper/Pounce.cs libpurple/wrapper/Prefs.cs
libpurple/wrapper/Privacy.cs libpurple/wrapper/Proxy.cs
libpurple/wrapper/Prpl.cs libpurple/wrapper/PurpleAccount.cs
libpurple/wrapper/PurpleAccountUiOps.cs
libpurple/wrapper/PurpleAttentionType.cs
libpurple/wrapper/PurpleBlistNode.cs
libpurple/wrapper/PurpleBlistUiOps.cs
libpurple/wrapper/PurpleBuddy.cs
libpurple/wrapper/PurpleBuddyIconSpec.cs
libpurple/wrapper/PurpleBuddyList.cs
libpurple/wrapper/PurpleCertificate.cs
libpurple/wrapper/PurpleCertificatePool.cs
libpurple/wrapper/PurpleCertificateScheme.cs
libpurple/wrapper/PurpleCertificateVerificationRequest.cs
libpurple/wrapper/PurpleCertificateVerifier.cs
libpurple/wrapper/PurpleChat.cs
libpurple/wrapper/PurpleCipherOps.cs
libpurple/wrapper/PurpleClient.cs
libpurple/wrapper/PurpleConnection.cs
libpurple/wrapper/PurpleContact.cs
libpurple/wrapper/PurpleConvChat.cs
libpurple/wrapper/PurpleConvChatBuddy.cs
libpurple/wrapper/PurpleConvIm.cs
libpurple/wrapper/PurpleConvMessage.cs
libpurple/wrapper/PurpleConversation.cs
libpurple/wrapper/PurpleConversationUiOps.cs
libpurple/wrapper/PurpleEventLoopUiOps.cs
libpurple/wrapper/PurpleGroup.cs
libpurple/wrapper/PurpleKeyValuePair.cs
libpurple/wrapper/PurpleLog.cs
libpurple/wrapper/PurpleLogCommonLoggerData.cs
libpurple/wrapper/PurpleLogLogger.cs
libpurple/wrapper/PurpleLogSet.cs
libpurple/wrapper/PurpleMenuAction.cs
libpurple/wrapper/PurplePlugin.cs
libpurple/wrapper/PurplePluginAction.cs
libpurple/wrapper/PurplePluginInfo.cs
libpurple/wrapper/PurplePluginLoaderInfo.cs
libpurple/wrapper/PurplePluginProtocolInfo.cs
libpurple/wrapper/PurplePluginUiInfo.cs
libpurple/wrapper/PurplePounce.cs
libpurple/wrapper/PurpleRequestField.cs
libpurple/wrapper/PurpleRoomlist.cs
libpurple/wrapper/PurpleRoomlistField.cs
libpurple/wrapper/PurpleRoomlistRoom.cs
libpurple/wrapper/PurpleRoomlistUiOps.cs
libpurple/wrapper/PurpleSoundTheme.cs
libpurple/wrapper/PurpleSoundThemeClass.cs
libpurple/wrapper/PurpleSoundThemeLoader.cs
libpurple/wrapper/PurpleSoundThemeLoaderClass.cs
libpurple/wrapper/PurpleSrvResponse.cs
libpurple/wrapper/PurpleSslConnection.cs
libpurple/wrapper/PurpleStunNatDiscovery.cs
libpurple/wrapper/PurpleTheme.cs
libpurple/wrapper/PurpleThemeClass.cs
libpurple/wrapper/PurpleThemeLoader.cs
libpurple/wrapper/PurpleThemeLoaderClass.cs
libpurple/wrapper/PurpleThemeManager.cs
libpurple/wrapper/PurpleThemeManagerClass.cs
libpurple/wrapper/PurpleWhiteboard.cs
libpurple/wrapper/PurpleXfer.cs libpurple/wrapper/Request.cs
libpurple/wrapper/Roomlist.cs
libpurple/wrapper/Savedstatuses.cs
libpurple/wrapper/Server.cs libpurple/wrapper/Signals.cs
libpurple/wrapper/Smiley.cs libpurple/wrapper/Sound.cs
libpurple/wrapper/SoundTheme.cs
libpurple/wrapper/SoundThemeLoader.cs
libpurple/wrapper/Sslconn.cs libpurple/wrapper/Status.cs
libpurple/wrapper/Stringref.cs libpurple/wrapper/Stun.cs
libpurple/wrapper/Theme.cs libpurple/wrapper/ThemeLoader.cs
libpurple/wrapper/ThemeManager.cs libpurple/wrapper/Upnp.cs
libpurple/wrapper/Util.cs libpurple/wrapper/Value.cs
libpurple/wrapper/Version.cs libpurple/wrapper/Whiteboard.cs
libpurple/wrapper/proto_chat_entry.cs
libpurple/wrapper/xmlnode.cs
Added directories:
libpurple/wrapper
ChangeLog:
First big run of the C# wrapper. Mostly just the nearly-complete parsing, but some typing is done w/ native types. Yayy!
-------------- next part --------------
============================================================
--- libpurple/wrapper/Account.cs 70927698aa381839a83cc58fa092442e653e2e69
+++ libpurple/wrapper/Account.cs 70927698aa381839a83cc58fa092442e653e2e69
@@ -0,0 +1,1011 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Account
+ {
+ /*
+ * PurpleAccount * purple_account_new(char * username, char * protocol_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_new(string username, string protocol_id);
+
+ public static PurpleAccount New(string username, string protocol_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_destroy(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_destroy(IntPtr account);
+
+ public static void Destroy(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_connect(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_connect(IntPtr account);
+
+ public static void Connect(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_register_callback(PurpleAccount * account, PurpleAccountRegistrationCb cb, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_register_callback(IntPtr account, UNKNOWN cb, IntPtr user_data);
+
+ public static void SetRegisterCallback(PurpleAccount account, PurpleAccountRegistrationCb cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_register(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_register(IntPtr account);
+
+ public static void Register(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_unregister(PurpleAccount * account, PurpleAccountUnregistrationCb cb, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_unregister(IntPtr account, UNKNOWN cb, IntPtr user_data);
+
+ public static void Unregister(PurpleAccount account, PurpleAccountUnregistrationCb cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_disconnect(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_disconnect(IntPtr account);
+
+ public static void Disconnect(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_notify_added(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_notify_added(IntPtr account, string remote_user, string id, string alias, string message);
+
+ public static void NotifyAdded(PurpleAccount account, string remote_user, string id, string alias, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_add(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_add(IntPtr account, string remote_user, string id, string alias, string message);
+
+ public static void RequestAdd(PurpleAccount account, string remote_user, string id, string alias, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_account_request_authorization(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message, gboolean on_list, PurpleAccountRequestAuthorizationCb auth_cb, PurpleAccountRequestAuthorizationCb deny_cb, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_request_authorization(IntPtr account, string remote_user, string id, string alias, string message, bool on_list, UNKNOWN auth_cb, UNKNOWN deny_cb, IntPtr user_data);
+
+ public static IntPtr RequestAuthorization(PurpleAccount account, string remote_user, string id, string alias, string message, bool on_list, PurpleAccountRequestAuthorizationCb auth_cb, PurpleAccountRequestAuthorizationCb deny_cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_close_with_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_close_with_account(IntPtr account);
+
+ public static void RequestCloseWithAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_close(void * ui_handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_close(IntPtr ui_handle);
+
+ public static void RequestClose(IntPtr ui_handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_password(PurpleAccount * account, GCallback ok_cb, GCallback cancel_cb, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_password(IntPtr account, UNKNOWN ok_cb, UNKNOWN cancel_cb, IntPtr user_data);
+
+ public static void RequestPassword(PurpleAccount account, GCallback ok_cb, GCallback cancel_cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_change_password(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_change_password(IntPtr account);
+
+ public static void RequestChangePassword(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_request_change_user_info(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_request_change_user_info(IntPtr account);
+
+ public static void RequestChangeUserInfo(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_username(PurpleAccount * account, char * username)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_username(IntPtr account, string username);
+
+ public static void SetUsername(PurpleAccount account, string username)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_password(PurpleAccount * account, char * password)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_password(IntPtr account, string password);
+
+ public static void SetPassword(PurpleAccount account, string password)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_alias(PurpleAccount * account, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_alias(IntPtr account, string alias);
+
+ public static void SetAlias(PurpleAccount account, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_user_info(PurpleAccount * account, char * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_user_info(IntPtr account, string user_info);
+
+ public static void SetUserInfo(PurpleAccount account, string user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_buddy_icon_path(PurpleAccount * account, char * path)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_buddy_icon_path(IntPtr account, string path);
+
+ public static void SetBuddyIconPath(PurpleAccount account, string path)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_protocol_id(PurpleAccount * account, char * protocol_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_protocol_id(IntPtr account, string protocol_id);
+
+ public static void SetProtocolId(PurpleAccount account, string protocol_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_connection(PurpleAccount * account, PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_connection(IntPtr account, IntPtr gc);
+
+ public static void SetConnection(PurpleAccount account, PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_remember_password(PurpleAccount * account, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_remember_password(IntPtr account, bool value);
+
+ public static void SetRememberPassword(PurpleAccount account, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_check_mail(PurpleAccount * account, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_check_mail(IntPtr account, bool value);
+
+ public static void SetCheckMail(PurpleAccount account, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_enabled(PurpleAccount * account, char * ui, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_enabled(IntPtr account, string ui, bool value);
+
+ public static void SetEnabled(PurpleAccount account, string ui, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_proxy_info(PurpleAccount * account, PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_proxy_info(IntPtr account, IntPtr info);
+
+ public static void SetProxyInfo(PurpleAccount account, PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_status_types(PurpleAccount * account, GList * status_types)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_status_types(IntPtr account, IntPtr status_types);
+
+ public static void SetStatusTypes(PurpleAccount account, GList status_types)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_status(PurpleAccount * account, char * status_id, gboolean active, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_status(IntPtr account, string status_id, bool active, ...);
+
+ public static void SetStatus(PurpleAccount account, string status_id, bool active, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_status_list(PurpleAccount * account, char * status_id, gboolean active, GList * attrs)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_status_list(IntPtr account, string status_id, bool active, IntPtr attrs);
+
+ public static void SetStatusList(PurpleAccount account, string status_id, bool active, GList attrs)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_clear_settings(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_clear_settings(IntPtr account);
+
+ public static void ClearSettings(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_int(PurpleAccount * account, char * name, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_int(IntPtr account, string name, int value);
+
+ public static void SetInt(PurpleAccount account, string name, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_string(PurpleAccount * account, char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_string(IntPtr account, string name, string value);
+
+ public static void SetString(PurpleAccount account, string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_bool(PurpleAccount * account, char * name, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_bool(IntPtr account, string name, bool value);
+
+ public static void SetBool(PurpleAccount account, string name, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_ui_int(PurpleAccount * account, char * ui, char * name, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_ui_int(IntPtr account, string ui, string name, int value);
+
+ public static void SetUiInt(PurpleAccount account, string ui, string name, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_ui_string(PurpleAccount * account, char * ui, char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_ui_string(IntPtr account, string ui, string name, string value);
+
+ public static void SetUiString(PurpleAccount account, string ui, string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_set_ui_bool(PurpleAccount * account, char * ui, char * name, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_set_ui_bool(IntPtr account, string ui, string name, bool value);
+
+ public static void SetUiBool(PurpleAccount account, string ui, string name, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_is_connected(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_is_connected(IntPtr account);
+
+ public static bool IsConnected(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_is_connecting(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_is_connecting(IntPtr account);
+
+ public static bool IsConnecting(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_is_disconnected(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_is_disconnected(IntPtr account);
+
+ public static bool IsDisconnected(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_username(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_username(IntPtr account);
+
+ public static string GetUsername(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_password(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_password(IntPtr account);
+
+ public static string GetPassword(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_alias(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_alias(IntPtr account);
+
+ public static string GetAlias(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_user_info(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_user_info(IntPtr account);
+
+ public static string GetUserInfo(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_buddy_icon_path(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_buddy_icon_path(IntPtr account);
+
+ public static string GetBuddyIconPath(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_protocol_id(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_protocol_id(IntPtr account);
+
+ public static string GetProtocolId(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_protocol_name(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_protocol_name(IntPtr account);
+
+ public static string GetProtocolName(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnection * purple_account_get_connection(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_connection(IntPtr account);
+
+ public static PurpleConnection GetConnection(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_get_remember_password(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_get_remember_password(IntPtr account);
+
+ public static bool GetRememberPassword(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_get_check_mail(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_get_check_mail(IntPtr account);
+
+ public static bool GetCheckMail(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_get_enabled(PurpleAccount * account, char * ui)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_get_enabled(IntPtr account, string ui);
+
+ public static bool GetEnabled(PurpleAccount account, string ui)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyInfo * purple_account_get_proxy_info(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_proxy_info(IntPtr account);
+
+ public static PurpleProxyInfo GetProxyInfo(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatus * purple_account_get_active_status(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_active_status(IntPtr account);
+
+ public static PurpleStatus GetActiveStatus(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatus * purple_account_get_status(PurpleAccount * account, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_status(IntPtr account, string status_id);
+
+ public static PurpleStatus GetStatus(PurpleAccount account, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_account_get_status_type(PurpleAccount * account, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_status_type(IntPtr account, string id);
+
+ public static PurpleStatusType GetStatusType(PurpleAccount account, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_account_get_status_type_with_primitive(PurpleAccount * account, PurpleStatusPrimitive primitive)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_status_type_with_primitive(IntPtr account, UNKNOWN primitive);
+
+ public static PurpleStatusType GetStatusTypeWithPrimitive(PurpleAccount account, PurpleStatusPrimitive primitive)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_account_get_presence(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_presence(IntPtr account);
+
+ public static PurplePresence GetPresence(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_is_status_active(PurpleAccount * account, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_is_status_active(IntPtr account, string status_id);
+
+ public static bool IsStatusActive(PurpleAccount account, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_account_get_status_types(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_status_types(IntPtr account);
+
+ public static GList GetStatusTypes(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_account_get_int(PurpleAccount * account, char * name, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_account_get_int(IntPtr account, string name, int default_value);
+
+ public static int GetInt(PurpleAccount account, string name, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_string(PurpleAccount * account, char * name, char * default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_string(IntPtr account, string name, string default_value);
+
+ public static string GetString(PurpleAccount account, string name, string default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_get_bool(PurpleAccount * account, char * name, gboolean default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_get_bool(IntPtr account, string name, bool default_value);
+
+ public static bool GetBool(PurpleAccount account, string name, bool default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_account_get_ui_int(PurpleAccount * account, char * ui, char * name, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_account_get_ui_int(IntPtr account, string ui, string name, int default_value);
+
+ public static int GetUiInt(PurpleAccount account, string ui, string name, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_get_ui_string(PurpleAccount * account, char * ui, char * name, char * default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_get_ui_string(IntPtr account, string ui, string name, string default_value);
+
+ public static string GetUiString(PurpleAccount account, string ui, string name, string default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_get_ui_bool(PurpleAccount * account, char * ui, char * name, gboolean default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_get_ui_bool(IntPtr account, string ui, string name, bool default_value);
+
+ public static bool GetUiBool(PurpleAccount account, string ui, string name, bool default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleLog * purple_account_get_log(PurpleAccount * account, gboolean create)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_log(IntPtr account, bool create);
+
+ public static PurpleLog GetLog(PurpleAccount account, bool create)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_destroy_log(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_destroy_log(IntPtr account);
+
+ public static void DestroyLog(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_add_buddy(PurpleAccount * account, PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_add_buddy(IntPtr account, IntPtr buddy);
+
+ public static void AddBuddy(PurpleAccount account, PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_add_buddies(PurpleAccount * account, GList * buddies)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_add_buddies(IntPtr account, IntPtr buddies);
+
+ public static void AddBuddies(PurpleAccount account, GList buddies)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_remove_buddy(PurpleAccount * account, PurpleBuddy * buddy, PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_remove_buddy(IntPtr account, IntPtr buddy, IntPtr group);
+
+ public static void RemoveBuddy(PurpleAccount account, PurpleBuddy buddy, PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_remove_buddies(PurpleAccount * account, GList * buddies, GList * groups)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_remove_buddies(IntPtr account, IntPtr buddies, IntPtr groups);
+
+ public static void RemoveBuddies(PurpleAccount account, GList buddies, GList groups)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_remove_group(PurpleAccount * account, PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_remove_group(IntPtr account, IntPtr group);
+
+ public static void RemoveGroup(PurpleAccount account, PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_change_password(PurpleAccount * account, char * orig_pw, char * new_pw)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_change_password(IntPtr account, string orig_pw, string new_pw);
+
+ public static void ChangePassword(PurpleAccount account, string orig_pw, string new_pw)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_supports_offline_message(PurpleAccount * account, PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_supports_offline_message(IntPtr account, IntPtr buddy);
+
+ public static bool SupportsOfflineMessage(PurpleAccount account, PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnectionErrorInfo * purple_account_get_current_error(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_get_current_error(IntPtr account);
+
+ public static PurpleConnectionErrorInfo GetCurrentError(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_clear_current_error(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_clear_current_error(IntPtr account);
+
+ public static void ClearCurrentError(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_add(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_add(IntPtr account);
+
+ public static void AccountsAdd(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_remove(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_remove(IntPtr account);
+
+ public static void AccountsRemove(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_delete(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_delete(IntPtr account);
+
+ public static void AccountsDelete(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_reorder(PurpleAccount * account, gint new_index)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_reorder(IntPtr account, int new_index);
+
+ public static void AccountsReorder(PurpleAccount account, int new_index)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_accounts_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_accounts_get_all();
+
+ public static GList AccountsGetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_accounts_get_all_active()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_accounts_get_all_active();
+
+ public static GList AccountsGetAllActive()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_accounts_find(char * name, char * protocol)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_accounts_find(string name, string protocol);
+
+ public static PurpleAccount AccountsFind(string name, string protocol)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_restore_current_statuses()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_restore_current_statuses();
+
+ public static void AccountsRestoreCurrentStatuses()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_set_ui_ops(PurpleAccountUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_set_ui_ops(IntPtr ops);
+
+ public static void AccountsSetUiOps(PurpleAccountUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountUiOps * purple_accounts_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_accounts_get_ui_ops();
+
+ public static PurpleAccountUiOps AccountsGetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_accounts_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_accounts_get_handle();
+
+ public static IntPtr AccountsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_init();
+
+ public static void AccountsInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_accounts_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_accounts_uninit();
+
+ public static void AccountsUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Accountopt.cs e6d67721f2e0e0e7984f117f9e94f20f47b128b5
+++ libpurple/wrapper/Accountopt.cs e6d67721f2e0e0e7984f117f9e94f20f47b128b5
@@ -0,0 +1,351 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Accountopt
+ {
+ /*
+ * PurpleAccountOption * purple_account_option_new(PurplePrefType type, char * text, char * pref_name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_new(UNKNOWN type, string text, string pref_name);
+
+ public static PurpleAccountOption AccountOptionNew(PurplePrefType type, string text, string pref_name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountOption * purple_account_option_bool_new(char * text, char * pref_name, gboolean default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_bool_new(string text, string pref_name, bool default_value);
+
+ public static PurpleAccountOption AccountOptionBoolNew(string text, string pref_name, bool default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountOption * purple_account_option_int_new(char * text, char * pref_name, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_int_new(string text, string pref_name, int default_value);
+
+ public static PurpleAccountOption AccountOptionIntNew(string text, string pref_name, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountOption * purple_account_option_string_new(char * text, char * pref_name, char * default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_string_new(string text, string pref_name, string default_value);
+
+ public static PurpleAccountOption AccountOptionStringNew(string text, string pref_name, string default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountOption * purple_account_option_list_new(char * text, char * pref_name, GList * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_list_new(string text, string pref_name, IntPtr list);
+
+ public static PurpleAccountOption AccountOptionListNew(string text, string pref_name, GList list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_destroy(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_destroy(IntPtr option);
+
+ public static void AccountOptionDestroy(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_set_default_bool(PurpleAccountOption * option, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_set_default_bool(IntPtr option, bool value);
+
+ public static void AccountOptionSetDefaultBool(PurpleAccountOption option, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_set_default_int(PurpleAccountOption * option, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_set_default_int(IntPtr option, int value);
+
+ public static void AccountOptionSetDefaultInt(PurpleAccountOption option, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_set_default_string(PurpleAccountOption * option, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_set_default_string(IntPtr option, string value);
+
+ public static void AccountOptionSetDefaultString(PurpleAccountOption option, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_set_masked(PurpleAccountOption * option, gboolean masked)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_set_masked(IntPtr option, bool masked);
+
+ public static void AccountOptionSetMasked(PurpleAccountOption option, bool masked)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_set_list(PurpleAccountOption * option, GList * values)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_set_list(IntPtr option, IntPtr values);
+
+ public static void AccountOptionSetList(PurpleAccountOption option, GList values)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_option_add_list_item(PurpleAccountOption * option, char * key, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_option_add_list_item(IntPtr option, string key, string value);
+
+ public static void AccountOptionAddListItem(PurpleAccountOption option, string key, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePrefType purple_account_option_get_type(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_account_option_get_type(IntPtr option);
+
+ public static PurplePrefType AccountOptionGetType(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_option_get_text(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_option_get_text(IntPtr option);
+
+ public static string AccountOptionGetText(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_option_get_setting(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_option_get_setting(IntPtr option);
+
+ public static string AccountOptionGetSetting(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_option_get_default_bool(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_option_get_default_bool(IntPtr option);
+
+ public static bool AccountOptionGetDefaultBool(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_account_option_get_default_int(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_account_option_get_default_int(IntPtr option);
+
+ public static int AccountOptionGetDefaultInt(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_option_get_default_string(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_option_get_default_string(IntPtr option);
+
+ public static string AccountOptionGetDefaultString(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_option_get_default_list_value(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_option_get_default_list_value(IntPtr option);
+
+ public static string AccountOptionGetDefaultListValue(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_option_get_masked(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_option_get_masked(IntPtr option);
+
+ public static bool AccountOptionGetMasked(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_account_option_get_list(PurpleAccountOption * option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_option_get_list(IntPtr option);
+
+ public static GList AccountOptionGetList(PurpleAccountOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccountUserSplit * purple_account_user_split_new(char * text, char * default_value, char sep)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_account_user_split_new(string text, string default_value, char sep);
+
+ public static PurpleAccountUserSplit AccountUserSplitNew(string text, string default_value, char sep)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_user_split_destroy(PurpleAccountUserSplit * split)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_user_split_destroy(IntPtr split);
+
+ public static void AccountUserSplitDestroy(PurpleAccountUserSplit split)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_user_split_get_text(PurpleAccountUserSplit * split)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_user_split_get_text(IntPtr split);
+
+ public static string AccountUserSplitGetText(PurpleAccountUserSplit split)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_account_user_split_get_default_value(PurpleAccountUserSplit * split)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_account_user_split_get_default_value(IntPtr split);
+
+ public static string AccountUserSplitGetDefaultValue(PurpleAccountUserSplit split)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char purple_account_user_split_get_separator(PurpleAccountUserSplit * split)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern char purple_account_user_split_get_separator(IntPtr split);
+
+ public static char AccountUserSplitGetSeparator(PurpleAccountUserSplit split)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_account_user_split_get_reverse(PurpleAccountUserSplit * split)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_account_user_split_get_reverse(IntPtr split);
+
+ public static bool AccountUserSplitGetReverse(PurpleAccountUserSplit split)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_account_user_split_set_reverse(PurpleAccountUserSplit * split, gboolean reverse)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_account_user_split_set_reverse(IntPtr split, bool reverse);
+
+ public static void AccountUserSplitSetReverse(PurpleAccountUserSplit split, bool reverse)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Blist.cs 0113806aa65037779a4db8efa36f04ece107dc99
+++ libpurple/wrapper/Blist.cs 0113806aa65037779a4db8efa36f04ece107dc99
@@ -0,0 +1,1143 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Blist
+ {
+ /*
+ * PurpleBuddyList * purple_blist_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_new();
+
+ public static PurpleBuddyList New()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_set_blist(PurpleBuddyList * blist)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_set_blist(IntPtr blist);
+
+ public static void SetBlist(PurpleBuddyList blist)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddyList * purple_get_blist()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_blist();
+
+ public static PurpleBuddyList GetBlist()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_get_root()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_get_root();
+
+ public static PurpleBlistNode GetRoot()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GSList * purple_blist_get_buddies()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_get_buddies();
+
+ public static GSList GetBuddies()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_blist_get_ui_data()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_get_ui_data();
+
+ public static IntPtr GetUiData()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_set_ui_data(gpointer ui_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_set_ui_data(IntPtr ui_data);
+
+ public static void SetUiData(IntPtr ui_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_node_next(PurpleBlistNode * node, gboolean offline)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_next(IntPtr node, bool offline);
+
+ public static PurpleBlistNode NodeNext(PurpleBlistNode node, bool offline)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_node_get_parent(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_parent(IntPtr node);
+
+ public static PurpleBlistNode NodeGetParent(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_node_get_first_child(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_first_child(IntPtr node);
+
+ public static PurpleBlistNode NodeGetFirstChild(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_node_get_sibling_next(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_sibling_next(IntPtr node);
+
+ public static PurpleBlistNode NodeGetSiblingNext(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNode * purple_blist_node_get_sibling_prev(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_sibling_prev(IntPtr node);
+
+ public static PurpleBlistNode NodeGetSiblingPrev(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_blist_node_get_ui_data(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_ui_data(IntPtr node);
+
+ public static IntPtr NodeGetUiData(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_set_ui_data(PurpleBlistNode * node, gpointer ui_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_set_ui_data(IntPtr node, IntPtr ui_data);
+
+ public static void NodeSetUiData(PurpleBlistNode node, IntPtr ui_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_show()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_show();
+
+ public static void Show()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_destroy()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_destroy();
+
+ public static void Destroy()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_set_visible(gboolean show)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_set_visible(bool show);
+
+ public static void SetVisible(bool show)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_update_buddy_status(PurpleBuddy * buddy, PurpleStatus * old_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_update_buddy_status(IntPtr buddy, IntPtr old_status);
+
+ public static void UpdateBuddyStatus(PurpleBuddy buddy, PurpleStatus old_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_update_node_icon(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_update_node_icon(IntPtr node);
+
+ public static void UpdateNodeIcon(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_update_buddy_icon(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_update_buddy_icon(IntPtr buddy);
+
+ public static void UpdateBuddyIcon(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_rename_buddy(PurpleBuddy * buddy, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_rename_buddy(IntPtr buddy, string name);
+
+ public static void RenameBuddy(PurpleBuddy buddy, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_alias_contact(PurpleContact * contact, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_alias_contact(IntPtr contact, string alias);
+
+ public static void AliasContact(PurpleContact contact, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_alias_buddy(PurpleBuddy * buddy, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_alias_buddy(IntPtr buddy, string alias);
+
+ public static void AliasBuddy(PurpleBuddy buddy, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_server_alias_buddy(PurpleBuddy * buddy, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_server_alias_buddy(IntPtr buddy, string alias);
+
+ public static void ServerAliasBuddy(PurpleBuddy buddy, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_alias_chat(PurpleChat * chat, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_alias_chat(IntPtr chat, string alias);
+
+ public static void AliasChat(PurpleChat chat, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_rename_group(PurpleGroup * group, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_rename_group(IntPtr group, string name);
+
+ public static void RenameGroup(PurpleGroup group, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleChat * purple_chat_new(PurpleAccount * account, char * alias, GHashTable * components)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_chat_new(IntPtr account, string alias, IntPtr components);
+
+ public static PurpleChat ChatNew(PurpleAccount account, string alias, GHashTable components)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_chat_destroy(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_chat_destroy(IntPtr chat);
+
+ public static void ChatDestroy(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_add_chat(PurpleChat * chat, PurpleGroup * group, PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_add_chat(IntPtr chat, IntPtr group, IntPtr node);
+
+ public static void AddChat(PurpleChat chat, PurpleGroup group, PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddy * purple_buddy_new(PurpleAccount * account, char * name, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_new(IntPtr account, string name, string alias);
+
+ public static PurpleBuddy BuddyNew(PurpleAccount account, string name, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_destroy(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_destroy(IntPtr buddy);
+
+ public static void BuddyDestroy(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_set_icon(PurpleBuddy * buddy, PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_set_icon(IntPtr buddy, IntPtr icon);
+
+ public static void BuddySetIcon(PurpleBuddy buddy, PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_buddy_get_account(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_account(IntPtr buddy);
+
+ public static PurpleAccount BuddyGetAccount(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_name(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_name(IntPtr buddy);
+
+ public static string BuddyGetName(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddyIcon * purple_buddy_get_icon(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_icon(IntPtr buddy);
+
+ public static PurpleBuddyIcon BuddyGetIcon(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_buddy_get_protocol_data(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_protocol_data(IntPtr buddy);
+
+ public static IntPtr BuddyGetProtocolData(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_set_protocol_data(PurpleBuddy * buddy, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_set_protocol_data(IntPtr buddy, IntPtr data);
+
+ public static void BuddySetProtocolData(PurpleBuddy buddy, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleContact * purple_buddy_get_contact(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_contact(IntPtr buddy);
+
+ public static PurpleContact BuddyGetContact(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_buddy_get_presence(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_presence(IntPtr buddy);
+
+ public static PurplePresence BuddyGetPresence(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_add_buddy(PurpleBuddy * buddy, PurpleContact * contact, PurpleGroup * group, PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_add_buddy(IntPtr buddy, IntPtr contact, IntPtr group, IntPtr node);
+
+ public static void AddBuddy(PurpleBuddy buddy, PurpleContact contact, PurpleGroup group, PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleGroup * purple_group_new(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_group_new(string name);
+
+ public static PurpleGroup GroupNew(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_group_destroy(PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_group_destroy(IntPtr group);
+
+ public static void GroupDestroy(PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_add_group(PurpleGroup * group, PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_add_group(IntPtr group, IntPtr node);
+
+ public static void AddGroup(PurpleGroup group, PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleContact * purple_contact_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_contact_new();
+
+ public static PurpleContact ContactNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_contact_destroy(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_contact_destroy(IntPtr contact);
+
+ public static void ContactDestroy(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_add_contact(PurpleContact * contact, PurpleGroup * group, PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_add_contact(IntPtr contact, IntPtr group, IntPtr node);
+
+ public static void AddContact(PurpleContact contact, PurpleGroup group, PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_merge_contact(PurpleContact * source, PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_merge_contact(IntPtr source, IntPtr node);
+
+ public static void MergeContact(PurpleContact source, PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddy * purple_contact_get_priority_buddy(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_contact_get_priority_buddy(IntPtr contact);
+
+ public static PurpleBuddy ContactGetPriorityBuddy(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_contact_set_alias(PurpleContact * contact, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_contact_set_alias(IntPtr contact, string alias);
+
+ public static void ContactSetAlias(PurpleContact contact, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_contact_get_alias(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_contact_get_alias(IntPtr contact);
+
+ public static string ContactGetAlias(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_contact_on_account(PurpleContact * contact, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_contact_on_account(IntPtr contact, IntPtr account);
+
+ public static bool ContactOnAccount(PurpleContact contact, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_contact_invalidate_priority_buddy(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_contact_invalidate_priority_buddy(IntPtr contact);
+
+ public static void ContactInvalidatePriorityBuddy(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_remove_buddy(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_remove_buddy(IntPtr buddy);
+
+ public static void RemoveBuddy(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_remove_contact(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_remove_contact(IntPtr contact);
+
+ public static void RemoveContact(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_remove_chat(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_remove_chat(IntPtr chat);
+
+ public static void RemoveChat(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_remove_group(PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_remove_group(IntPtr group);
+
+ public static void RemoveGroup(PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_alias_only(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_alias_only(IntPtr buddy);
+
+ public static string BuddyGetAliasOnly(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_server_alias(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_server_alias(IntPtr buddy);
+
+ public static string BuddyGetServerAlias(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_contact_alias(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_contact_alias(IntPtr buddy);
+
+ public static string BuddyGetContactAlias(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_local_alias(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_local_alias(IntPtr buddy);
+
+ public static string BuddyGetLocalAlias(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_alias(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_alias(IntPtr buddy);
+
+ public static string BuddyGetAlias(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_get_local_buddy_alias(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_get_local_buddy_alias(IntPtr buddy);
+
+ public static string BuddyGetLocalBuddyAlias(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_chat_get_name(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_chat_get_name(IntPtr chat);
+
+ public static string ChatGetName(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddy * purple_find_buddy(PurpleAccount * account, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_buddy(IntPtr account, string name);
+
+ public static PurpleBuddy FindBuddy(PurpleAccount account, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddy * purple_find_buddy_in_group(PurpleAccount * account, char * name, PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_buddy_in_group(IntPtr account, string name, IntPtr group);
+
+ public static PurpleBuddy FindBuddyInGroup(PurpleAccount account, string name, PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GSList * purple_find_buddies(PurpleAccount * account, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_buddies(IntPtr account, string name);
+
+ public static GSList FindBuddies(PurpleAccount account, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleGroup * purple_find_group(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_group(string name);
+
+ public static PurpleGroup FindGroup(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleChat * purple_blist_find_chat(PurpleAccount * account, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_find_chat(IntPtr account, string name);
+
+ public static PurpleChat FindChat(PurpleAccount account, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleGroup * purple_chat_get_group(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_chat_get_group(IntPtr chat);
+
+ public static PurpleGroup ChatGetGroup(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_chat_get_account(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_chat_get_account(IntPtr chat);
+
+ public static PurpleAccount ChatGetAccount(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GHashTable * purple_chat_get_components(PurpleChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_chat_get_components(IntPtr chat);
+
+ public static GHashTable ChatGetComponents(PurpleChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleGroup * purple_buddy_get_group(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_get_group(IntPtr buddy);
+
+ public static PurpleGroup BuddyGetGroup(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GSList * purple_group_get_accounts(PurpleGroup * g)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_group_get_accounts(IntPtr g);
+
+ public static GSList GroupGetAccounts(PurpleGroup g)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_group_on_account(PurpleGroup * g, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_group_on_account(IntPtr g, IntPtr account);
+
+ public static bool GroupOnAccount(PurpleGroup g, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_group_get_name(PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_group_get_name(IntPtr group);
+
+ public static string GroupGetName(PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_add_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_add_account(IntPtr account);
+
+ public static void AddAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_remove_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_remove_account(IntPtr account);
+
+ public static void RemoveAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_blist_get_group_size(PurpleGroup * group, gboolean offline)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_blist_get_group_size(IntPtr group, bool offline);
+
+ public static int GetGroupSize(PurpleGroup group, bool offline)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_blist_get_group_online_count(PurpleGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_blist_get_group_online_count(IntPtr group);
+
+ public static int GetGroupOnlineCount(PurpleGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_load()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_load();
+
+ public static void Load()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_schedule_save()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_schedule_save();
+
+ public static void ScheduleSave()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_request_add_buddy(PurpleAccount * account, char * username, char * group, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_request_add_buddy(IntPtr account, string username, string group, string alias);
+
+ public static void RequestAddBuddy(PurpleAccount account, string username, string group, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_request_add_chat(PurpleAccount * account, PurpleGroup * group, char * alias, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_request_add_chat(IntPtr account, IntPtr group, string alias, string name);
+
+ public static void RequestAddChat(PurpleAccount account, PurpleGroup group, string alias, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_request_add_group()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_request_add_group();
+
+ public static void RequestAddGroup()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_set_bool(PurpleBlistNode * node, char * key, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_set_bool(IntPtr node, string key, bool value);
+
+ public static void NodeSetBool(PurpleBlistNode node, string key, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_blist_node_get_bool(PurpleBlistNode * node, char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_blist_node_get_bool(IntPtr node, string key);
+
+ public static bool NodeGetBool(PurpleBlistNode node, string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_set_int(PurpleBlistNode * node, char * key, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_set_int(IntPtr node, string key, int value);
+
+ public static void NodeSetInt(PurpleBlistNode node, string key, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_blist_node_get_int(PurpleBlistNode * node, char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_blist_node_get_int(IntPtr node, string key);
+
+ public static int NodeGetInt(PurpleBlistNode node, string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_set_string(PurpleBlistNode * node, char * key, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_set_string(IntPtr node, string key, string value);
+
+ public static void NodeSetString(PurpleBlistNode node, string key, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_blist_node_get_string(PurpleBlistNode * node, char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_blist_node_get_string(IntPtr node, string key);
+
+ public static string NodeGetString(PurpleBlistNode node, string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_remove_setting(PurpleBlistNode * node, char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_remove_setting(IntPtr node, string key);
+
+ public static void NodeRemoveSetting(PurpleBlistNode node, string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_node_set_flags(PurpleBlistNode * node, PurpleBlistNodeFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_node_set_flags(IntPtr node, UNKNOWN flags);
+
+ public static void NodeSetFlags(PurpleBlistNode node, PurpleBlistNodeFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNodeFlags purple_blist_node_get_flags(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_blist_node_get_flags(IntPtr node);
+
+ public static PurpleBlistNodeFlags NodeGetFlags(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistNodeType purple_blist_node_get_type(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_blist_node_get_type(IntPtr node);
+
+ public static PurpleBlistNodeType NodeGetType(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_blist_node_get_extended_menu(PurpleBlistNode * n)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_node_get_extended_menu(IntPtr n);
+
+ public static GList NodeGetExtendedMenu(PurpleBlistNode n)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_set_ui_ops(PurpleBlistUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleBlistUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBlistUiOps * purple_blist_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_get_ui_ops();
+
+ public static PurpleBlistUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_blist_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_blist_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_blist_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_blist_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Buddyicon.cs 5d7cba7346a131a30cfac1ae7dbb14793aa288db
+++ libpurple/wrapper/Buddyicon.cs 5d7cba7346a131a30cfac1ae7dbb14793aa288db
@@ -0,0 +1,296 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Buddyicon
+ {
+ /*
+ * PurpleBuddyIcon * purple_buddy_icon_new(PurpleAccount * account, char * username, void * icon_data, size_t icon_len, char * checksum)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_icon_new(IntPtr account, string username, IntPtr icon_data, UNKNOWN icon_len, string checksum);
+
+ public static PurpleBuddyIcon BuddyIconNew(PurpleAccount account, string username, IntPtr icon_data, size_t icon_len, string checksum)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddyIcon * purple_buddy_icon_ref(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_icon_ref(IntPtr icon);
+
+ public static PurpleBuddyIcon BuddyIconRef(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddyIcon * purple_buddy_icon_unref(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_icon_unref(IntPtr icon);
+
+ public static PurpleBuddyIcon BuddyIconUnref(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icon_update(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icon_update(IntPtr icon);
+
+ public static void BuddyIconUpdate(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icon_set_data(PurpleBuddyIcon * icon, guchar * data, size_t len, char * checksum)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icon_set_data(IntPtr icon, IntPtr data, UNKNOWN len, string checksum);
+
+ public static void BuddyIconSetData(PurpleBuddyIcon icon, guchar data, size_t len, string checksum)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_buddy_icon_get_account(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_icon_get_account(IntPtr icon);
+
+ public static PurpleAccount BuddyIconGetAccount(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_icon_get_username(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_icon_get_username(IntPtr icon);
+
+ public static string BuddyIconGetUsername(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_icon_get_checksum(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_icon_get_checksum(IntPtr icon);
+
+ public static string BuddyIconGetChecksum(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gconstpointer purple_buddy_icon_get_data(PurpleBuddyIcon * icon, size_t * len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_buddy_icon_get_data(IntPtr icon, IntPtr len);
+
+ public static gconstpointer BuddyIconGetData(PurpleBuddyIcon icon, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_icon_get_extension(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_icon_get_extension(IntPtr icon);
+
+ public static string BuddyIconGetExtension(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_icon_get_full_path(PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_icon_get_full_path(IntPtr icon);
+
+ public static string BuddyIconGetFullPath(PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icons_set_for_user(PurpleAccount * account, char * username, void * icon_data, size_t icon_len, char * checksum)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icons_set_for_user(IntPtr account, string username, IntPtr icon_data, UNKNOWN icon_len, string checksum);
+
+ public static void BuddyIconsSetForUser(PurpleAccount account, string username, IntPtr icon_data, size_t icon_len, string checksum)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_buddy_icons_get_account_icon_timestamp(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_buddy_icons_get_account_icon_timestamp(IntPtr account);
+
+ public static time_t BuddyIconsGetAccountIconTimestamp(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_buddy_icons_node_has_custom_icon(PurpleBlistNode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_buddy_icons_node_has_custom_icon(IntPtr node);
+
+ public static bool BuddyIconsNodeHasCustomIcon(PurpleBlistNode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_buddy_icons_has_custom_icon(PurpleContact * contact)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_buddy_icons_has_custom_icon(IntPtr contact);
+
+ public static bool BuddyIconsHasCustomIcon(PurpleContact contact)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icons_set_caching(gboolean caching)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icons_set_caching(bool caching);
+
+ public static void BuddyIconsSetCaching(bool caching)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_buddy_icons_is_caching()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_buddy_icons_is_caching();
+
+ public static bool BuddyIconsIsCaching()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icons_set_cache_dir(char * cache_dir)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icons_set_cache_dir(string cache_dir);
+
+ public static void BuddyIconsSetCacheDir(string cache_dir)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_buddy_icons_get_cache_dir()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_buddy_icons_get_cache_dir();
+
+ public static string BuddyIconsGetCacheDir()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_buddy_icons_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_buddy_icons_get_handle();
+
+ public static IntPtr BuddyIconsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icons_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icons_init();
+
+ public static void BuddyIconsInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icons_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icons_uninit();
+
+ public static void BuddyIconsUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_buddy_icon_get_scale_size(PurpleBuddyIconSpec * spec, int * width, int * height)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_buddy_icon_get_scale_size(IntPtr spec, IntPtr width, IntPtr height);
+
+ public static void BuddyIconGetScaleSize(PurpleBuddyIconSpec spec, int width, int height)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Certificate.cs c79e19d18abec5ebde4e742efd09f948b967ee7f
+++ libpurple/wrapper/Certificate.cs c79e19d18abec5ebde4e742efd09f948b967ee7f
@@ -0,0 +1,318 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Certificate
+ {
+ /*
+ * void purple_certificate_verify(PurpleCertificateVerifier * verifier, gchar * subject_name, GList * cert_chain, PurpleCertificateVerifiedCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_verify(IntPtr verifier, string subject_name, IntPtr cert_chain, UNKNOWN cb, IntPtr cb_data);
+
+ public static void Verify(PurpleCertificateVerifier verifier, string subject_name, GList cert_chain, PurpleCertificateVerifiedCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_verify_complete(PurpleCertificateVerificationRequest * vrq, PurpleCertificateVerificationStatus st)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_verify_complete(IntPtr vrq, UNKNOWN st);
+
+ public static void VerifyComplete(PurpleCertificateVerificationRequest vrq, PurpleCertificateVerificationStatus st)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_destroy(PurpleCertificate * crt)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_destroy(IntPtr crt);
+
+ public static void Destroy(PurpleCertificate crt)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_destroy_list( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_destroy_list(UNKNOWN );
+
+ public static void DestroyList( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_signed_by(PurpleCertificate * crt, PurpleCertificate * issuer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_signed_by(IntPtr crt, IntPtr issuer);
+
+ public static bool SignedBy(PurpleCertificate crt, PurpleCertificate issuer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_check_signature_chain(GList * chain)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_check_signature_chain(IntPtr chain);
+
+ public static bool CheckSignatureChain(GList chain)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_export(gchar * filename, PurpleCertificate * crt)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_export(string filename, IntPtr crt);
+
+ public static bool Export(string filename, PurpleCertificate crt)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_check_subject_name(PurpleCertificate * crt, gchar * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_check_subject_name(IntPtr crt, string name);
+
+ public static bool CheckSubjectName(PurpleCertificate crt, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_get_times(PurpleCertificate * crt, time_t * activation, time_t * expiration)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_get_times(IntPtr crt, IntPtr activation, IntPtr expiration);
+
+ public static bool GetTimes(PurpleCertificate crt, time_t activation, time_t expiration)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_pool_usable(PurpleCertificatePool * pool)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_pool_usable(IntPtr pool);
+
+ public static bool PoolUsable(PurpleCertificatePool pool)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_pool_contains(PurpleCertificatePool * pool, gchar * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_pool_contains(IntPtr pool, string id);
+
+ public static bool PoolContains(PurpleCertificatePool pool, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_pool_store(PurpleCertificatePool * pool, gchar * id, PurpleCertificate * crt)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_pool_store(IntPtr pool, string id, IntPtr crt);
+
+ public static bool PoolStore(PurpleCertificatePool pool, string id, PurpleCertificate crt)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_pool_delete(PurpleCertificatePool * pool, gchar * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_pool_delete(IntPtr pool, string id);
+
+ public static bool PoolDelete(PurpleCertificatePool pool, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_pool_destroy_idlist(GList * idlist)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_pool_destroy_idlist(IntPtr idlist);
+
+ public static void PoolDestroyIdlist(GList idlist)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_certificate_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_certificate_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_register_scheme(PurpleCertificateScheme * scheme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_register_scheme(IntPtr scheme);
+
+ public static bool RegisterScheme(PurpleCertificateScheme scheme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_unregister_scheme(PurpleCertificateScheme * scheme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_unregister_scheme(IntPtr scheme);
+
+ public static bool UnregisterScheme(PurpleCertificateScheme scheme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_register_verifier(PurpleCertificateVerifier * vr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_register_verifier(IntPtr vr);
+
+ public static bool RegisterVerifier(PurpleCertificateVerifier vr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_unregister_verifier(PurpleCertificateVerifier * vr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_unregister_verifier(IntPtr vr);
+
+ public static bool UnregisterVerifier(PurpleCertificateVerifier vr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_register_pool(PurpleCertificatePool * pool)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_register_pool(IntPtr pool);
+
+ public static bool RegisterPool(PurpleCertificatePool pool)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_certificate_unregister_pool(PurpleCertificatePool * pool)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_certificate_unregister_pool(IntPtr pool);
+
+ public static bool UnregisterPool(PurpleCertificatePool pool)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_display_x509(PurpleCertificate * crt)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_display_x509(IntPtr crt);
+
+ public static void DisplayX509(PurpleCertificate crt)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_certificate_add_ca_search_path(char * path)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_certificate_add_ca_search_path(string path);
+
+ public static void AddCaSearchPath(string path)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Cipher.cs 6fa0d2192c52b3653a034b0808ae5ff859948b5d
+++ libpurple/wrapper/Cipher.cs 6fa0d2192c52b3653a034b0808ae5ff859948b5d
@@ -0,0 +1,417 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Cipher
+ {
+ /*
+ * gchar * purple_cipher_get_name(PurpleCipher * cipher)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_cipher_get_name(IntPtr cipher);
+
+ public static string GetName(PurpleCipher cipher)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_cipher_get_capabilities(PurpleCipher * cipher)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_cipher_get_capabilities(IntPtr cipher);
+
+ public static uint GetCapabilities(PurpleCipher cipher)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_cipher_digest_region(gchar * name, guchar * data, size_t data_len, size_t in_len, guchar digest, size_t * out_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_cipher_digest_region(string name, IntPtr data, UNKNOWN data_len, UNKNOWN in_len, UNKNOWN digest, IntPtr out_len);
+
+ public static bool DigestRegion(string name, guchar data, size_t data_len, size_t in_len, guchar digest, size_t out_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCipher * purple_ciphers_find_cipher(gchar * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ciphers_find_cipher(string name);
+
+ public static PurpleCipher CiphersFindCipher(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCipher * purple_ciphers_register_cipher(gchar * name, PurpleCipherOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ciphers_register_cipher(string name, IntPtr ops);
+
+ public static PurpleCipher CiphersRegisterCipher(string name, PurpleCipherOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_ciphers_unregister_cipher(PurpleCipher * cipher)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_ciphers_unregister_cipher(IntPtr cipher);
+
+ public static bool CiphersUnregisterCipher(PurpleCipher cipher)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_ciphers_get_ciphers()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ciphers_get_ciphers();
+
+ public static GList CiphersGetCiphers()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_ciphers_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ciphers_get_handle();
+
+ public static IntPtr CiphersGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ciphers_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ciphers_init();
+
+ public static void CiphersInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ciphers_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ciphers_uninit();
+
+ public static void CiphersUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_option(PurpleCipherContext * context, gchar * name, gpointer value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_option(IntPtr context, string name, IntPtr value);
+
+ public static void ContextSetOption(PurpleCipherContext context, string name, IntPtr value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_cipher_context_get_option(PurpleCipherContext * context, gchar * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cipher_context_get_option(IntPtr context, string name);
+
+ public static IntPtr ContextGetOption(PurpleCipherContext context, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCipherContext * purple_cipher_context_new(PurpleCipher * cipher, void * extra)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cipher_context_new(IntPtr cipher, IntPtr extra);
+
+ public static PurpleCipherContext ContextNew(PurpleCipher cipher, IntPtr extra)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCipherContext * purple_cipher_context_new_by_name(gchar * name, void * extra)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cipher_context_new_by_name(string name, IntPtr extra);
+
+ public static PurpleCipherContext ContextNewByName(string name, IntPtr extra)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_reset(PurpleCipherContext * context, gpointer extra)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_reset(IntPtr context, IntPtr extra);
+
+ public static void ContextReset(PurpleCipherContext context, IntPtr extra)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_destroy(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_destroy(IntPtr context);
+
+ public static void ContextDestroy(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_iv(PurpleCipherContext * context, guchar * iv, size_t len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_iv(IntPtr context, IntPtr iv, UNKNOWN len);
+
+ public static void ContextSetIv(PurpleCipherContext context, guchar iv, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_append(PurpleCipherContext * context, guchar * data, size_t len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_append(IntPtr context, IntPtr data, UNKNOWN len);
+
+ public static void ContextAppend(PurpleCipherContext context, guchar data, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_cipher_context_digest(PurpleCipherContext * context, size_t in_len, guchar digest, size_t * out_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_cipher_context_digest(IntPtr context, UNKNOWN in_len, UNKNOWN digest, IntPtr out_len);
+
+ public static bool ContextDigest(PurpleCipherContext context, size_t in_len, guchar digest, size_t out_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_cipher_context_digest_to_str(PurpleCipherContext * context, size_t in_len, gchar digest_s, size_t * out_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_cipher_context_digest_to_str(IntPtr context, UNKNOWN in_len, char digest_s, IntPtr out_len);
+
+ public static bool ContextDigestToStr(PurpleCipherContext context, size_t in_len, char digest_s, size_t out_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_cipher_context_encrypt(PurpleCipherContext * context, guchar data, size_t len, guchar output, size_t * outlen)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_cipher_context_encrypt(IntPtr context, UNKNOWN data, UNKNOWN len, UNKNOWN output, IntPtr outlen);
+
+ public static int ContextEncrypt(PurpleCipherContext context, guchar data, size_t len, guchar output, size_t outlen)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_cipher_context_decrypt(PurpleCipherContext * context, guchar data, size_t len, guchar output, size_t * outlen)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_cipher_context_decrypt(IntPtr context, UNKNOWN data, UNKNOWN len, UNKNOWN output, IntPtr outlen);
+
+ public static int ContextDecrypt(PurpleCipherContext context, guchar data, size_t len, guchar output, size_t outlen)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_salt(PurpleCipherContext * context, guchar * salt)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_salt(IntPtr context, IntPtr salt);
+
+ public static void ContextSetSalt(PurpleCipherContext context, guchar salt)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_cipher_context_get_salt_size(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cipher_context_get_salt_size(IntPtr context);
+
+ public static size_t ContextGetSaltSize(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_key(PurpleCipherContext * context, guchar * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_key(IntPtr context, IntPtr key);
+
+ public static void ContextSetKey(PurpleCipherContext context, guchar key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_cipher_context_get_key_size(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cipher_context_get_key_size(IntPtr context);
+
+ public static size_t ContextGetKeySize(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_batch_mode(PurpleCipherContext * context, PurpleCipherBatchMode mode)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_batch_mode(IntPtr context, UNKNOWN mode);
+
+ public static void ContextSetBatchMode(PurpleCipherContext context, PurpleCipherBatchMode mode)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCipherBatchMode purple_cipher_context_get_batch_mode(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cipher_context_get_batch_mode(IntPtr context);
+
+ public static PurpleCipherBatchMode ContextGetBatchMode(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_cipher_context_get_block_size(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cipher_context_get_block_size(IntPtr context);
+
+ public static size_t ContextGetBlockSize(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_key_with_len(PurpleCipherContext * context, guchar * key, size_t len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_key_with_len(IntPtr context, IntPtr key, UNKNOWN len);
+
+ public static void ContextSetKeyWithLen(PurpleCipherContext context, guchar key, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cipher_context_set_data(PurpleCipherContext * context, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cipher_context_set_data(IntPtr context, IntPtr data);
+
+ public static void ContextSetData(PurpleCipherContext context, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_cipher_context_get_data(PurpleCipherContext * context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cipher_context_get_data(IntPtr context);
+
+ public static IntPtr ContextGetData(PurpleCipherContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_cipher_http_digest_calculate_session_key(gchar * algorithm, gchar * username, gchar * realm, gchar * password, gchar * nonce, gchar * client_nonce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_cipher_http_digest_calculate_session_key(string algorithm, string username, string realm, string password, string nonce, string client_nonce);
+
+ public static string HttpDigestCalculateSessionKey(string algorithm, string username, string realm, string password, string nonce, string client_nonce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_cipher_http_digest_calculate_response(gchar * algorithm, gchar * method, gchar * digest_uri, gchar * qop, gchar * entity, gchar * nonce, gchar * nonce_count, gchar * client_nonce, gchar * session_key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_cipher_http_digest_calculate_response(string algorithm, string method, string digest_uri, string qop, string entity, string nonce, string nonce_count, string client_nonce, string session_key);
+
+ public static string HttpDigestCalculateResponse(string algorithm, string method, string digest_uri, string qop, string entity, string nonce, string nonce_count, string client_nonce, string session_key)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Circbuffer.cs cb58daa3d392c53494e31292553062df9553ef3d
+++ libpurple/wrapper/Circbuffer.cs cb58daa3d392c53494e31292553062df9553ef3d
@@ -0,0 +1,98 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Circbuffer
+ {
+ /*
+ * PurpleCircBuffer * purple_circ_buffer_new(gsize growsize)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_circ_buffer_new(UNKNOWN growsize);
+
+ public static PurpleCircBuffer CircBufferNew(gsize growsize)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_circ_buffer_destroy(PurpleCircBuffer * buf)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_circ_buffer_destroy(IntPtr buf);
+
+ public static void CircBufferDestroy(PurpleCircBuffer buf)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_circ_buffer_append(PurpleCircBuffer * buf, gconstpointer src, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_circ_buffer_append(IntPtr buf, UNKNOWN src, UNKNOWN len);
+
+ public static void CircBufferAppend(PurpleCircBuffer buf, gconstpointer src, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gsize purple_circ_buffer_get_max_read(PurpleCircBuffer * buf)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_circ_buffer_get_max_read(IntPtr buf);
+
+ public static gsize CircBufferGetMaxRead(PurpleCircBuffer buf)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_circ_buffer_mark_read(PurpleCircBuffer * buf, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_circ_buffer_mark_read(IntPtr buf, UNKNOWN len);
+
+ public static bool CircBufferMarkRead(PurpleCircBuffer buf, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Cmds.cs e38cff8d1660c307bf010bbc3df6923c2d145542
+++ libpurple/wrapper/Cmds.cs e38cff8d1660c307bf010bbc3df6923c2d145542
@@ -0,0 +1,131 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Cmds
+ {
+ /*
+ * PurpleCmdId purple_cmd_register(gchar * cmd, gchar * args, PurpleCmdPriority p, PurpleCmdFlag f, gchar * prpl_id, PurpleCmdFunc func, gchar * helpstr, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cmd_register(string cmd, string args, UNKNOWN p, UNKNOWN f, string prpl_id, UNKNOWN func, string helpstr, IntPtr data);
+
+ public static PurpleCmdId CmdRegister(string cmd, string args, PurpleCmdPriority p, PurpleCmdFlag f, string prpl_id, PurpleCmdFunc func, string helpstr, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cmd_unregister(PurpleCmdId id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cmd_unregister(UNKNOWN id);
+
+ public static void CmdUnregister(PurpleCmdId id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCmdStatus purple_cmd_do_command(PurpleConversation * conv, gchar * cmdline, gchar * markup, gchar ** errormsg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_cmd_do_command(IntPtr conv, string cmdline, string markup, IntPtr errormsg);
+
+ public static PurpleCmdStatus CmdDoCommand(PurpleConversation conv, string cmdline, string markup, gchar errormsg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_cmd_list(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cmd_list(IntPtr conv);
+
+ public static GList CmdList(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_cmd_help(PurpleConversation * conv, gchar * cmd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cmd_help(IntPtr conv, string cmd);
+
+ public static GList CmdHelp(PurpleConversation conv, string cmd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_cmds_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_cmds_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cmds_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cmds_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_cmds_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_cmds_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Config.cs 9940c35e2f6e2804575f1b65280f5406c842251d
+++ libpurple/wrapper/Config.cs 9940c35e2f6e2804575f1b65280f5406c842251d
@@ -0,0 +1,54 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Config
+ {
+ /*
+ * void static_proto_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void static_proto_init();
+
+ public static void StaticProtoInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Connection.cs 240fd18be4019a6e932adc021e8fdf26c6c69a13
+++ libpurple/wrapper/Connection.cs 240fd18be4019a6e932adc021e8fdf26c6c69a13
@@ -0,0 +1,329 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Connection
+ {
+ /*
+ * void purple_connection_new(PurpleAccount * account, gboolean regist, char * password)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_new(IntPtr account, bool regist, string password);
+
+ public static void New(PurpleAccount account, bool regist, string password)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_new_unregister(PurpleAccount * account, char * password, PurpleAccountUnregistrationCb cb, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_new_unregister(IntPtr account, string password, UNKNOWN cb, IntPtr user_data);
+
+ public static void NewUnregister(PurpleAccount account, string password, PurpleAccountUnregistrationCb cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_destroy(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_destroy(IntPtr gc);
+
+ public static void Destroy(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_set_state(PurpleConnection * gc, PurpleConnectionState state)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_set_state(IntPtr gc, UNKNOWN state);
+
+ public static void SetState(PurpleConnection gc, PurpleConnectionState state)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_set_account(PurpleConnection * gc, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_set_account(IntPtr gc, IntPtr account);
+
+ public static void SetAccount(PurpleConnection gc, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_set_display_name(PurpleConnection * gc, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_set_display_name(IntPtr gc, string name);
+
+ public static void SetDisplayName(PurpleConnection gc, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_set_protocol_data(PurpleConnection * connection, void * proto_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_set_protocol_data(IntPtr connection, IntPtr proto_data);
+
+ public static void SetProtocolData(PurpleConnection connection, IntPtr proto_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnectionState purple_connection_get_state(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_connection_get_state(IntPtr gc);
+
+ public static PurpleConnectionState GetState(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_connection_get_account(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connection_get_account(IntPtr gc);
+
+ public static PurpleAccount GetAccount(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_connection_get_password(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_connection_get_password(IntPtr gc);
+
+ public static string GetPassword(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_connection_get_display_name(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_connection_get_display_name(IntPtr gc);
+
+ public static string GetDisplayName(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_connection_get_protocol_data(PurpleConnection * connection)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connection_get_protocol_data(IntPtr connection);
+
+ public static IntPtr GetProtocolData(PurpleConnection connection)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_update_progress(PurpleConnection * gc, char * text, size_t step, size_t count)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_update_progress(IntPtr gc, string text, UNKNOWN step, UNKNOWN count);
+
+ public static void UpdateProgress(PurpleConnection gc, string text, size_t step, size_t count)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_notice(PurpleConnection * gc, char * text)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_notice(IntPtr gc, string text);
+
+ public static void Notice(PurpleConnection gc, string text)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_error(PurpleConnection * gc, char * reason)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_error(IntPtr gc, string reason);
+
+ public static void Error(PurpleConnection gc, string reason)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_error_reason(PurpleConnection * gc, PurpleConnectionError reason, char * description)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_error_reason(IntPtr gc, UNKNOWN reason, string description);
+
+ public static void ErrorReason(PurpleConnection gc, PurpleConnectionError reason, string description)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connection_ssl_error(PurpleConnection * gc, PurpleSslErrorType ssl_error)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connection_ssl_error(IntPtr gc, UNKNOWN ssl_error);
+
+ public static void SslError(PurpleConnection gc, PurpleSslErrorType ssl_error)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_connection_error_is_fatal(PurpleConnectionError reason)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_connection_error_is_fatal(UNKNOWN reason);
+
+ public static bool ErrorIsFatal(PurpleConnectionError reason)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connections_disconnect_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connections_disconnect_all();
+
+ public static void ConnectionsDisconnectAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_connections_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connections_get_all();
+
+ public static GList ConnectionsGetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_connections_get_connecting()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connections_get_connecting();
+
+ public static GList ConnectionsGetConnecting()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connections_set_ui_ops(PurpleConnectionUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connections_set_ui_ops(IntPtr ops);
+
+ public static void ConnectionsSetUiOps(PurpleConnectionUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnectionUiOps * purple_connections_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connections_get_ui_ops();
+
+ public static PurpleConnectionUiOps ConnectionsGetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connections_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connections_init();
+
+ public static void ConnectionsInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_connections_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_connections_uninit();
+
+ public static void ConnectionsUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_connections_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_connections_get_handle();
+
+ public static IntPtr ConnectionsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Conversation.cs 2678e5a205e179d0fa6e79f9ba43e94ddc14045c
+++ libpurple/wrapper/Conversation.cs 2678e5a205e179d0fa6e79f9ba43e94ddc14045c
@@ -0,0 +1,1132 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Conversation
+ {
+ /*
+ * PurpleConversation * purple_conversation_new(PurpleConversationType type, PurpleAccount * account, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_new(UNKNOWN type, IntPtr account, string name);
+
+ public static PurpleConversation New(PurpleConversationType type, PurpleAccount account, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_destroy(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_destroy(IntPtr conv);
+
+ public static void Destroy(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_present(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_present(IntPtr conv);
+
+ public static void Present(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversationType purple_conversation_get_type(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conversation_get_type(IntPtr conv);
+
+ public static PurpleConversationType GetType(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_ui_ops(PurpleConversation * conv, PurpleConversationUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_ui_ops(IntPtr conv, IntPtr ops);
+
+ public static void SetUiOps(PurpleConversation conv, PurpleConversationUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversations_set_ui_ops(PurpleConversationUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversations_set_ui_ops(IntPtr ops);
+
+ public static void ConversationsSetUiOps(PurpleConversationUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversationUiOps * purple_conversation_get_ui_ops(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_ui_ops(IntPtr conv);
+
+ public static PurpleConversationUiOps GetUiOps(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_account(PurpleConversation * conv, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_account(IntPtr conv, IntPtr account);
+
+ public static void SetAccount(PurpleConversation conv, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_conversation_get_account(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_account(IntPtr conv);
+
+ public static PurpleAccount GetAccount(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnection * purple_conversation_get_gc(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_gc(IntPtr conv);
+
+ public static PurpleConnection GetGc(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_title(PurpleConversation * conv, char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_title(IntPtr conv, string title);
+
+ public static void SetTitle(PurpleConversation conv, string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conversation_get_title(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conversation_get_title(IntPtr conv);
+
+ public static string GetTitle(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_autoset_title(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_autoset_title(IntPtr conv);
+
+ public static void AutosetTitle(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_name(PurpleConversation * conv, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_name(IntPtr conv, string name);
+
+ public static void SetName(PurpleConversation conv, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conversation_get_name(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conversation_get_name(IntPtr conv);
+
+ public static string GetName(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_logging(PurpleConversation * conv, gboolean log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_logging(IntPtr conv, bool log);
+
+ public static void SetLogging(PurpleConversation conv, bool log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conversation_is_logging(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conversation_is_logging(IntPtr conv);
+
+ public static bool IsLogging(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_close_logs(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_close_logs(IntPtr conv);
+
+ public static void CloseLogs(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConvIm * purple_conversation_get_im_data(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_im_data(IntPtr conv);
+
+ public static PurpleConvIm GetImData(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConvChat * purple_conversation_get_chat_data(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_chat_data(IntPtr conv);
+
+ public static PurpleConvChat GetChatData(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_data(PurpleConversation * conv, char * key, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_data(IntPtr conv, string key, IntPtr data);
+
+ public static void SetData(PurpleConversation conv, string key, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_conversation_get_data(PurpleConversation * conv, char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_data(IntPtr conv, string key);
+
+ public static IntPtr GetData(PurpleConversation conv, string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_get_conversations()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_conversations();
+
+ public static GList GetConversations()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_get_ims()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_ims();
+
+ public static GList GetIms()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_get_chats()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_chats();
+
+ public static GList GetChats()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * purple_find_conversation_with_account(PurpleConversationType type, char * name, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_conversation_with_account(UNKNOWN type, string name, IntPtr account);
+
+ public static PurpleConversation FindConversationWithAccount(PurpleConversationType type, string name, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_write(PurpleConversation * conv, char * who, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_write(IntPtr conv, string who, string message, UNKNOWN flags, UNKNOWN mtime);
+
+ public static void Write(PurpleConversation conv, string who, string message, PurpleMessageFlags flags, time_t mtime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_set_features(PurpleConversation * conv, PurpleConnectionFlags features)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_set_features(IntPtr conv, UNKNOWN features);
+
+ public static void SetFeatures(PurpleConversation conv, PurpleConnectionFlags features)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConnectionFlags purple_conversation_get_features(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conversation_get_features(IntPtr conv);
+
+ public static PurpleConnectionFlags GetFeatures(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conversation_has_focus(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conversation_has_focus(IntPtr conv);
+
+ public static bool HasFocus(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_update(PurpleConversation * conv, PurpleConvUpdateType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_update(IntPtr conv, UNKNOWN type);
+
+ public static void Update(PurpleConversation conv, PurpleConvUpdateType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_foreach( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_foreach(UNKNOWN );
+
+ public static void Foreach( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_conversation_get_message_history(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversation_get_message_history(IntPtr conv);
+
+ public static GList GetMessageHistory(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversation_clear_message_history(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversation_clear_message_history(IntPtr conv);
+
+ public static void ClearMessageHistory(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conversation_message_get_sender(PurpleConvMessage * msg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conversation_message_get_sender(IntPtr msg);
+
+ public static string MessageGetSender(PurpleConvMessage msg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conversation_message_get_message(PurpleConvMessage * msg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conversation_message_get_message(IntPtr msg);
+
+ public static string MessageGetMessage(PurpleConvMessage msg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMessageFlags purple_conversation_message_get_flags(PurpleConvMessage * msg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conversation_message_get_flags(IntPtr msg);
+
+ public static PurpleMessageFlags MessageGetFlags(PurpleConvMessage msg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_conversation_message_get_timestamp(PurpleConvMessage * msg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conversation_message_get_timestamp(IntPtr msg);
+
+ public static time_t MessageGetTimestamp(PurpleConvMessage msg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * purple_conv_im_get_conversation(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_im_get_conversation(IntPtr im);
+
+ public static PurpleConversation ConvImGetConversation(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_set_icon(PurpleConvIm * im, PurpleBuddyIcon * icon)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_set_icon(IntPtr im, IntPtr icon);
+
+ public static void ConvImSetIcon(PurpleConvIm im, PurpleBuddyIcon icon)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddyIcon * purple_conv_im_get_icon(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_im_get_icon(IntPtr im);
+
+ public static PurpleBuddyIcon ConvImGetIcon(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_set_typing_state(PurpleConvIm * im, PurpleTypingState state)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_set_typing_state(IntPtr im, UNKNOWN state);
+
+ public static void ConvImSetTypingState(PurpleConvIm im, PurpleTypingState state)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleTypingState purple_conv_im_get_typing_state(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conv_im_get_typing_state(IntPtr im);
+
+ public static PurpleTypingState ConvImGetTypingState(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_start_typing_timeout(PurpleConvIm * im, int timeout)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_start_typing_timeout(IntPtr im, int timeout);
+
+ public static void ConvImStartTypingTimeout(PurpleConvIm im, int timeout)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_stop_typing_timeout(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_stop_typing_timeout(IntPtr im);
+
+ public static void ConvImStopTypingTimeout(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_conv_im_get_typing_timeout(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_conv_im_get_typing_timeout(IntPtr im);
+
+ public static uint ConvImGetTypingTimeout(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_set_type_again(PurpleConvIm * im, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_set_type_again(IntPtr im, UNKNOWN int);
+
+ public static void ConvImSetTypeAgain(PurpleConvIm im, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_conv_im_get_type_again(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conv_im_get_type_again(IntPtr im);
+
+ public static time_t ConvImGetTypeAgain(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_start_send_typed_timeout(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_start_send_typed_timeout(IntPtr im);
+
+ public static void ConvImStartSendTypedTimeout(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_stop_send_typed_timeout(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_stop_send_typed_timeout(IntPtr im);
+
+ public static void ConvImStopSendTypedTimeout(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_conv_im_get_send_typed_timeout(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_conv_im_get_send_typed_timeout(IntPtr im);
+
+ public static uint ConvImGetSendTypedTimeout(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_update_typing(PurpleConvIm * im)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_update_typing(IntPtr im);
+
+ public static void ConvImUpdateTyping(PurpleConvIm im)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_write(PurpleConvIm * im, char * who, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_write(IntPtr im, string who, string message, UNKNOWN flags, UNKNOWN mtime);
+
+ public static void ConvImWrite(PurpleConvIm im, string who, string message, PurpleMessageFlags flags, time_t mtime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conv_present_error(char * who, PurpleAccount * account, char * what)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conv_present_error(string who, IntPtr account, string what);
+
+ public static bool ConvPresentError(string who, PurpleAccount account, string what)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_send(PurpleConvIm * im, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_send(IntPtr im, string message);
+
+ public static void ConvImSend(PurpleConvIm im, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_send_confirm(PurpleConversation * conv, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_send_confirm(IntPtr conv, string message);
+
+ public static void ConvSendConfirm(PurpleConversation conv, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_im_send_with_flags(PurpleConvIm * im, char * message, PurpleMessageFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_im_send_with_flags(IntPtr im, string message, UNKNOWN flags);
+
+ public static void ConvImSendWithFlags(PurpleConvIm im, string message, PurpleMessageFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conv_custom_smiley_add(PurpleConversation * conv, char * smile, char * cksum_type, char * chksum, gboolean remote)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conv_custom_smiley_add(IntPtr conv, string smile, string cksum_type, string chksum, bool remote);
+
+ public static bool ConvCustomSmileyAdd(PurpleConversation conv, string smile, string cksum_type, string chksum, bool remote)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_custom_smiley_write(PurpleConversation * conv, char * smile, guchar * data, gsize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_custom_smiley_write(IntPtr conv, string smile, IntPtr data, UNKNOWN size);
+
+ public static void ConvCustomSmileyWrite(PurpleConversation conv, string smile, guchar data, gsize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_custom_smiley_close(PurpleConversation * conv, char * smile)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_custom_smiley_close(IntPtr conv, string smile);
+
+ public static void ConvCustomSmileyClose(PurpleConversation conv, string smile)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * purple_conv_chat_get_conversation(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_get_conversation(IntPtr chat);
+
+ public static PurpleConversation ConvChatGetConversation(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_conv_chat_set_users(PurpleConvChat * chat, GList * users)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_set_users(IntPtr chat, IntPtr users);
+
+ public static GList ConvChatSetUsers(PurpleConvChat chat, GList users)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_conv_chat_get_users(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_get_users(IntPtr chat);
+
+ public static GList ConvChatGetUsers(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_ignore(PurpleConvChat * chat, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_ignore(IntPtr chat, string name);
+
+ public static void ConvChatIgnore(PurpleConvChat chat, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_unignore(PurpleConvChat * chat, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_unignore(IntPtr chat, string name);
+
+ public static void ConvChatUnignore(PurpleConvChat chat, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_conv_chat_set_ignored(PurpleConvChat * chat, GList * ignored)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_set_ignored(IntPtr chat, IntPtr ignored);
+
+ public static GList ConvChatSetIgnored(PurpleConvChat chat, GList ignored)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_conv_chat_get_ignored(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_get_ignored(IntPtr chat);
+
+ public static GList ConvChatGetIgnored(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conv_chat_get_ignored_user(PurpleConvChat * chat, char * user)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conv_chat_get_ignored_user(IntPtr chat, string user);
+
+ public static string ConvChatGetIgnoredUser(PurpleConvChat chat, string user)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conv_chat_is_user_ignored(PurpleConvChat * chat, char * user)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conv_chat_is_user_ignored(IntPtr chat, string user);
+
+ public static bool ConvChatIsUserIgnored(PurpleConvChat chat, string user)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_set_topic(PurpleConvChat * chat, char * who, char * topic)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_set_topic(IntPtr chat, string who, string topic);
+
+ public static void ConvChatSetTopic(PurpleConvChat chat, string who, string topic)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conv_chat_get_topic(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conv_chat_get_topic(IntPtr chat);
+
+ public static string ConvChatGetTopic(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_set_id(PurpleConvChat * chat, int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_set_id(IntPtr chat, int id);
+
+ public static void ConvChatSetId(PurpleConvChat chat, int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_conv_chat_get_id(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_conv_chat_get_id(IntPtr chat);
+
+ public static int ConvChatGetId(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_write(PurpleConvChat * chat, char * who, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_write(IntPtr chat, string who, string message, UNKNOWN flags, UNKNOWN mtime);
+
+ public static void ConvChatWrite(PurpleConvChat chat, string who, string message, PurpleMessageFlags flags, time_t mtime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_send(PurpleConvChat * chat, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_send(IntPtr chat, string message);
+
+ public static void ConvChatSend(PurpleConvChat chat, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_send_with_flags(PurpleConvChat * chat, char * message, PurpleMessageFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_send_with_flags(IntPtr chat, string message, UNKNOWN flags);
+
+ public static void ConvChatSendWithFlags(PurpleConvChat chat, string message, PurpleMessageFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_add_user(PurpleConvChat * chat, char * user, char * extra_msg, PurpleConvChatBuddyFlags flags, gboolean new_arrival)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_add_user(IntPtr chat, string user, string extra_msg, UNKNOWN flags, bool new_arrival);
+
+ public static void ConvChatAddUser(PurpleConvChat chat, string user, string extra_msg, PurpleConvChatBuddyFlags flags, bool new_arrival)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_add_users(PurpleConvChat * chat, GList * users, GList * extra_msgs, GList * flags, gboolean new_arrivals)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_add_users(IntPtr chat, IntPtr users, IntPtr extra_msgs, IntPtr flags, bool new_arrivals);
+
+ public static void ConvChatAddUsers(PurpleConvChat chat, GList users, GList extra_msgs, GList flags, bool new_arrivals)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_rename_user(PurpleConvChat * chat, char * old_user, char * new_user)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_rename_user(IntPtr chat, string old_user, string new_user);
+
+ public static void ConvChatRenameUser(PurpleConvChat chat, string old_user, string new_user)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_remove_user(PurpleConvChat * chat, char * user, char * reason)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_remove_user(IntPtr chat, string user, string reason);
+
+ public static void ConvChatRemoveUser(PurpleConvChat chat, string user, string reason)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_remove_users(PurpleConvChat * chat, GList * users, char * reason)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_remove_users(IntPtr chat, IntPtr users, string reason);
+
+ public static void ConvChatRemoveUsers(PurpleConvChat chat, GList users, string reason)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conv_chat_find_user(PurpleConvChat * chat, char * user)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conv_chat_find_user(IntPtr chat, string user);
+
+ public static bool ConvChatFindUser(PurpleConvChat chat, string user)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_user_set_flags(PurpleConvChat * chat, char * user, PurpleConvChatBuddyFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_user_set_flags(IntPtr chat, string user, UNKNOWN flags);
+
+ public static void ConvChatUserSetFlags(PurpleConvChat chat, string user, PurpleConvChatBuddyFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConvChatBuddyFlags purple_conv_chat_user_get_flags(PurpleConvChat * chat, char * user)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_conv_chat_user_get_flags(IntPtr chat, string user);
+
+ public static PurpleConvChatBuddyFlags ConvChatUserGetFlags(PurpleConvChat chat, string user)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_clear_users(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_clear_users(IntPtr chat);
+
+ public static void ConvChatClearUsers(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_set_nick(PurpleConvChat * chat, char * nick)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_set_nick(IntPtr chat, string nick);
+
+ public static void ConvChatSetNick(PurpleConvChat chat, string nick)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conv_chat_get_nick(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conv_chat_get_nick(IntPtr chat);
+
+ public static string ConvChatGetNick(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * purple_find_chat(PurpleConnection * gc, int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_chat(IntPtr gc, int id);
+
+ public static PurpleConversation FindChat(PurpleConnection gc, int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_left(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_left(IntPtr chat);
+
+ public static void ConvChatLeft(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_invite_user(PurpleConvChat * chat, char * user, char * message, gboolean confirm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_invite_user(IntPtr chat, string user, string message, bool confirm);
+
+ public static void ConvChatInviteUser(PurpleConvChat chat, string user, string message, bool confirm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conv_chat_has_left(PurpleConvChat * chat)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conv_chat_has_left(IntPtr chat);
+
+ public static bool ConvChatHasLeft(PurpleConvChat chat)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConvChatBuddy * purple_conv_chat_cb_new(char * name, char * alias, PurpleConvChatBuddyFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_cb_new(string name, string alias, UNKNOWN flags);
+
+ public static PurpleConvChatBuddy ConvChatCbNew(string name, string alias, PurpleConvChatBuddyFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConvChatBuddy * purple_conv_chat_cb_find(PurpleConvChat * chat, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conv_chat_cb_find(IntPtr chat, string name);
+
+ public static PurpleConvChatBuddy ConvChatCbFind(PurpleConvChat chat, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_conv_chat_cb_get_name(PurpleConvChatBuddy * cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_conv_chat_cb_get_name(IntPtr cb);
+
+ public static string ConvChatCbGetName(PurpleConvChatBuddy cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conv_chat_cb_destroy(PurpleConvChatBuddy * cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conv_chat_cb_destroy(IntPtr cb);
+
+ public static void ConvChatCbDestroy(PurpleConvChatBuddy cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_conversation_do_command(PurpleConversation * conv, gchar * cmdline, gchar * markup, gchar ** error)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_conversation_do_command(IntPtr conv, string cmdline, string markup, IntPtr error);
+
+ public static bool DoCommand(PurpleConversation conv, string cmdline, string markup, gchar error)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_conversations_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_conversations_get_handle();
+
+ public static IntPtr ConversationsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversations_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversations_init();
+
+ public static void ConversationsInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_conversations_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_conversations_uninit();
+
+ public static void ConversationsUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Core.cs 3a60cd1694524f875b46757389ffebe82089cb66
+++ libpurple/wrapper/Core.cs 3a60cd1694524f875b46757389ffebe82089cb66
@@ -0,0 +1,153 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Core
+ {
+ /*
+ * gboolean purple_core_init(char * ui)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_core_init(string ui);
+
+ public static bool Init(string ui)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_core_quit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_core_quit();
+
+ public static void Quit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_core_quit_cb(gpointer unused)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_core_quit_cb(IntPtr unused);
+
+ public static bool QuitCb(IntPtr unused)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_core_get_version()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_core_get_version();
+
+ public static string GetVersion()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_core_get_ui()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_core_get_ui();
+
+ public static string GetUi()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCore * purple_get_core()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_core();
+
+ public static PurpleCore GetCore()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_core_set_ui_ops(PurpleCoreUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_core_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleCoreUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleCoreUiOps * purple_core_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_core_get_ui_ops();
+
+ public static PurpleCoreUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_core_migrate()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_core_migrate();
+
+ public static bool Migrate()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_core_ensure_single_instance()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_core_ensure_single_instance();
+
+ public static bool EnsureSingleInstance()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Debug.cs cc587e78038680088455af17195310b70cc568e4
+++ libpurple/wrapper/Debug.cs cc587e78038680088455af17195310b70cc568e4
@@ -0,0 +1,164 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Debug
+ {
+ /*
+ * void purple_debug(PurpleDebugLevel level, char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug(UNKNOWN level, string category, string format, ...);
+
+ public static void Debug(PurpleDebugLevel level, string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_misc(char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_misc(string category, string format, ...);
+
+ public static void Misc(string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_info(char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_info(string category, string format, ...);
+
+ public static void Info(string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_warning(char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_warning(string category, string format, ...);
+
+ public static void Warning(string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_error(char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_error(string category, string format, ...);
+
+ public static void Error(string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_fatal(char * category, char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_fatal(string category, string format, ...);
+
+ public static void Fatal(string category, string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_set_enabled(gboolean enabled)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_set_enabled(bool enabled);
+
+ public static void SetEnabled(bool enabled)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_debug_is_enabled()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_debug_is_enabled();
+
+ public static bool IsEnabled()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_set_ui_ops(PurpleDebugUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleDebugUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleDebugUiOps * purple_debug_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_debug_get_ui_ops();
+
+ public static PurpleDebugUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_debug_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_debug_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Desktopitem.cs 89df04813015ea3ea4d0fdb85c40dc9c5ac219e2
+++ libpurple/wrapper/Desktopitem.cs 89df04813015ea3ea4d0fdb85c40dc9c5ac219e2
@@ -0,0 +1,109 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Desktopitem
+ {
+ /*
+ * GType purple_desktop_item_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_desktop_item_get_type();
+
+ public static GType DesktopItemGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleDesktopItem * purple_desktop_item_new_from_file(char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_desktop_item_new_from_file(string filename);
+
+ public static PurpleDesktopItem DesktopItemNewFromFile(string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleDesktopItemType purple_desktop_item_get_entry_type(PurpleDesktopItem * item)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_desktop_item_get_entry_type(IntPtr item);
+
+ public static PurpleDesktopItemType DesktopItemGetEntryType(PurpleDesktopItem item)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_desktop_item_get_string(PurpleDesktopItem * item, char * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_desktop_item_get_string(IntPtr item, string attr);
+
+ public static string DesktopItemGetString(PurpleDesktopItem item, string attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleDesktopItem * purple_desktop_item_copy(PurpleDesktopItem * item)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_desktop_item_copy(IntPtr item);
+
+ public static PurpleDesktopItem DesktopItemCopy(PurpleDesktopItem item)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_desktop_item_unref(PurpleDesktopItem * item)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_desktop_item_unref(IntPtr item);
+
+ public static void DesktopItemUnref(PurpleDesktopItem item)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Dnsquery.cs dbea6537cbef1fdc63b20299c18d165ec86985a9
+++ libpurple/wrapper/Dnsquery.cs dbea6537cbef1fdc63b20299c18d165ec86985a9
@@ -0,0 +1,131 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Dnsquery
+ {
+ /*
+ * PurpleDnsQueryData * purple_dnsquery_a(char * hostname, int port, PurpleDnsQueryConnectFunction callback, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_dnsquery_a(string hostname, int port, UNKNOWN callback, IntPtr data);
+
+ public static PurpleDnsQueryData A(string hostname, int port, PurpleDnsQueryConnectFunction callback, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_dnsquery_destroy(PurpleDnsQueryData * query_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_dnsquery_destroy(IntPtr query_data);
+
+ public static void Destroy(PurpleDnsQueryData query_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_dnsquery_set_ui_ops(PurpleDnsQueryUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_dnsquery_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleDnsQueryUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleDnsQueryUiOps * purple_dnsquery_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_dnsquery_get_ui_ops();
+
+ public static PurpleDnsQueryUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_dnsquery_get_host(PurpleDnsQueryData * query_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_dnsquery_get_host(IntPtr query_data);
+
+ public static string GetHost(PurpleDnsQueryData query_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * short purple_dnsquery_get_port(PurpleDnsQueryData * query_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern short purple_dnsquery_get_port(IntPtr query_data);
+
+ public static short GetPort(PurpleDnsQueryData query_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_dnsquery_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_dnsquery_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_dnsquery_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_dnsquery_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Dnssrv.cs bcfa494b2a88ae8e1b4d62fa093cf19d9b8f9498
+++ libpurple/wrapper/Dnssrv.cs bcfa494b2a88ae8e1b4d62fa093cf19d9b8f9498
@@ -0,0 +1,109 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Dnssrv
+ {
+ /*
+ * PurpleSrvQueryData * purple_srv_resolve(char * protocol, char * transport, char * domain, PurpleSrvCallback cb, gpointer extradata)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_srv_resolve(string protocol, string transport, string domain, UNKNOWN cb, IntPtr extradata);
+
+ public static PurpleSrvQueryData SrvResolve(string protocol, string transport, string domain, PurpleSrvCallback cb, IntPtr extradata)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_srv_cancel(PurpleSrvQueryData * query_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_srv_cancel(IntPtr query_data);
+
+ public static void SrvCancel(PurpleSrvQueryData query_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSrvQueryData * purple_txt_resolve(char * owner, char * domain, PurpleTxtCallback cb, gpointer extradata)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_txt_resolve(string owner, string domain, UNKNOWN cb, IntPtr extradata);
+
+ public static PurpleSrvQueryData TxtResolve(string owner, string domain, PurpleTxtCallback cb, IntPtr extradata)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_txt_cancel(PurpleSrvQueryData * query_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_txt_cancel(IntPtr query_data);
+
+ public static void TxtCancel(PurpleSrvQueryData query_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_txt_response_get_content(PurpleTxtResponse * resp)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_txt_response_get_content(IntPtr resp);
+
+ public static string TxtResponseGetContent(PurpleTxtResponse resp)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_txt_response_destroy(PurpleTxtResponse * resp)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_txt_response_destroy(IntPtr resp);
+
+ public static void TxtResponseDestroy(PurpleTxtResponse resp)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Eventloop.cs 58d05562d886b39513e58cb904fc1ebf9b5324ca
+++ libpurple/wrapper/Eventloop.cs 58d05562d886b39513e58cb904fc1ebf9b5324ca
@@ -0,0 +1,131 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Eventloop
+ {
+ /*
+ * guint purple_timeout_add(guint interval, GSourceFunc function, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_timeout_add(uint interval, UNKNOWN function, IntPtr data);
+
+ public static uint TimeoutAdd(uint interval, GSourceFunc function, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_timeout_add_seconds(guint interval, GSourceFunc function, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_timeout_add_seconds(uint interval, UNKNOWN function, IntPtr data);
+
+ public static uint TimeoutAddSeconds(uint interval, GSourceFunc function, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_timeout_remove(guint handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_timeout_remove(uint handle);
+
+ public static bool TimeoutRemove(uint handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_input_add(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_input_add(int fd, UNKNOWN cond, UNKNOWN func, IntPtr user_data);
+
+ public static uint InputAdd(int fd, PurpleInputCondition cond, PurpleInputFunction func, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_input_remove(guint handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_input_remove(uint handle);
+
+ public static bool InputRemove(uint handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_input_get_error(int fd, int * error)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_input_get_error(int fd, IntPtr error);
+
+ public static int InputGetError(int fd, int error)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_eventloop_set_ui_ops(PurpleEventLoopUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_eventloop_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleEventLoopUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleEventLoopUiOps * purple_eventloop_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_eventloop_get_ui_ops();
+
+ public static PurpleEventLoopUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Ft.cs 65769ab4f81adf72fa51dd74311010fdcf0c6ec1
+++ libpurple/wrapper/Ft.cs 65769ab4f81adf72fa51dd74311010fdcf0c6ec1
@@ -0,0 +1,648 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Ft
+ {
+ /*
+ * PurpleXfer * purple_xfer_new(PurpleAccount * account, PurpleXferType type, char * who)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfer_new(IntPtr account, UNKNOWN type, string who);
+
+ public static PurpleXfer XferNew(PurpleAccount account, PurpleXferType type, string who)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_xfers_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfers_get_all();
+
+ public static GList XfersGetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_ref(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_ref(IntPtr xfer);
+
+ public static void XferRef(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_unref(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_unref(IntPtr xfer);
+
+ public static void XferUnref(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_request(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_request(IntPtr xfer);
+
+ public static void XferRequest(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_request_accepted(PurpleXfer * xfer, char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_request_accepted(IntPtr xfer, string filename);
+
+ public static void XferRequestAccepted(PurpleXfer xfer, string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_request_denied(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_request_denied(IntPtr xfer);
+
+ public static void XferRequestDenied(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleXferType purple_xfer_get_type(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_type(IntPtr xfer);
+
+ public static PurpleXferType XferGetType(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_xfer_get_account(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfer_get_account(IntPtr xfer);
+
+ public static PurpleAccount XferGetAccount(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_xfer_get_remote_user(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_xfer_get_remote_user(IntPtr xfer);
+
+ public static string XferGetRemoteUser(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleXferStatusType purple_xfer_get_status(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_status(IntPtr xfer);
+
+ public static PurpleXferStatusType XferGetStatus(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_xfer_is_canceled(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_xfer_is_canceled(IntPtr xfer);
+
+ public static bool XferIsCanceled(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_xfer_is_completed(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_xfer_is_completed(IntPtr xfer);
+
+ public static bool XferIsCompleted(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_xfer_get_filename(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_xfer_get_filename(IntPtr xfer);
+
+ public static string XferGetFilename(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_xfer_get_local_filename(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_xfer_get_local_filename(IntPtr xfer);
+
+ public static string XferGetLocalFilename(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_xfer_get_bytes_sent(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_bytes_sent(IntPtr xfer);
+
+ public static size_t XferGetBytesSent(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_xfer_get_bytes_remaining(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_bytes_remaining(IntPtr xfer);
+
+ public static size_t XferGetBytesRemaining(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_xfer_get_size(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_size(IntPtr xfer);
+
+ public static size_t XferGetSize(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * double purple_xfer_get_progress(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern double purple_xfer_get_progress(IntPtr xfer);
+
+ public static double XferGetProgress(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_xfer_get_local_port(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_xfer_get_local_port(IntPtr xfer);
+
+ public static int XferGetLocalPort(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_xfer_get_remote_ip(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_xfer_get_remote_ip(IntPtr xfer);
+
+ public static string XferGetRemoteIp(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_xfer_get_remote_port(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_xfer_get_remote_port(IntPtr xfer);
+
+ public static int XferGetRemotePort(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_xfer_get_start_time(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_start_time(IntPtr xfer);
+
+ public static time_t XferGetStartTime(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_xfer_get_end_time(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_get_end_time(IntPtr xfer);
+
+ public static time_t XferGetEndTime(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_completed(PurpleXfer * xfer, gboolean completed)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_completed(IntPtr xfer, bool completed);
+
+ public static void XferSetCompleted(PurpleXfer xfer, bool completed)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_message(PurpleXfer * xfer, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_message(IntPtr xfer, string message);
+
+ public static void XferSetMessage(PurpleXfer xfer, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_filename(PurpleXfer * xfer, char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_filename(IntPtr xfer, string filename);
+
+ public static void XferSetFilename(PurpleXfer xfer, string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_local_filename(PurpleXfer * xfer, char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_local_filename(IntPtr xfer, string filename);
+
+ public static void XferSetLocalFilename(PurpleXfer xfer, string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_size(PurpleXfer * xfer, size_t size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_size(IntPtr xfer, UNKNOWN size);
+
+ public static void XferSetSize(PurpleXfer xfer, size_t size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_bytes_sent(PurpleXfer * xfer, size_t bytes_sent)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_bytes_sent(IntPtr xfer, UNKNOWN bytes_sent);
+
+ public static void XferSetBytesSent(PurpleXfer xfer, size_t bytes_sent)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleXferUiOps * purple_xfer_get_ui_ops(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfer_get_ui_ops(IntPtr xfer);
+
+ public static PurpleXferUiOps XferGetUiOps(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_read_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_read_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetReadFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_write_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_write_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetWriteFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_ack_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_ack_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetAckFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_request_denied_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_request_denied_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetRequestDeniedFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_init_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_init_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetInitFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_start_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_start_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetStartFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_end_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_end_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetEndFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_cancel_send_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_cancel_send_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetCancelSendFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_set_cancel_recv_fnc(PurpleXfer * xfer, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_set_cancel_recv_fnc(IntPtr xfer, UNKNOWN );
+
+ public static void XferSetCancelRecvFnc(PurpleXfer xfer, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gssize purple_xfer_read(PurpleXfer * xfer, guchar ** buffer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_read(IntPtr xfer, IntPtr buffer);
+
+ public static gssize XferRead(PurpleXfer xfer, guchar buffer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gssize purple_xfer_write(PurpleXfer * xfer, guchar * buffer, gsize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_xfer_write(IntPtr xfer, IntPtr buffer, UNKNOWN size);
+
+ public static gssize XferWrite(PurpleXfer xfer, guchar buffer, gsize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_start(PurpleXfer * xfer, int fd, char * ip, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_start(IntPtr xfer, int fd, string ip, UNKNOWN int);
+
+ public static void XferStart(PurpleXfer xfer, int fd, string ip, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_end(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_end(IntPtr xfer);
+
+ public static void XferEnd(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_add(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_add(IntPtr xfer);
+
+ public static void XferAdd(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_cancel_local(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_cancel_local(IntPtr xfer);
+
+ public static void XferCancelLocal(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_cancel_remote(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_cancel_remote(IntPtr xfer);
+
+ public static void XferCancelRemote(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_error(PurpleXferType type, PurpleAccount * account, char * who, char * msg)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_error(UNKNOWN type, IntPtr account, string who, string msg);
+
+ public static void XferError(PurpleXferType type, PurpleAccount account, string who, string msg)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_update_progress(PurpleXfer * xfer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_update_progress(IntPtr xfer);
+
+ public static void XferUpdateProgress(PurpleXfer xfer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfer_conversation_write(PurpleXfer * xfer, char * message, gboolean is_error)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfer_conversation_write(IntPtr xfer, string message, bool is_error);
+
+ public static void XferConversationWrite(PurpleXfer xfer, string message, bool is_error)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_xfers_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfers_get_handle();
+
+ public static IntPtr XfersGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfers_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfers_init();
+
+ public static void XfersInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfers_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfers_uninit();
+
+ public static void XfersUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_xfers_set_ui_ops(PurpleXferUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_xfers_set_ui_ops(IntPtr ops);
+
+ public static void XfersSetUiOps(PurpleXferUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleXferUiOps * purple_xfers_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_xfers_get_ui_ops();
+
+ public static PurpleXferUiOps XfersGetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Idle.cs db72710e10f3af61497e269b6628131f669a7129
+++ libpurple/wrapper/Idle.cs db72710e10f3af61497e269b6628131f669a7129
@@ -0,0 +1,109 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Idle
+ {
+ /*
+ * void purple_idle_touch()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_idle_touch();
+
+ public static void Touch()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_idle_set(time_t time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_idle_set(UNKNOWN time);
+
+ public static void Set(time_t time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_idle_set_ui_ops(PurpleIdleUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_idle_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleIdleUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleIdleUiOps * purple_idle_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_idle_get_ui_ops();
+
+ public static PurpleIdleUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_idle_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_idle_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_idle_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_idle_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Imgstore.cs d95f6da0cba34a57ab0133016aeb4dc97e5c01f9
+++ libpurple/wrapper/Imgstore.cs d95f6da0cba34a57ab0133016aeb4dc97e5c01f9
@@ -0,0 +1,164 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Imgstore
+ {
+ /*
+ * int purple_imgstore_add_with_id(gpointer data, size_t size, char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_imgstore_add_with_id(IntPtr data, UNKNOWN size, string filename);
+
+ public static int AddWithId(IntPtr data, size_t size, string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStoredImage * purple_imgstore_find_by_id(int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_imgstore_find_by_id(int id);
+
+ public static PurpleStoredImage FindById(int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gconstpointer purple_imgstore_get_data(PurpleStoredImage * img)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_imgstore_get_data(IntPtr img);
+
+ public static gconstpointer GetData(PurpleStoredImage img)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_imgstore_get_size(PurpleStoredImage * img)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_imgstore_get_size(IntPtr img);
+
+ public static size_t GetSize(PurpleStoredImage img)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_imgstore_get_filename(PurpleStoredImage * img)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_imgstore_get_filename(IntPtr img);
+
+ public static string GetFilename(PurpleStoredImage img)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_imgstore_get_extension(PurpleStoredImage * img)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_imgstore_get_extension(IntPtr img);
+
+ public static string GetExtension(PurpleStoredImage img)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_imgstore_ref_by_id(int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_imgstore_ref_by_id(int id);
+
+ public static void RefById(int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_imgstore_unref_by_id(int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_imgstore_unref_by_id(int id);
+
+ public static void UnrefById(int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_imgstore_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_imgstore_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_imgstore_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_imgstore_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_imgstore_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_imgstore_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Log.cs 590ff3a5d74bb783d6af29df2d07758b8d44aec5
+++ libpurple/wrapper/Log.cs 590ff3a5d74bb783d6af29df2d07758b8d44aec5
@@ -0,0 +1,395 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Log
+ {
+ /*
+ * PurpleLog * purple_log_new(PurpleLogType type, char * name, PurpleAccount * account, PurpleConversation * conv, time_t time, struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_new(UNKNOWN type, string name, IntPtr account, IntPtr conv, UNKNOWN time, UNKNOWN tm);
+
+ public static PurpleLog New(PurpleLogType type, string name, PurpleAccount account, PurpleConversation conv, time_t time, struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_free(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_free(IntPtr log);
+
+ public static void Free(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_write(PurpleLog * log, PurpleMessageFlags type, char * from, time_t time, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_write(IntPtr log, UNKNOWN type, string from, UNKNOWN time, string message);
+
+ public static void Write(PurpleLog log, PurpleMessageFlags type, string from, time_t time, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_log_read(PurpleLog * log, PurpleLogReadFlags * flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_log_read(IntPtr log, IntPtr flags);
+
+ public static string Read(PurpleLog log, PurpleLogReadFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_log_get_logs(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_get_logs(UNKNOWN type, string name, IntPtr account);
+
+ public static GList GetLogs(PurpleLogType type, string name, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GHashTable * purple_log_get_log_sets()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_get_log_sets();
+
+ public static GHashTable GetLogSets()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_log_get_system_logs(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_get_system_logs(IntPtr account);
+
+ public static GList GetSystemLogs(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_log_get_size(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_get_size(IntPtr log);
+
+ public static int GetSize(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_log_get_total_size(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_get_total_size(UNKNOWN type, string name, IntPtr account);
+
+ public static int GetTotalSize(PurpleLogType type, string name, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_log_get_activity_score(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_get_activity_score(UNKNOWN type, string name, IntPtr account);
+
+ public static int GetActivityScore(PurpleLogType type, string name, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_log_is_deletable(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_log_is_deletable(IntPtr log);
+
+ public static bool IsDeletable(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_log_delete(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_log_delete(IntPtr log);
+
+ public static bool Delete(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_log_get_log_dir(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_log_get_log_dir(UNKNOWN type, string name, IntPtr account);
+
+ public static string GetLogDir(PurpleLogType type, string name, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_log_compare(gconstpointer y, gconstpointer z)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_compare(UNKNOWN y, UNKNOWN z);
+
+ public static int Compare(gconstpointer y, gconstpointer z)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_log_set_compare(gconstpointer y, gconstpointer z)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_set_compare(UNKNOWN y, UNKNOWN z);
+
+ public static int SetCompare(gconstpointer y, gconstpointer z)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_set_free(PurpleLogSet * set)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_set_free(IntPtr set);
+
+ public static void SetFree(PurpleLogSet set)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_common_writer(PurpleLog * log, char * ext)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_common_writer(IntPtr log, string ext);
+
+ public static void CommonWriter(PurpleLog log, string ext)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_log_common_lister(PurpleLogType type, char * name, PurpleAccount * account, char * ext, PurpleLogLogger * logger)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_common_lister(UNKNOWN type, string name, IntPtr account, string ext, IntPtr logger);
+
+ public static GList CommonLister(PurpleLogType type, string name, PurpleAccount account, string ext, PurpleLogLogger logger)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_log_common_total_sizer(PurpleLogType type, char * name, PurpleAccount * account, char * ext)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_common_total_sizer(UNKNOWN type, string name, IntPtr account, string ext);
+
+ public static int CommonTotalSizer(PurpleLogType type, string name, PurpleAccount account, string ext)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_log_common_sizer(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_log_common_sizer(IntPtr log);
+
+ public static int CommonSizer(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_log_common_deleter(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_log_common_deleter(IntPtr log);
+
+ public static bool CommonDeleter(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_log_common_is_deletable(PurpleLog * log)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_log_common_is_deletable(IntPtr log);
+
+ public static bool CommonIsDeletable(PurpleLog log)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleLogLogger * purple_log_logger_new(char * id, char * name, int functions, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_logger_new(string id, string name, int functions, ...);
+
+ public static PurpleLogLogger LoggerNew(string id, string name, int functions, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_logger_free(PurpleLogLogger * logger)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_logger_free(IntPtr logger);
+
+ public static void LoggerFree(PurpleLogLogger logger)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_logger_add(PurpleLogLogger * logger)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_logger_add(IntPtr logger);
+
+ public static void LoggerAdd(PurpleLogLogger logger)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_logger_remove(PurpleLogLogger * logger)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_logger_remove(IntPtr logger);
+
+ public static void LoggerRemove(PurpleLogLogger logger)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_logger_set(PurpleLogLogger * logger)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_logger_set(IntPtr logger);
+
+ public static void LoggerSet(PurpleLogLogger logger)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleLogLogger * purple_log_logger_get()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_logger_get();
+
+ public static PurpleLogLogger LoggerGet()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_log_logger_get_options()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_logger_get_options();
+
+ public static GList LoggerGetOptions()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_log_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_log_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_log_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_log_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Media.cs fc6e2ab2653d4f4c9fca694a4bff3ddd0c2fb421
+++ libpurple/wrapper/Media.cs fc6e2ab2653d4f4c9fca694a4bff3ddd0c2fb421
@@ -0,0 +1,703 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Media
+ {
+ /*
+ * GType purple_media_session_type_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_session_type_get_type();
+
+ public static GType SessionTypeGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_candidate_type_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_candidate_type_get_type();
+
+ public static GType CandidateTypeGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_network_protocol_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_network_protocol_get_type();
+
+ public static GType NetworkProtocolGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_get_type();
+
+ public static GType GetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_state_changed_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_state_changed_get_type();
+
+ public static GType StateChangedGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_info_type_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_info_type_get_type();
+
+ public static GType InfoTypeGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_candidate_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_candidate_get_type();
+
+ public static GType CandidateGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaCandidate * purple_media_candidate_new(gchar * foundation, guint component_id, PurpleMediaCandidateType type, PurpleMediaNetworkProtocol proto, gchar * ip, guint port)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_candidate_new(string foundation, uint component_id, UNKNOWN type, UNKNOWN proto, string ip, uint port);
+
+ public static PurpleMediaCandidate CandidateNew(string foundation, uint component_id, PurpleMediaCandidateType type, PurpleMediaNetworkProtocol proto, string ip, uint port)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_candidate_list_copy(GList * candidates)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_candidate_list_copy(IntPtr candidates);
+
+ public static GList CandidateListCopy(GList candidates)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_candidate_list_free(GList * candidates)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_candidate_list_free(IntPtr candidates);
+
+ public static void CandidateListFree(GList candidates)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_candidate_get_foundation(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_candidate_get_foundation(IntPtr candidate);
+
+ public static string CandidateGetFoundation(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_media_candidate_get_component_id(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_candidate_get_component_id(IntPtr candidate);
+
+ public static uint CandidateGetComponentId(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_candidate_get_ip(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_candidate_get_ip(IntPtr candidate);
+
+ public static string CandidateGetIp(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint16 purple_media_candidate_get_port(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ushort purple_media_candidate_get_port(IntPtr candidate);
+
+ public static ushort CandidateGetPort(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_candidate_get_base_ip(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_candidate_get_base_ip(IntPtr candidate);
+
+ public static string CandidateGetBaseIp(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint16 purple_media_candidate_get_base_port(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ushort purple_media_candidate_get_base_port(IntPtr candidate);
+
+ public static ushort CandidateGetBasePort(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaNetworkProtocol purple_media_candidate_get_protocol(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_candidate_get_protocol(IntPtr candidate);
+
+ public static PurpleMediaNetworkProtocol CandidateGetProtocol(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint32 purple_media_candidate_get_priority(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_candidate_get_priority(IntPtr candidate);
+
+ public static uint CandidateGetPriority(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaCandidateType purple_media_candidate_get_candidate_type(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_candidate_get_candidate_type(IntPtr candidate);
+
+ public static PurpleMediaCandidateType CandidateGetCandidateType(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_candidate_get_username(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_candidate_get_username(IntPtr candidate);
+
+ public static string CandidateGetUsername(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_candidate_get_password(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_candidate_get_password(IntPtr candidate);
+
+ public static string CandidateGetPassword(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_media_candidate_get_ttl(PurpleMediaCandidate * candidate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_candidate_get_ttl(IntPtr candidate);
+
+ public static uint CandidateGetTtl(PurpleMediaCandidate candidate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GType purple_media_codec_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_codec_get_type();
+
+ public static GType CodecGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaCodec * purple_media_codec_new(int id, char * encoding_name, PurpleMediaSessionType media_type, guint clock_rate)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_codec_new(int id, string encoding_name, UNKNOWN media_type, uint clock_rate);
+
+ public static PurpleMediaCodec CodecNew(int id, string encoding_name, PurpleMediaSessionType media_type, uint clock_rate)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_media_codec_get_id(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_codec_get_id(IntPtr codec);
+
+ public static uint CodecGetId(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_codec_get_encoding_name(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_codec_get_encoding_name(IntPtr codec);
+
+ public static string CodecGetEncodingName(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_media_codec_get_clock_rate(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_codec_get_clock_rate(IntPtr codec);
+
+ public static uint CodecGetClockRate(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_media_codec_get_channels(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_media_codec_get_channels(IntPtr codec);
+
+ public static uint CodecGetChannels(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_codec_get_optional_parameters(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_codec_get_optional_parameters(IntPtr codec);
+
+ public static GList CodecGetOptionalParameters(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_media_codec_to_string(PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_media_codec_to_string(IntPtr codec);
+
+ public static string CodecToString(PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_codec_add_optional_parameter(PurpleMediaCodec * codec, gchar * name, gchar * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_codec_add_optional_parameter(IntPtr codec, string name, string value);
+
+ public static void CodecAddOptionalParameter(PurpleMediaCodec codec, string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_codec_remove_optional_parameter(PurpleMediaCodec * codec, PurpleKeyValuePair * param)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_codec_remove_optional_parameter(IntPtr codec, IntPtr param);
+
+ public static void CodecRemoveOptionalParameter(PurpleMediaCodec codec, PurpleKeyValuePair param)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleKeyValuePair * purple_media_codec_get_optional_parameter(PurpleMediaCodec * codec, gchar * name, gchar * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_codec_get_optional_parameter(IntPtr codec, string name, string value);
+
+ public static PurpleKeyValuePair CodecGetOptionalParameter(PurpleMediaCodec codec, string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_codec_list_copy(GList * codecs)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_codec_list_copy(IntPtr codecs);
+
+ public static GList CodecListCopy(GList codecs)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_codec_list_free(GList * codecs)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_codec_list_free(IntPtr codecs);
+
+ public static void CodecListFree(GList codecs)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_get_session_ids(PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_session_ids(IntPtr media);
+
+ public static GList GetSessionIds(PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_media_get_account(PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_account(IntPtr media);
+
+ public static PurpleAccount GetAccount(PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_media_get_prpl_data(PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_prpl_data(IntPtr media);
+
+ public static IntPtr GetPrplData(PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_set_prpl_data(PurpleMedia * media, gpointer prpl_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_set_prpl_data(IntPtr media, IntPtr prpl_data);
+
+ public static void SetPrplData(PurpleMedia media, IntPtr prpl_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_error(PurpleMedia * media, gchar * error, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_error(IntPtr media, string error, ...);
+
+ public static void Error(PurpleMedia media, string error, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_end(PurpleMedia * media, gchar * session_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_end(IntPtr media, string session_id, string participant);
+
+ public static void End(PurpleMedia media, string session_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_stream_info(PurpleMedia * media, PurpleMediaInfoType type, gchar * session_id, gchar * participant, gboolean local)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_stream_info(IntPtr media, UNKNOWN type, string session_id, string participant, bool local);
+
+ public static void StreamInfo(PurpleMedia media, PurpleMediaInfoType type, string session_id, string participant, bool local)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_add_stream(PurpleMedia * media, gchar * sess_id, gchar * who, PurpleMediaSessionType type, gboolean initiator, gchar * transmitter, guint num_params, GParameter * params)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_add_stream(IntPtr media, string sess_id, string who, UNKNOWN type, bool initiator, string transmitter, uint num_params, IntPtr params);
+
+ public static bool AddStream(PurpleMedia media, string sess_id, string who, PurpleMediaSessionType type, bool initiator, string transmitter, uint num_params, GParameter params)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaSessionType purple_media_get_session_type(PurpleMedia * media, gchar * sess_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_get_session_type(IntPtr media, string sess_id);
+
+ public static PurpleMediaSessionType GetSessionType(PurpleMedia media, string sess_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * _PurpleMediaManager * purple_media_get_manager(PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_manager(IntPtr media);
+
+ public static _PurpleMediaManager GetManager(PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_get_codecs(PurpleMedia * media, gchar * sess_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_codecs(IntPtr media, string sess_id);
+
+ public static GList GetCodecs(PurpleMedia media, string sess_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_add_remote_candidates(PurpleMedia * media, gchar * sess_id, gchar * participant, GList * remote_candidates)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_add_remote_candidates(IntPtr media, string sess_id, string participant, IntPtr remote_candidates);
+
+ public static void AddRemoteCandidates(PurpleMedia media, string sess_id, string participant, GList remote_candidates)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_get_local_candidates(PurpleMedia * media, gchar * sess_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_local_candidates(IntPtr media, string sess_id, string participant);
+
+ public static GList GetLocalCandidates(PurpleMedia media, string sess_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_get_active_local_candidates(PurpleMedia * media, gchar * sess_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_active_local_candidates(IntPtr media, string sess_id, string participant);
+
+ public static GList GetActiveLocalCandidates(PurpleMedia media, string sess_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_get_active_remote_candidates(PurpleMedia * media, gchar * sess_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_get_active_remote_candidates(IntPtr media, string sess_id, string participant);
+
+ public static GList GetActiveRemoteCandidates(PurpleMedia media, string sess_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_set_remote_codecs(PurpleMedia * media, gchar * sess_id, gchar * participant, GList * codecs)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_set_remote_codecs(IntPtr media, string sess_id, string participant, IntPtr codecs);
+
+ public static bool SetRemoteCodecs(PurpleMedia media, string sess_id, string participant, GList codecs)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_candidates_prepared(PurpleMedia * media, gchar * session_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_candidates_prepared(IntPtr media, string session_id, string participant);
+
+ public static bool CandidatesPrepared(PurpleMedia media, string session_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_set_send_codec(PurpleMedia * media, gchar * sess_id, PurpleMediaCodec * codec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_set_send_codec(IntPtr media, string sess_id, IntPtr codec);
+
+ public static bool SetSendCodec(PurpleMedia media, string sess_id, PurpleMediaCodec codec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_codecs_ready(PurpleMedia * media, gchar * sess_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_codecs_ready(IntPtr media, string sess_id);
+
+ public static bool CodecsReady(PurpleMedia media, string sess_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_is_initiator(PurpleMedia * media, gchar * sess_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_is_initiator(IntPtr media, string sess_id, string participant);
+
+ public static bool IsInitiator(PurpleMedia media, string sess_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_accepted(PurpleMedia * media, gchar * sess_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_accepted(IntPtr media, string sess_id, string participant);
+
+ public static bool Accepted(PurpleMedia media, string sess_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_set_input_volume(PurpleMedia * media, gchar * session_id, double level)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_set_input_volume(IntPtr media, string session_id, double level);
+
+ public static void SetInputVolume(PurpleMedia media, string session_id, double level)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_set_output_volume(PurpleMedia * media, gchar * session_id, gchar * participant, double level)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_set_output_volume(IntPtr media, string session_id, string participant, double level);
+
+ public static void SetOutputVolume(PurpleMedia media, string session_id, string participant, double level)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_media_set_output_window(PurpleMedia * media, gchar * session_id, gchar * participant, gulong window_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_media_set_output_window(IntPtr media, string session_id, string participant, ulong window_id);
+
+ public static ulong SetOutputWindow(PurpleMedia media, string session_id, string participant, ulong window_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_remove_output_windows(PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_remove_output_windows(IntPtr media);
+
+ public static void RemoveOutputWindows(PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Mediamanager.cs 041e5f99d1fec6c0d4679252fb0757f94091f10c
+++ libpurple/wrapper/Mediamanager.cs 041e5f99d1fec6c0d4679252fb0757f94091f10c
@@ -0,0 +1,175 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Mediamanager
+ {
+ /*
+ * GType purple_media_manager_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_manager_get_type();
+
+ public static GType MediaManagerGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaManager * purple_media_manager_get()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_manager_get();
+
+ public static PurpleMediaManager MediaManagerGet()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMedia * purple_media_manager_create_media(PurpleMediaManager * manager, PurpleAccount * account, char * conference_type, char * remote_user, gboolean initiator)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_manager_create_media(IntPtr manager, IntPtr account, string conference_type, string remote_user, bool initiator);
+
+ public static PurpleMedia MediaManagerCreateMedia(PurpleMediaManager manager, PurpleAccount account, string conference_type, string remote_user, bool initiator)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_manager_get_media(PurpleMediaManager * manager)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_manager_get_media(IntPtr manager);
+
+ public static GList MediaManagerGetMedia(PurpleMediaManager manager)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_media_manager_get_media_by_account(PurpleMediaManager * manager, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_media_manager_get_media_by_account(IntPtr manager, IntPtr account);
+
+ public static GList MediaManagerGetMediaByAccount(PurpleMediaManager manager, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_manager_remove_media(PurpleMediaManager * manager, PurpleMedia * media)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_manager_remove_media(IntPtr manager, IntPtr media);
+
+ public static void MediaManagerRemoveMedia(PurpleMediaManager manager, PurpleMedia media)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_manager_create_output_window(PurpleMediaManager * manager, PurpleMedia * media, gchar * session_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_manager_create_output_window(IntPtr manager, IntPtr media, string session_id, string participant);
+
+ public static bool MediaManagerCreateOutputWindow(PurpleMediaManager manager, PurpleMedia media, string session_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_media_manager_set_output_window(PurpleMediaManager * manager, PurpleMedia * media, gchar * session_id, gchar * participant, gulong window_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_media_manager_set_output_window(IntPtr manager, IntPtr media, string session_id, string participant, ulong window_id);
+
+ public static ulong MediaManagerSetOutputWindow(PurpleMediaManager manager, PurpleMedia media, string session_id, string participant, ulong window_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_media_manager_remove_output_window(PurpleMediaManager * manager, gulong output_window_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_media_manager_remove_output_window(IntPtr manager, ulong output_window_id);
+
+ public static bool MediaManagerRemoveOutputWindow(PurpleMediaManager manager, ulong output_window_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_manager_remove_output_windows(PurpleMediaManager * manager, PurpleMedia * media, gchar * session_id, gchar * participant)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_manager_remove_output_windows(IntPtr manager, IntPtr media, string session_id, string participant);
+
+ public static void MediaManagerRemoveOutputWindows(PurpleMediaManager manager, PurpleMedia media, string session_id, string participant)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_media_manager_set_ui_caps(PurpleMediaManager * manager, PurpleMediaCaps caps)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_media_manager_set_ui_caps(IntPtr manager, UNKNOWN caps);
+
+ public static void MediaManagerSetUiCaps(PurpleMediaManager manager, PurpleMediaCaps caps)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaCaps purple_media_manager_get_ui_caps(PurpleMediaManager * manager)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_media_manager_get_ui_caps(IntPtr manager);
+
+ public static PurpleMediaCaps MediaManagerGetUiCaps(PurpleMediaManager manager)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Mime.cs 3a2a87fbb809e5fed1bd800f1a6b59c246bda462
+++ libpurple/wrapper/Mime.cs 3a2a87fbb809e5fed1bd800f1a6b59c246bda462
@@ -0,0 +1,241 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Mime
+ {
+ /*
+ * PurpleMimeDocument * purple_mime_document_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_document_new();
+
+ public static PurpleMimeDocument DocumentNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_document_free(PurpleMimeDocument * doc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_document_free(IntPtr doc);
+
+ public static void DocumentFree(PurpleMimeDocument doc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMimeDocument * purple_mime_document_parse(char * buf)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_document_parse(string buf);
+
+ public static PurpleMimeDocument DocumentParse(string buf)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMimeDocument * purple_mime_document_parsen(char * buf, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_document_parsen(string buf, UNKNOWN len);
+
+ public static PurpleMimeDocument DocumentParsen(string buf, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_document_write(PurpleMimeDocument * doc, GString * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_document_write(IntPtr doc, IntPtr str);
+
+ public static void DocumentWrite(PurpleMimeDocument doc, GString str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_mime_document_get_fields(PurpleMimeDocument * doc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_document_get_fields(IntPtr doc);
+
+ public static GList DocumentGetFields(PurpleMimeDocument doc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_mime_document_get_field(PurpleMimeDocument * doc, char * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_mime_document_get_field(IntPtr doc, string field);
+
+ public static string DocumentGetField(PurpleMimeDocument doc, string field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_document_set_field(PurpleMimeDocument * doc, char * field, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_document_set_field(IntPtr doc, string field, string value);
+
+ public static void DocumentSetField(PurpleMimeDocument doc, string field, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_mime_document_get_parts(PurpleMimeDocument * doc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_document_get_parts(IntPtr doc);
+
+ public static GList DocumentGetParts(PurpleMimeDocument doc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMimePart * purple_mime_part_new(PurpleMimeDocument * doc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_part_new(IntPtr doc);
+
+ public static PurpleMimePart PartNew(PurpleMimeDocument doc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_mime_part_get_fields(PurpleMimePart * part)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mime_part_get_fields(IntPtr part);
+
+ public static GList PartGetFields(PurpleMimePart part)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_mime_part_get_field(PurpleMimePart * part, char * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_mime_part_get_field(IntPtr part, string field);
+
+ public static string PartGetField(PurpleMimePart part, string field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_mime_part_get_field_decoded(PurpleMimePart * part, char * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_mime_part_get_field_decoded(IntPtr part, string field);
+
+ public static string PartGetFieldDecoded(PurpleMimePart part, string field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_part_set_field(PurpleMimePart * part, char * field, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_part_set_field(IntPtr part, string field, string value);
+
+ public static void PartSetField(PurpleMimePart part, string field, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_mime_part_get_data(PurpleMimePart * part)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_mime_part_get_data(IntPtr part);
+
+ public static string PartGetData(PurpleMimePart part)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_part_get_data_decoded(PurpleMimePart * part, guchar ** data, gsize * len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_part_get_data_decoded(IntPtr part, IntPtr data, IntPtr len);
+
+ public static void PartGetDataDecoded(PurpleMimePart part, guchar data, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gsize purple_mime_part_get_length(PurpleMimePart * part)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_mime_part_get_length(IntPtr part);
+
+ public static gsize PartGetLength(PurpleMimePart part)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_mime_part_set_data(PurpleMimePart * part, char * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_mime_part_set_data(IntPtr part, string data);
+
+ public static void PartSetData(PurpleMimePart part, string data)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/NatPmp.cs 184a8d5346ef7751e9fb90723b15b6095a39d315
+++ libpurple/wrapper/NatPmp.cs 184a8d5346ef7751e9fb90723b15b6095a39d315
@@ -0,0 +1,87 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class NatPmp
+ {
+ /*
+ * void purple_pmp_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pmp_init();
+
+ public static void PmpInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_pmp_get_public_ip()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_pmp_get_public_ip();
+
+ public static string PmpGetPublicIp()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_pmp_create_map(PurplePmpType type, unsigned short, unsigned short, int lifetime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_pmp_create_map(UNKNOWN type, UNKNOWN short, UNKNOWN short, int lifetime);
+
+ public static bool PmpCreateMap(PurplePmpType type, unsigned short, unsigned short, int lifetime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_pmp_destroy_map(PurplePmpType type, unsigned short)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_pmp_destroy_map(UNKNOWN type, UNKNOWN short);
+
+ public static bool PmpDestroyMap(PurplePmpType type, unsigned short)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Network.cs 75195b5f5664821413f14bf8393a68f6e699d07c
+++ libpurple/wrapper/Network.cs 75195b5f5664821413f14bf8393a68f6e699d07c
@@ -0,0 +1,252 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Network
+ {
+ /*
+ * char * purple_network_ip_atoi(char * ip)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_ip_atoi(string ip);
+
+ public static string IpAtoi(string ip)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_set_public_ip(char * ip)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_set_public_ip(string ip);
+
+ public static void SetPublicIp(string ip)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_network_get_public_ip()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_get_public_ip();
+
+ public static string GetPublicIp()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_network_get_local_system_ip(int fd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_get_local_system_ip(int fd);
+
+ public static string GetLocalSystemIp(int fd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_network_get_my_ip(int fd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_get_my_ip(int fd);
+
+ public static string GetMyIp(int fd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_listen_map_external(gboolean map_external)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_listen_map_external(bool map_external);
+
+ public static void ListenMapExternal(bool map_external)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNetworkListenData * purple_network_listen(unsigned short, int socket_type, PurpleNetworkListenCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_network_listen(UNKNOWN short, int socket_type, UNKNOWN cb, IntPtr cb_data);
+
+ public static PurpleNetworkListenData Listen(unsigned short, int socket_type, PurpleNetworkListenCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNetworkListenData * purple_network_listen_range(unsigned short, unsigned short, int socket_type, PurpleNetworkListenCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_network_listen_range(UNKNOWN short, UNKNOWN short, int socket_type, UNKNOWN cb, IntPtr cb_data);
+
+ public static PurpleNetworkListenData ListenRange(unsigned short, unsigned short, int socket_type, PurpleNetworkListenCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_listen_cancel(PurpleNetworkListenData * listen_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_listen_cancel(IntPtr listen_data);
+
+ public static void ListenCancel(PurpleNetworkListenData listen_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * short purple_network_get_port_from_fd(int fd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern short purple_network_get_port_from_fd(int fd);
+
+ public static short GetPortFromFd(int fd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_network_is_available()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_network_is_available();
+
+ public static bool IsAvailable()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_force_online()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_force_online();
+
+ public static void ForceOnline()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_network_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_network_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_set_stun_server(gchar * stun_server)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_set_stun_server(string stun_server);
+
+ public static void SetStunServer(string stun_server)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_network_get_stun_ip()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_get_stun_ip();
+
+ public static string GetStunIp()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_set_turn_server(gchar * stun_server)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_set_turn_server(string stun_server);
+
+ public static void SetTurnServer(string stun_server)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_network_get_turn_ip()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_network_get_turn_ip();
+
+ public static string GetTurnIp()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_network_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_network_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Notify.cs 1f1539bc627036b4f3859fb40bdd044a9df5ddcb
+++ libpurple/wrapper/Notify.cs 1f1539bc627036b4f3859fb40bdd044a9df5ddcb
@@ -0,0 +1,538 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Notify
+ {
+ /*
+ * void * purple_notify_searchresults(PurpleConnection * gc, char * title, char * primary, char * secondary, PurpleNotifySearchResults * results, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_searchresults(IntPtr gc, string title, string primary, string secondary, IntPtr results, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Searchresults(PurpleConnection gc, string title, string primary, string secondary, PurpleNotifySearchResults results, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_free(PurpleNotifySearchResults * results)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_free(IntPtr results);
+
+ public static void SearchresultsFree(PurpleNotifySearchResults results)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_new_rows(PurpleConnection * gc, PurpleNotifySearchResults * results, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_new_rows(IntPtr gc, IntPtr results, IntPtr data);
+
+ public static void SearchresultsNewRows(PurpleConnection gc, PurpleNotifySearchResults results, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_button_add(PurpleNotifySearchResults * results, PurpleNotifySearchButtonType type, PurpleNotifySearchResultsCallback cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_button_add(IntPtr results, UNKNOWN type, UNKNOWN cb);
+
+ public static void SearchresultsButtonAdd(PurpleNotifySearchResults results, PurpleNotifySearchButtonType type, PurpleNotifySearchResultsCallback cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_button_add_labeled(PurpleNotifySearchResults * results, char * label, PurpleNotifySearchResultsCallback cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_button_add_labeled(IntPtr results, string label, UNKNOWN cb);
+
+ public static void SearchresultsButtonAddLabeled(PurpleNotifySearchResults results, string label, PurpleNotifySearchResultsCallback cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifySearchResults * purple_notify_searchresults_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_searchresults_new();
+
+ public static PurpleNotifySearchResults SearchresultsNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifySearchColumn * purple_notify_searchresults_column_new(char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_searchresults_column_new(string title);
+
+ public static PurpleNotifySearchColumn SearchresultsColumnNew(string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_column_add(PurpleNotifySearchResults * results, PurpleNotifySearchColumn * column)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_column_add(IntPtr results, IntPtr column);
+
+ public static void SearchresultsColumnAdd(PurpleNotifySearchResults results, PurpleNotifySearchColumn column)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_searchresults_row_add(PurpleNotifySearchResults * results, GList * row)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_searchresults_row_add(IntPtr results, IntPtr row);
+
+ public static void SearchresultsRowAdd(PurpleNotifySearchResults results, GList row)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_notify_searchresults_get_rows_count(PurpleNotifySearchResults * results)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_notify_searchresults_get_rows_count(IntPtr results);
+
+ public static uint SearchresultsGetRowsCount(PurpleNotifySearchResults results)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_notify_searchresults_get_columns_count(PurpleNotifySearchResults * results)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_notify_searchresults_get_columns_count(IntPtr results);
+
+ public static uint SearchresultsGetColumnsCount(PurpleNotifySearchResults results)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_notify_searchresults_row_get(PurpleNotifySearchResults * results, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_searchresults_row_get(IntPtr results, UNKNOWN int);
+
+ public static GList SearchresultsRowGet(PurpleNotifySearchResults results, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_notify_searchresults_column_get_title(PurpleNotifySearchResults * results, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_notify_searchresults_column_get_title(IntPtr results, UNKNOWN int);
+
+ public static string SearchresultsColumnGetTitle(PurpleNotifySearchResults results, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_message(void * handle, PurpleNotifyMsgType type, char * title, char * primary, char * secondary, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_message(IntPtr handle, UNKNOWN type, string title, string primary, string secondary, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Message(IntPtr handle, PurpleNotifyMsgType type, string title, string primary, string secondary, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_email(void * handle, char * subject, char * from, char * to, char * url, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_email(IntPtr handle, string subject, string from, string to, string url, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Email(IntPtr handle, string subject, string from, string to, string url, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_emails(void * handle, size_t count, gboolean detailed, char ** subjects, char ** froms, char ** tos, char ** urls, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_emails(IntPtr handle, UNKNOWN count, bool detailed, IntPtr subjects, IntPtr froms, IntPtr tos, IntPtr urls, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Emails(IntPtr handle, size_t count, bool detailed, char subjects, char froms, char tos, char urls, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_formatted(void * handle, char * title, char * primary, char * secondary, char * text, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_formatted(IntPtr handle, string title, string primary, string secondary, string text, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Formatted(IntPtr handle, string title, string primary, string secondary, string text, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_userinfo(PurpleConnection * gc, char * who, PurpleNotifyUserInfo * user_info, PurpleNotifyCloseCallback cb, gpointer user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_userinfo(IntPtr gc, string who, IntPtr user_info, UNKNOWN cb, IntPtr user_data);
+
+ public static IntPtr Userinfo(PurpleConnection gc, string who, PurpleNotifyUserInfo user_info, PurpleNotifyCloseCallback cb, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifyUserInfo * purple_notify_user_info_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_user_info_new();
+
+ public static PurpleNotifyUserInfo UserInfoNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_destroy(PurpleNotifyUserInfo * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_destroy(IntPtr user_info);
+
+ public static void UserInfoDestroy(PurpleNotifyUserInfo user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_notify_user_info_get_entries(PurpleNotifyUserInfo * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_user_info_get_entries(IntPtr user_info);
+
+ public static GList UserInfoGetEntries(PurpleNotifyUserInfo user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_notify_user_info_get_text_with_newline(PurpleNotifyUserInfo * user_info, char * newline)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_notify_user_info_get_text_with_newline(IntPtr user_info, string newline);
+
+ public static string UserInfoGetTextWithNewline(PurpleNotifyUserInfo user_info, string newline)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_add_pair(PurpleNotifyUserInfo * user_info, char * label, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_add_pair(IntPtr user_info, string label, string value);
+
+ public static void UserInfoAddPair(PurpleNotifyUserInfo user_info, string label, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_prepend_pair(PurpleNotifyUserInfo * user_info, char * label, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_prepend_pair(IntPtr user_info, string label, string value);
+
+ public static void UserInfoPrependPair(PurpleNotifyUserInfo user_info, string label, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_remove_entry(PurpleNotifyUserInfo * user_info, PurpleNotifyUserInfoEntry * user_info_entry)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_remove_entry(IntPtr user_info, IntPtr user_info_entry);
+
+ public static void UserInfoRemoveEntry(PurpleNotifyUserInfo user_info, PurpleNotifyUserInfoEntry user_info_entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifyUserInfoEntry * purple_notify_user_info_entry_new(char * label, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_user_info_entry_new(string label, string value);
+
+ public static PurpleNotifyUserInfoEntry UserInfoEntryNew(string label, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_add_section_break(PurpleNotifyUserInfo * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_add_section_break(IntPtr user_info);
+
+ public static void UserInfoAddSectionBreak(PurpleNotifyUserInfo user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_prepend_section_break(PurpleNotifyUserInfo * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_prepend_section_break(IntPtr user_info);
+
+ public static void UserInfoPrependSectionBreak(PurpleNotifyUserInfo user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_add_section_header(PurpleNotifyUserInfo * user_info, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_add_section_header(IntPtr user_info, string label);
+
+ public static void UserInfoAddSectionHeader(PurpleNotifyUserInfo user_info, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_prepend_section_header(PurpleNotifyUserInfo * user_info, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_prepend_section_header(IntPtr user_info, string label);
+
+ public static void UserInfoPrependSectionHeader(PurpleNotifyUserInfo user_info, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_remove_last_item(PurpleNotifyUserInfo * user_info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_remove_last_item(IntPtr user_info);
+
+ public static void UserInfoRemoveLastItem(PurpleNotifyUserInfo user_info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_notify_user_info_entry_get_label(PurpleNotifyUserInfoEntry * user_info_entry)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_notify_user_info_entry_get_label(IntPtr user_info_entry);
+
+ public static string UserInfoEntryGetLabel(PurpleNotifyUserInfoEntry user_info_entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_entry_set_label(PurpleNotifyUserInfoEntry * user_info_entry, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_entry_set_label(IntPtr user_info_entry, string label);
+
+ public static void UserInfoEntrySetLabel(PurpleNotifyUserInfoEntry user_info_entry, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_notify_user_info_entry_get_value(PurpleNotifyUserInfoEntry * user_info_entry)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_notify_user_info_entry_get_value(IntPtr user_info_entry);
+
+ public static string UserInfoEntryGetValue(PurpleNotifyUserInfoEntry user_info_entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_entry_set_value(PurpleNotifyUserInfoEntry * user_info_entry, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_entry_set_value(IntPtr user_info_entry, string value);
+
+ public static void UserInfoEntrySetValue(PurpleNotifyUserInfoEntry user_info_entry, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifyUserInfoEntryType purple_notify_user_info_entry_get_type(PurpleNotifyUserInfoEntry * user_info_entry)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_notify_user_info_entry_get_type(IntPtr user_info_entry);
+
+ public static PurpleNotifyUserInfoEntryType UserInfoEntryGetType(PurpleNotifyUserInfoEntry user_info_entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_user_info_entry_set_type(PurpleNotifyUserInfoEntry * user_info_entry, PurpleNotifyUserInfoEntryType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_user_info_entry_set_type(IntPtr user_info_entry, UNKNOWN type);
+
+ public static void UserInfoEntrySetType(PurpleNotifyUserInfoEntry user_info_entry, PurpleNotifyUserInfoEntryType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_uri(void * handle, char * uri)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_uri(IntPtr handle, string uri);
+
+ public static IntPtr Uri(IntPtr handle, string uri)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_close(PurpleNotifyType type, void * ui_handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_close(UNKNOWN type, IntPtr ui_handle);
+
+ public static void Close(PurpleNotifyType type, IntPtr ui_handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_close_with_handle(void * handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_close_with_handle(IntPtr handle);
+
+ public static void CloseWithHandle(IntPtr handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_set_ui_ops(PurpleNotifyUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleNotifyUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleNotifyUiOps * purple_notify_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_get_ui_ops();
+
+ public static PurpleNotifyUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_notify_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_notify_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_notify_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_notify_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Ntlm.cs 92a5717a2815ff4058b0fff2e1da9dd8d4c0ba10
+++ libpurple/wrapper/Ntlm.cs 92a5717a2815ff4058b0fff2e1da9dd8d4c0ba10
@@ -0,0 +1,76 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Ntlm
+ {
+ /*
+ * gchar * purple_ntlm_gen_type1(gchar * hostname, gchar * domain)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_ntlm_gen_type1(string hostname, string domain);
+
+ public static string GenType1(string hostname, string domain)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint8 * purple_ntlm_parse_type2(gchar * type2, guint32 * flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ntlm_parse_type2(string type2, IntPtr flags);
+
+ public static guint8 ParseType2(string type2, guint32 flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_ntlm_gen_type3(gchar * username, gchar * passw, gchar * hostname, gchar * domain, guint8 * nonce, guint32 * flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_ntlm_gen_type3(string username, string passw, string hostname, string domain, IntPtr nonce, IntPtr flags);
+
+ public static string GenType3(string username, string passw, string hostname, string domain, guint8 nonce, guint32 flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Plugin.cs b812ff8d30fec18ed5474623d412787ba7b0c44b
+++ libpurple/wrapper/Plugin.cs b812ff8d30fec18ed5474623d412787ba7b0c44b
@@ -0,0 +1,637 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Plugin
+ {
+ /*
+ * gboolean _FUNC_NAME( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool _FUNC_NAME(UNKNOWN );
+
+ public static bool _funcName( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean _FUNC_NAME( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool _FUNC_NAME(UNKNOWN );
+
+ public static bool _funcName( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * return purple_plugin_register( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_plugin_register(UNKNOWN );
+
+ public static return Register( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_init_plugin(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_init_plugin(IntPtr plugin);
+
+ public static bool InitPlugin(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_init_plugin(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_init_plugin(IntPtr plugin);
+
+ public static bool InitPlugin(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * return purple_plugin_register( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_plugin_register(UNKNOWN );
+
+ public static return Register( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugin_new(gboolean native, char * path)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_new(bool native, string path);
+
+ public static PurplePlugin New(bool native, string path)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugin_probe(char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_probe(string filename);
+
+ public static PurplePlugin Probe(string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_register(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_register(IntPtr plugin);
+
+ public static bool Register(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_load(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_load(IntPtr plugin);
+
+ public static bool Load(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_unload(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_unload(IntPtr plugin);
+
+ public static bool Unload(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_disable(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_disable(IntPtr plugin);
+
+ public static void Disable(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_reload(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_reload(IntPtr plugin);
+
+ public static bool Reload(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_destroy(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_destroy(IntPtr plugin);
+
+ public static void Destroy(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_is_loaded(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_is_loaded(IntPtr plugin);
+
+ public static bool IsLoaded(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_is_unloadable(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_is_unloadable(IntPtr plugin);
+
+ public static bool IsUnloadable(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_id(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_id(IntPtr plugin);
+
+ public static string GetId(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_name(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_name(IntPtr plugin);
+
+ public static string GetName(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_version(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_version(IntPtr plugin);
+
+ public static string GetVersion(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_summary(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_summary(IntPtr plugin);
+
+ public static string GetSummary(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_description(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_description(IntPtr plugin);
+
+ public static string GetDescription(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_author(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_author(IntPtr plugin);
+
+ public static string GetAuthor(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_plugin_get_homepage(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_get_homepage(IntPtr plugin);
+
+ public static string GetHomepage(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_ipc_register(PurplePlugin * plugin, char * command, PurpleCallback func, PurpleSignalMarshalFunc marshal, PurpleValue * ret_value, int num_params, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_ipc_register(IntPtr plugin, string command, UNKNOWN func, UNKNOWN marshal, IntPtr ret_value, int num_params, ...);
+
+ public static bool IpcRegister(PurplePlugin plugin, string command, PurpleCallback func, PurpleSignalMarshalFunc marshal, PurpleValue ret_value, int num_params, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_ipc_unregister(PurplePlugin * plugin, char * command)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_ipc_unregister(IntPtr plugin, string command);
+
+ public static void IpcUnregister(PurplePlugin plugin, string command)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_ipc_unregister_all(PurplePlugin * plugin)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_ipc_unregister_all(IntPtr plugin);
+
+ public static void IpcUnregisterAll(PurplePlugin plugin)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_ipc_get_params(PurplePlugin * plugin, char * command, PurpleValue ** ret_value, int * num_params, PurpleValue *** params)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_ipc_get_params(IntPtr plugin, string command, IntPtr ret_value, IntPtr num_params, IntPtr params);
+
+ public static bool IpcGetParams(PurplePlugin plugin, string command, PurpleValue ret_value, int num_params, PurpleValue params)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_plugin_ipc_call(PurplePlugin * plugin, char * command, gboolean * ok, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_ipc_call(IntPtr plugin, string command, IntPtr ok, ...);
+
+ public static IntPtr IpcCall(PurplePlugin plugin, string command, gboolean ok, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_add_search_path(char * path)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_add_search_path(string path);
+
+ public static void PluginsAddSearchPath(string path)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_unload_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_unload_all();
+
+ public static void PluginsUnloadAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_unload(PurplePluginType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_unload(UNKNOWN type);
+
+ public static void PluginsUnload(PurplePluginType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_destroy_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_destroy_all();
+
+ public static void PluginsDestroyAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_save_loaded(char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_save_loaded(string key);
+
+ public static void PluginsSaveLoaded(string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_load_saved(char * key)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_load_saved(string key);
+
+ public static void PluginsLoadSaved(string key)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_probe(char * ext)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_probe(string ext);
+
+ public static void PluginsProbe(string ext)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugins_enabled()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugins_enabled();
+
+ public static bool PluginsEnabled()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_register_probe_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_register_probe_notify_cb(UNKNOWN );
+
+ public static void PluginsRegisterProbeNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_unregister_probe_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_unregister_probe_notify_cb(UNKNOWN );
+
+ public static void PluginsUnregisterProbeNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_register_load_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_register_load_notify_cb(UNKNOWN );
+
+ public static void PluginsRegisterLoadNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_unregister_load_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_unregister_load_notify_cb(UNKNOWN );
+
+ public static void PluginsUnregisterLoadNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_register_unload_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_register_unload_notify_cb(UNKNOWN );
+
+ public static void PluginsRegisterUnloadNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_unregister_unload_notify_cb( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_unregister_unload_notify_cb(UNKNOWN );
+
+ public static void PluginsUnregisterUnloadNotifyCb( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugins_find_with_name(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_find_with_name(string name);
+
+ public static PurplePlugin PluginsFindWithName(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugins_find_with_filename(char * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_find_with_filename(string filename);
+
+ public static PurplePlugin PluginsFindWithFilename(string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugins_find_with_basename(char * basename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_find_with_basename(string basename);
+
+ public static PurplePlugin PluginsFindWithBasename(string basename)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_plugins_find_with_id(char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_find_with_id(string id);
+
+ public static PurplePlugin PluginsFindWithId(string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_plugins_get_loaded()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_get_loaded();
+
+ public static GList PluginsGetLoaded()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_plugins_get_protocols()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_get_protocols();
+
+ public static GList PluginsGetProtocols()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_plugins_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_get_all();
+
+ public static GList PluginsGetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_plugins_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugins_get_handle();
+
+ public static IntPtr PluginsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_init();
+
+ public static void PluginsInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugins_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugins_uninit();
+
+ public static void PluginsUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginAction * purple_plugin_action_new( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_action_new(UNKNOWN , UNKNOWN );
+
+ public static PurplePluginAction ActionNew( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_action_free(PurplePluginAction * action)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_action_free(IntPtr action);
+
+ public static void ActionFree(PurplePluginAction action)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Pluginpref.cs 5bc34570e9845a5ba6eca9e2eb9a051057a25508
+++ libpurple/wrapper/Pluginpref.cs 5bc34570e9845a5ba6eca9e2eb9a051057a25508
@@ -0,0 +1,318 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Pluginpref
+ {
+ /*
+ * PurplePluginPrefFrame * purple_plugin_pref_frame_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_frame_new();
+
+ public static PurplePluginPrefFrame PluginPrefFrameNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_frame_destroy(PurplePluginPrefFrame * frame)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_frame_destroy(IntPtr frame);
+
+ public static void PluginPrefFrameDestroy(PurplePluginPrefFrame frame)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_frame_add(PurplePluginPrefFrame * frame, PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_frame_add(IntPtr frame, IntPtr pref);
+
+ public static void PluginPrefFrameAdd(PurplePluginPrefFrame frame, PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_plugin_pref_frame_get_prefs(PurplePluginPrefFrame * frame)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_frame_get_prefs(IntPtr frame);
+
+ public static GList PluginPrefFrameGetPrefs(PurplePluginPrefFrame frame)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginPref * purple_plugin_pref_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_new();
+
+ public static PurplePluginPref PluginPrefNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginPref * purple_plugin_pref_new_with_name(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_new_with_name(string name);
+
+ public static PurplePluginPref PluginPrefNewWithName(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginPref * purple_plugin_pref_new_with_label(char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_new_with_label(string label);
+
+ public static PurplePluginPref PluginPrefNewWithLabel(string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginPref * purple_plugin_pref_new_with_name_and_label(char * name, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_new_with_name_and_label(string name, string label);
+
+ public static PurplePluginPref PluginPrefNewWithNameAndLabel(string name, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_destroy(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_destroy(IntPtr pref);
+
+ public static void PluginPrefDestroy(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_name(PurplePluginPref * pref, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_name(IntPtr pref, string name);
+
+ public static void PluginPrefSetName(PurplePluginPref pref, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_plugin_pref_get_name(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_pref_get_name(IntPtr pref);
+
+ public static string PluginPrefGetName(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_label(PurplePluginPref * pref, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_label(IntPtr pref, string label);
+
+ public static void PluginPrefSetLabel(PurplePluginPref pref, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_plugin_pref_get_label(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_plugin_pref_get_label(IntPtr pref);
+
+ public static string PluginPrefGetLabel(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_bounds(PurplePluginPref * pref, int min, int max)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_bounds(IntPtr pref, int min, int max);
+
+ public static void PluginPrefSetBounds(PurplePluginPref pref, int min, int max)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_get_bounds(PurplePluginPref * pref, int * min, int * max)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_get_bounds(IntPtr pref, IntPtr min, IntPtr max);
+
+ public static void PluginPrefGetBounds(PurplePluginPref pref, int min, int max)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_type(PurplePluginPref * pref, PurplePluginPrefType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_type(IntPtr pref, UNKNOWN type);
+
+ public static void PluginPrefSetType(PurplePluginPref pref, PurplePluginPrefType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePluginPrefType purple_plugin_pref_get_type(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_plugin_pref_get_type(IntPtr pref);
+
+ public static PurplePluginPrefType PluginPrefGetType(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_add_choice(PurplePluginPref * pref, char * label, gpointer choice)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_add_choice(IntPtr pref, string label, IntPtr choice);
+
+ public static void PluginPrefAddChoice(PurplePluginPref pref, string label, IntPtr choice)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_plugin_pref_get_choices(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_plugin_pref_get_choices(IntPtr pref);
+
+ public static GList PluginPrefGetChoices(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_max_length(PurplePluginPref * pref, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_max_length(IntPtr pref, UNKNOWN int);
+
+ public static void PluginPrefSetMaxLength(PurplePluginPref pref, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_plugin_pref_get_max_length(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_plugin_pref_get_max_length(IntPtr pref);
+
+ public static int PluginPrefGetMaxLength(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_masked(PurplePluginPref * pref, gboolean mask)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_masked(IntPtr pref, bool mask);
+
+ public static void PluginPrefSetMasked(PurplePluginPref pref, bool mask)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_plugin_pref_get_masked(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_plugin_pref_get_masked(IntPtr pref);
+
+ public static bool PluginPrefGetMasked(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_plugin_pref_set_format_type(PurplePluginPref * pref, PurpleStringFormatType format)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_plugin_pref_set_format_type(IntPtr pref, UNKNOWN format);
+
+ public static void PluginPrefSetFormatType(PurplePluginPref pref, PurpleStringFormatType format)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStringFormatType purple_plugin_pref_get_format_type(PurplePluginPref * pref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_plugin_pref_get_format_type(IntPtr pref);
+
+ public static PurpleStringFormatType PluginPrefGetFormatType(PurplePluginPref pref)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Pounce.cs d73876a171f1f42bb9cde032f393a4d9bc30095a
+++ libpurple/wrapper/Pounce.cs d73876a171f1f42bb9cde032f393a4d9bc30095a
@@ -0,0 +1,373 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Pounce
+ {
+ /*
+ * PurplePounce * purple_pounce_new(char * ui_type, PurpleAccount * pouncer, char * pouncee, PurplePounceEvent event, PurplePounceOption option)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounce_new(string ui_type, IntPtr pouncer, string pouncee, UNKNOWN event, UNKNOWN option);
+
+ public static PurplePounce New(string ui_type, PurpleAccount pouncer, string pouncee, PurplePounceEvent event, PurplePounceOption option)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_destroy(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_destroy(IntPtr pounce);
+
+ public static void Destroy(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_destroy_all_by_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_destroy_all_by_account(IntPtr account);
+
+ public static void DestroyAllByAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_events(PurplePounce * pounce, PurplePounceEvent events)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_events(IntPtr pounce, UNKNOWN events);
+
+ public static void SetEvents(PurplePounce pounce, PurplePounceEvent events)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_options(PurplePounce * pounce, PurplePounceOption options)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_options(IntPtr pounce, UNKNOWN options);
+
+ public static void SetOptions(PurplePounce pounce, PurplePounceOption options)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_pouncer(PurplePounce * pounce, PurpleAccount * pouncer)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_pouncer(IntPtr pounce, IntPtr pouncer);
+
+ public static void SetPouncer(PurplePounce pounce, PurpleAccount pouncer)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_pouncee(PurplePounce * pounce, char * pouncee)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_pouncee(IntPtr pounce, string pouncee);
+
+ public static void SetPouncee(PurplePounce pounce, string pouncee)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_save(PurplePounce * pounce, gboolean save)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_save(IntPtr pounce, bool save);
+
+ public static void SetSave(PurplePounce pounce, bool save)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_action_register(PurplePounce * pounce, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_action_register(IntPtr pounce, string name);
+
+ public static void ActionRegister(PurplePounce pounce, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_action_set_enabled(PurplePounce * pounce, char * action, gboolean enabled)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_action_set_enabled(IntPtr pounce, string action, bool enabled);
+
+ public static void ActionSetEnabled(PurplePounce pounce, string action, bool enabled)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_action_set_attribute(PurplePounce * pounce, char * action, char * attr, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_action_set_attribute(IntPtr pounce, string action, string attr, string value);
+
+ public static void ActionSetAttribute(PurplePounce pounce, string action, string attr, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_set_data(PurplePounce * pounce, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_set_data(IntPtr pounce, IntPtr data);
+
+ public static void SetData(PurplePounce pounce, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePounceEvent purple_pounce_get_events(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_pounce_get_events(IntPtr pounce);
+
+ public static PurplePounceEvent GetEvents(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePounceOption purple_pounce_get_options(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_pounce_get_options(IntPtr pounce);
+
+ public static PurplePounceOption GetOptions(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_pounce_get_pouncer(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounce_get_pouncer(IntPtr pounce);
+
+ public static PurpleAccount GetPouncer(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_pounce_get_pouncee(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_pounce_get_pouncee(IntPtr pounce);
+
+ public static string GetPouncee(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_pounce_get_save(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_pounce_get_save(IntPtr pounce);
+
+ public static bool GetSave(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_pounce_action_is_enabled(PurplePounce * pounce, char * action)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_pounce_action_is_enabled(IntPtr pounce, string action);
+
+ public static bool ActionIsEnabled(PurplePounce pounce, string action)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_pounce_action_get_attribute(PurplePounce * pounce, char * action, char * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_pounce_action_get_attribute(IntPtr pounce, string action, string attr);
+
+ public static string ActionGetAttribute(PurplePounce pounce, string action, string attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_pounce_get_data(PurplePounce * pounce)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounce_get_data(IntPtr pounce);
+
+ public static IntPtr GetData(PurplePounce pounce)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounce_execute(PurpleAccount * pouncer, char * pouncee, PurplePounceEvent events)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounce_execute(IntPtr pouncer, string pouncee, UNKNOWN events);
+
+ public static void Execute(PurpleAccount pouncer, string pouncee, PurplePounceEvent events)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePounce * purple_find_pounce(PurpleAccount * pouncer, char * pouncee, PurplePounceEvent events)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_pounce(IntPtr pouncer, string pouncee, UNKNOWN events);
+
+ public static PurplePounce FindPounce(PurpleAccount pouncer, string pouncee, PurplePounceEvent events)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_pounces_load()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_pounces_load();
+
+ public static bool PouncesLoad()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounces_register_handler(char * ui, PurplePounceCb cb, )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounces_register_handler(string ui, UNKNOWN cb, UNKNOWN );
+
+ public static void PouncesRegisterHandler(string ui, PurplePounceCb cb, )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounces_unregister_handler(char * ui)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounces_unregister_handler(string ui);
+
+ public static void PouncesUnregisterHandler(string ui)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_pounces_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounces_get_all();
+
+ public static GList PouncesGetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_pounces_get_all_for_ui(char * ui)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounces_get_all_for_ui(string ui);
+
+ public static GList PouncesGetAllForUi(string ui)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_pounces_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_pounces_get_handle();
+
+ public static IntPtr PouncesGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounces_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounces_init();
+
+ public static void PouncesInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_pounces_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_pounces_uninit();
+
+ public static void PouncesUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Prefs.cs efd47832daa59dfcf43fa14679d89011ea69409c
+++ libpurple/wrapper/Prefs.cs efd47832daa59dfcf43fa14679d89011ea69409c
@@ -0,0 +1,439 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Prefs
+ {
+ /*
+ * void * purple_prefs_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_prefs_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_none(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_none(string name);
+
+ public static void AddNone(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_bool(char * name, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_bool(string name, bool value);
+
+ public static void AddBool(string name, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_int(char * name, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_int(string name, int value);
+
+ public static void AddInt(string name, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_string(char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_string(string name, string value);
+
+ public static void AddString(string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_string_list(char * name, GList * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_string_list(string name, IntPtr value);
+
+ public static void AddStringList(string name, GList value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_path(char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_path(string name, string value);
+
+ public static void AddPath(string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_add_path_list(char * name, GList * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_add_path_list(string name, IntPtr value);
+
+ public static void AddPathList(string name, GList value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_remove(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_remove(string name);
+
+ public static void Remove(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_rename(char * oldname, char * newname)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_rename(string oldname, string newname);
+
+ public static void Rename(string oldname, string newname)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_rename_boolean_toggle(char * oldname, char * newname)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_rename_boolean_toggle(string oldname, string newname);
+
+ public static void RenameBooleanToggle(string oldname, string newname)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_destroy()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_destroy();
+
+ public static void Destroy()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_generic(char * name, gpointer value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_generic(string name, IntPtr value);
+
+ public static void SetGeneric(string name, IntPtr value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_bool(char * name, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_bool(string name, bool value);
+
+ public static void SetBool(string name, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_int(char * name, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_int(string name, int value);
+
+ public static void SetInt(string name, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_string(char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_string(string name, string value);
+
+ public static void SetString(string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_string_list(char * name, GList * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_string_list(string name, IntPtr value);
+
+ public static void SetStringList(string name, GList value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_path(char * name, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_path(string name, string value);
+
+ public static void SetPath(string name, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_set_path_list(char * name, GList * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_set_path_list(string name, IntPtr value);
+
+ public static void SetPathList(string name, GList value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_prefs_exists(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_prefs_exists(string name);
+
+ public static bool Exists(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePrefType purple_prefs_get_type(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_prefs_get_type(string name);
+
+ public static PurplePrefType GetType(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_prefs_get_bool(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_prefs_get_bool(string name);
+
+ public static bool GetBool(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_prefs_get_int(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_prefs_get_int(string name);
+
+ public static int GetInt(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_prefs_get_string(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_prefs_get_string(string name);
+
+ public static string GetString(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_prefs_get_string_list(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_prefs_get_string_list(string name);
+
+ public static GList GetStringList(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_prefs_get_path(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_prefs_get_path(string name);
+
+ public static string GetPath(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_prefs_get_path_list(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_prefs_get_path_list(string name);
+
+ public static GList GetPathList(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_prefs_get_children_names(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_prefs_get_children_names(string name);
+
+ public static GList GetChildrenNames(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint purple_prefs_connect_callback(void * handle, char * name, PurplePrefCallback cb, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern uint purple_prefs_connect_callback(IntPtr handle, string name, UNKNOWN cb, IntPtr data);
+
+ public static uint ConnectCallback(IntPtr handle, string name, PurplePrefCallback cb, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_disconnect_callback(guint callback_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_disconnect_callback(uint callback_id);
+
+ public static void DisconnectCallback(uint callback_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_disconnect_by_handle(void * handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_disconnect_by_handle(IntPtr handle);
+
+ public static void DisconnectByHandle(IntPtr handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_trigger_callback(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_trigger_callback(string name);
+
+ public static void TriggerCallback(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_prefs_load()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_prefs_load();
+
+ public static bool Load()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prefs_update_old()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prefs_update_old();
+
+ public static void UpdateOld()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Privacy.cs dea43fea4b6136d9a31f6dc1a421e969ee2c4848
+++ libpurple/wrapper/Privacy.cs dea43fea4b6136d9a31f6dc1a421e969ee2c4848
@@ -0,0 +1,153 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Privacy
+ {
+ /*
+ * gboolean purple_privacy_permit_add(PurpleAccount * account, char * name, gboolean local_only)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_privacy_permit_add(IntPtr account, string name, bool local_only);
+
+ public static bool PermitAdd(PurpleAccount account, string name, bool local_only)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_privacy_permit_remove(PurpleAccount * account, char * name, gboolean local_only)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_privacy_permit_remove(IntPtr account, string name, bool local_only);
+
+ public static bool PermitRemove(PurpleAccount account, string name, bool local_only)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_privacy_deny_add(PurpleAccount * account, char * name, gboolean local_only)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_privacy_deny_add(IntPtr account, string name, bool local_only);
+
+ public static bool DenyAdd(PurpleAccount account, string name, bool local_only)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_privacy_deny_remove(PurpleAccount * account, char * name, gboolean local_only)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_privacy_deny_remove(IntPtr account, string name, bool local_only);
+
+ public static bool DenyRemove(PurpleAccount account, string name, bool local_only)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_privacy_allow(PurpleAccount * account, char * who, gboolean local, gboolean restore)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_privacy_allow(IntPtr account, string who, bool local, bool restore);
+
+ public static void Allow(PurpleAccount account, string who, bool local, bool restore)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_privacy_deny(PurpleAccount * account, char * who, gboolean local, gboolean restore)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_privacy_deny(IntPtr account, string who, bool local, bool restore);
+
+ public static void Deny(PurpleAccount account, string who, bool local, bool restore)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_privacy_check(PurpleAccount * account, char * who)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_privacy_check(IntPtr account, string who);
+
+ public static bool Check(PurpleAccount account, string who)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_privacy_set_ui_ops(PurplePrivacyUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_privacy_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurplePrivacyUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePrivacyUiOps * purple_privacy_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_privacy_get_ui_ops();
+
+ public static PurplePrivacyUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_privacy_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_privacy_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Proxy.cs 77fb0b88d96aacf393f246c64704cabde6ac10f1
+++ libpurple/wrapper/Proxy.cs 77fb0b88d96aacf393f246c64704cabde6ac10f1
@@ -0,0 +1,296 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Proxy
+ {
+ /*
+ * PurpleProxyInfo * purple_proxy_info_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_info_new();
+
+ public static PurpleProxyInfo InfoNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_destroy(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_destroy(IntPtr info);
+
+ public static void InfoDestroy(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_set_type(PurpleProxyInfo * info, PurpleProxyType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_set_type(IntPtr info, UNKNOWN type);
+
+ public static void InfoSetType(PurpleProxyInfo info, PurpleProxyType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_set_host(PurpleProxyInfo * info, char * host)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_set_host(IntPtr info, string host);
+
+ public static void InfoSetHost(PurpleProxyInfo info, string host)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_set_port(PurpleProxyInfo * info, int port)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_set_port(IntPtr info, int port);
+
+ public static void InfoSetPort(PurpleProxyInfo info, int port)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_set_username(PurpleProxyInfo * info, char * username)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_set_username(IntPtr info, string username);
+
+ public static void InfoSetUsername(PurpleProxyInfo info, string username)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_info_set_password(PurpleProxyInfo * info, char * password)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_info_set_password(IntPtr info, string password);
+
+ public static void InfoSetPassword(PurpleProxyInfo info, string password)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyType purple_proxy_info_get_type(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_proxy_info_get_type(IntPtr info);
+
+ public static PurpleProxyType InfoGetType(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_proxy_info_get_host(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_proxy_info_get_host(IntPtr info);
+
+ public static string InfoGetHost(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_proxy_info_get_port(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_proxy_info_get_port(IntPtr info);
+
+ public static int InfoGetPort(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_proxy_info_get_username(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_proxy_info_get_username(IntPtr info);
+
+ public static string InfoGetUsername(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_proxy_info_get_password(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_proxy_info_get_password(IntPtr info);
+
+ public static string InfoGetPassword(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyInfo * purple_global_proxy_get_info()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_global_proxy_get_info();
+
+ public static PurpleProxyInfo GlobalProxyGetInfo()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_global_proxy_set_info(PurpleProxyInfo * info)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_global_proxy_set_info(IntPtr info);
+
+ public static void GlobalProxySetInfo(PurpleProxyInfo info)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_proxy_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyInfo * purple_proxy_get_setup(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_get_setup(IntPtr account);
+
+ public static PurpleProxyInfo GetSetup(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyConnectData * purple_proxy_connect(void * handle, PurpleAccount * account, char * host, int port, PurpleProxyConnectFunction connect_cb, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_connect(IntPtr handle, IntPtr account, string host, int port, UNKNOWN connect_cb, IntPtr data);
+
+ public static PurpleProxyConnectData Connect(IntPtr handle, PurpleAccount account, string host, int port, PurpleProxyConnectFunction connect_cb, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyConnectData * purple_proxy_connect_udp(void * handle, PurpleAccount * account, char * host, int port, PurpleProxyConnectFunction connect_cb, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_connect_udp(IntPtr handle, IntPtr account, string host, int port, UNKNOWN connect_cb, IntPtr data);
+
+ public static PurpleProxyConnectData ConnectUdp(IntPtr handle, PurpleAccount account, string host, int port, PurpleProxyConnectFunction connect_cb, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleProxyConnectData * purple_proxy_connect_socks5(void * handle, PurpleProxyInfo * gpi, char * host, int port, PurpleProxyConnectFunction connect_cb, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_proxy_connect_socks5(IntPtr handle, IntPtr gpi, string host, int port, UNKNOWN connect_cb, IntPtr data);
+
+ public static PurpleProxyConnectData ConnectSocks5(IntPtr handle, PurpleProxyInfo gpi, string host, int port, PurpleProxyConnectFunction connect_cb, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_connect_cancel(PurpleProxyConnectData * connect_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_connect_cancel(IntPtr connect_data);
+
+ public static void ConnectCancel(PurpleProxyConnectData connect_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_proxy_connect_cancel_with_handle(void * handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_proxy_connect_cancel_with_handle(IntPtr handle);
+
+ public static void ConnectCancelWithHandle(IntPtr handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Prpl.cs 881501dece6309dc38f5c610ff8b41b18276d74c
+++ libpurple/wrapper/Prpl.cs 881501dece6309dc38f5c610ff8b41b18276d74c
@@ -0,0 +1,351 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Prpl
+ {
+ /*
+ * unsigned int( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN int(UNKNOWN );
+
+ public static unsigned Int( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAttentionType * purple_attention_type_new(char * ulname, char * name, char * inc_desc, char * out_desc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_attention_type_new(string ulname, string name, string inc_desc, string out_desc);
+
+ public static PurpleAttentionType AttentionTypeNew(string ulname, string name, string inc_desc, string out_desc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_attention_type_set_name(PurpleAttentionType * type, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_attention_type_set_name(IntPtr type, string name);
+
+ public static void AttentionTypeSetName(PurpleAttentionType type, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_attention_type_set_incoming_desc(PurpleAttentionType * type, char * desc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_attention_type_set_incoming_desc(IntPtr type, string desc);
+
+ public static void AttentionTypeSetIncomingDesc(PurpleAttentionType type, string desc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_attention_type_set_outgoing_desc(PurpleAttentionType * type, char * desc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_attention_type_set_outgoing_desc(IntPtr type, string desc);
+
+ public static void AttentionTypeSetOutgoingDesc(PurpleAttentionType type, string desc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_attention_type_set_icon_name(PurpleAttentionType * type, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_attention_type_set_icon_name(IntPtr type, string name);
+
+ public static void AttentionTypeSetIconName(PurpleAttentionType type, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_attention_type_set_unlocalized_name(PurpleAttentionType * type, char * ulname)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_attention_type_set_unlocalized_name(IntPtr type, string ulname);
+
+ public static void AttentionTypeSetUnlocalizedName(PurpleAttentionType type, string ulname)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_attention_type_get_name(PurpleAttentionType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_attention_type_get_name(IntPtr type);
+
+ public static string AttentionTypeGetName(PurpleAttentionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_attention_type_get_incoming_desc(PurpleAttentionType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_attention_type_get_incoming_desc(IntPtr type);
+
+ public static string AttentionTypeGetIncomingDesc(PurpleAttentionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_attention_type_get_outgoing_desc(PurpleAttentionType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_attention_type_get_outgoing_desc(IntPtr type);
+
+ public static string AttentionTypeGetOutgoingDesc(PurpleAttentionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_attention_type_get_icon_name(PurpleAttentionType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_attention_type_get_icon_name(IntPtr type);
+
+ public static string AttentionTypeGetIconName(PurpleAttentionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_attention_type_get_unlocalized_name(PurpleAttentionType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_attention_type_get_unlocalized_name(IntPtr type);
+
+ public static string AttentionTypeGetUnlocalizedName(PurpleAttentionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_account_idle(PurpleAccount * account, gboolean idle, time_t idle_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_account_idle(IntPtr account, bool idle, UNKNOWN idle_time);
+
+ public static void GotAccountIdle(PurpleAccount account, bool idle, time_t idle_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_account_login_time(PurpleAccount * account, time_t login_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_account_login_time(IntPtr account, UNKNOWN login_time);
+
+ public static void GotAccountLoginTime(PurpleAccount account, time_t login_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_account_status(PurpleAccount * account, char * status_id, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_account_status(IntPtr account, string status_id, ...);
+
+ public static void GotAccountStatus(PurpleAccount account, string status_id, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_account_actions(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_account_actions(IntPtr account);
+
+ public static void GotAccountActions(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_user_idle(PurpleAccount * account, char * name, gboolean idle, time_t idle_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_user_idle(IntPtr account, string name, bool idle, UNKNOWN idle_time);
+
+ public static void GotUserIdle(PurpleAccount account, string name, bool idle, time_t idle_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_user_login_time(PurpleAccount * account, char * name, time_t login_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_user_login_time(IntPtr account, string name, UNKNOWN login_time);
+
+ public static void GotUserLoginTime(PurpleAccount account, string name, time_t login_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_user_status(PurpleAccount * account, char * name, char * status_id, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_user_status(IntPtr account, string name, string status_id, ...);
+
+ public static void GotUserStatus(PurpleAccount account, string name, string status_id, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_user_status_deactive(PurpleAccount * account, char * name, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_user_status_deactive(IntPtr account, string name, string status_id);
+
+ public static void GotUserStatusDeactive(PurpleAccount account, string name, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_change_account_status(PurpleAccount * account, PurpleStatus * old_status, PurpleStatus * new_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_change_account_status(IntPtr account, IntPtr old_status, IntPtr new_status);
+
+ public static void ChangeAccountStatus(PurpleAccount account, PurpleStatus old_status, PurpleStatus new_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_prpl_get_statuses(PurpleAccount * account, PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_prpl_get_statuses(IntPtr account, IntPtr presence);
+
+ public static GList GetStatuses(PurpleAccount account, PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_send_attention(PurpleConnection * gc, char * who, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_send_attention(IntPtr gc, string who, uint type_code);
+
+ public static void SendAttention(PurpleConnection gc, string who, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_attention(PurpleConnection * gc, char * who, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_attention(IntPtr gc, string who, uint type_code);
+
+ public static void GotAttention(PurpleConnection gc, string who, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_prpl_got_attention_in_chat(PurpleConnection * gc, int id, char * who, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_prpl_got_attention_in_chat(IntPtr gc, int id, string who, uint type_code);
+
+ public static void GotAttentionInChat(PurpleConnection gc, int id, string who, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleMediaCaps purple_prpl_get_media_caps(PurpleAccount * account, char * who)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_prpl_get_media_caps(IntPtr account, string who);
+
+ public static PurpleMediaCaps GetMediaCaps(PurpleAccount account, string who)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_prpl_initiate_media(PurpleAccount * account, char * who, PurpleMediaSessionType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_prpl_initiate_media(IntPtr account, string who, UNKNOWN type);
+
+ public static bool InitiateMedia(PurpleAccount account, string who, PurpleMediaSessionType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePlugin * purple_find_prpl(char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_find_prpl(string id);
+
+ public static PurplePlugin FindPrpl(string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleAccount.cs f30d444cbe85a062d2e4dde8bb47b38498c2b26e
+++ libpurple/wrapper/PurpleAccount.cs f30d444cbe85a062d2e4dde8bb47b38498c2b26e
@@ -0,0 +1,499 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleAccount : UnmanagedWrapper<_PurpleAccount>
+ {
+ public PurpleAccount()
+ {
+ }
+
+ public PurpleAccount(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleAccount)Marshal.PtrToStructure(this.Reference, typeof(_PurpleAccount));
+ }
+
+ public string username
+ {
+ get
+ {
+ return this.Data.username;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.username = value;
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ public string password
+ {
+ get
+ {
+ return this.Data.password;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.password = value;
+ }
+ }
+
+ public string user_info
+ {
+ get
+ {
+ return this.Data.user_info;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.user_info = value;
+ }
+ }
+
+ public string buddy_icon_path
+ {
+ get
+ {
+ return this.Data.buddy_icon_path;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.buddy_icon_path = value;
+ }
+ }
+
+ public bool remember_pass
+ {
+ get
+ {
+ return this.Data.remember_pass;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.remember_pass = value;
+ }
+ }
+
+ public string protocol_id
+ {
+ get
+ {
+ return this.Data.protocol_id;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.protocol_id = value;
+ }
+ }
+
+ public PurpleConnection gc
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool disconnecting
+ {
+ get
+ {
+ return this.Data.disconnecting;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.disconnecting = value;
+ }
+ }
+
+ public GHashTable settings
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable ui_settings
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleProxyInfo proxy_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GSList permit
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GSList deny
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePrivacyType perm_deny
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList status_types
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePresence presence
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleLog system_log
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccountRegistrationCb registration_cb
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr registration_cb_user_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr priv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleAccount
+ {
+ /*
+ * char * username
+ */
+ string username;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ /*
+ * char * password
+ */
+ string password;
+
+ /*
+ * char * user_info
+ */
+ string user_info;
+
+ /*
+ * char * buddy_icon_path
+ */
+ string buddy_icon_path;
+
+ /*
+ * gboolean remember_pass
+ */
+ bool remember_pass;
+
+ /*
+ * char * protocol_id
+ */
+ string protocol_id;
+
+ /*
+ * PurpleConnection * gc
+ */
+ IntPtr gc;
+
+ /*
+ * gboolean disconnecting
+ */
+ bool disconnecting;
+
+ /*
+ * GHashTable * settings
+ */
+ IntPtr settings;
+
+ /*
+ * GHashTable * ui_settings
+ */
+ IntPtr ui_settings;
+
+ /*
+ * PurpleProxyInfo * proxy_info
+ */
+ IntPtr proxy_info;
+
+ /*
+ * GSList * permit
+ */
+ IntPtr permit;
+
+ /*
+ * GSList * deny
+ */
+ IntPtr deny;
+
+ /*
+ * PurplePrivacyType perm_deny
+ */
+ UNKNOWN perm_deny;
+
+ /*
+ * GList * status_types
+ */
+ IntPtr status_types;
+
+ /*
+ * PurplePresence * presence
+ */
+ IntPtr presence;
+
+ /*
+ * PurpleLog * system_log
+ */
+ IntPtr system_log;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * PurpleAccountRegistrationCb registration_cb
+ */
+ UNKNOWN registration_cb;
+
+ /*
+ * void * registration_cb_user_data
+ */
+ IntPtr registration_cb_user_data;
+
+ /*
+ * gpointer priv
+ */
+ IntPtr priv;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleAccountUiOps.cs 116f58485640b0decd2946febbdd8dc8555e81aa
+++ libpurple/wrapper/PurpleAccountUiOps.cs 116f58485640b0decd2946febbdd8dc8555e81aa
@@ -0,0 +1,239 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleAccountUiOps : UnmanagedWrapper<_PurpleAccountUiOps>
+ {
+ public PurpleAccountUiOps()
+ {
+ }
+
+ public PurpleAccountUiOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleAccountUiOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleAccountUiOps));
+ }
+
+ public void notify_added
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void status_changed
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void request_add
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr request_authorize
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void close_account_request
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleAccountUiOps
+ {
+ /*
+ * void (*notify_added)(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message)
+ */
+ void notify_added;
+
+ /*
+ * void (*status_changed)(PurpleAccount * account, PurpleStatus * status)
+ */
+ void status_changed;
+
+ /*
+ * void (*request_add)(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message)
+ */
+ void request_add;
+
+ /*
+ * void * (*request_authorize)(PurpleAccount * account, char * remote_user, char * id, char * alias, char * message, gboolean on_list, PurpleAccountRequestAuthorizationCb authorize_cb, PurpleAccountRequestAuthorizationCb deny_cb, void * user_data)
+ */
+ IntPtr request_authorize;
+
+ /*
+ * void (*close_account_request)(void * ui_handle)
+ */
+ void close_account_request;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleAttentionType.cs 21a5c2915860fc22f69c917d1c5d391b0892418a
+++ libpurple/wrapper/PurpleAttentionType.cs 21a5c2915860fc22f69c917d1c5d391b0892418a
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleAttentionType : UnmanagedWrapper<_PurpleAttentionType>
+ {
+ public PurpleAttentionType()
+ {
+ }
+
+ public PurpleAttentionType(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleAttentionType)Marshal.PtrToStructure(this.Reference, typeof(_PurpleAttentionType));
+ }
+
+ public const char *name
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *incoming_description
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *outgoing_description
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *icon_name
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *unlocalized_name
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr _reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr _reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr _reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleAttentionType
+ {
+ /*
+ * const char *name
+ */
+ UNKNOWN char *name;
+
+ /*
+ * const char *incoming_description
+ */
+ UNKNOWN char *incoming_description;
+
+ /*
+ * const char *outgoing_description
+ */
+ UNKNOWN char *outgoing_description;
+
+ /*
+ * const char *icon_name
+ */
+ UNKNOWN char *icon_name;
+
+ /*
+ * const char *unlocalized_name
+ */
+ UNKNOWN char *unlocalized_name;
+
+ /*
+ * gpointer _reserved2
+ */
+ IntPtr _reserved2;
+
+ /*
+ * gpointer _reserved3
+ */
+ IntPtr _reserved3;
+
+ /*
+ * gpointer _reserved4
+ */
+ IntPtr _reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleBlistNode.cs 2f5cf13875c2ad80380e3b60f14d38f5d7a3d30d
+++ libpurple/wrapper/PurpleBlistNode.cs 2f5cf13875c2ad80380e3b60f14d38f5d7a3d30d
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleBlistNode : UnmanagedWrapper<_PurpleBlistNode>
+ {
+ public PurpleBlistNode()
+ {
+ }
+
+ public PurpleBlistNode(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleBlistNode)Marshal.PtrToStructure(this.Reference, typeof(_PurpleBlistNode));
+ }
+
+ public PurpleBlistNodeType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBlistNode prev
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBlistNode next
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBlistNode parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBlistNode child
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable settings
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBlistNodeFlags flags
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleBlistNode
+ {
+ /*
+ * PurpleBlistNodeType type
+ */
+ UNKNOWN type;
+
+ /*
+ * PurpleBlistNode * prev
+ */
+ IntPtr prev;
+
+ /*
+ * PurpleBlistNode * next
+ */
+ IntPtr next;
+
+ /*
+ * PurpleBlistNode * parent
+ */
+ IntPtr parent;
+
+ /*
+ * PurpleBlistNode * child
+ */
+ IntPtr child;
+
+ /*
+ * GHashTable * settings
+ */
+ IntPtr settings;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * PurpleBlistNodeFlags flags
+ */
+ UNKNOWN flags;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleBlistUiOps.cs 0cac1ede6b13ef2b4ac9591e99b02cbd7f9aa465
+++ libpurple/wrapper/PurpleBlistUiOps.cs 0cac1ede6b13ef2b4ac9591e99b02cbd7f9aa465
@@ -0,0 +1,339 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleBlistUiOps : UnmanagedWrapper<_PurpleBlistUiOps>
+ {
+ public PurpleBlistUiOps()
+ {
+ }
+
+ public PurpleBlistUiOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleBlistUiOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleBlistUiOps));
+ }
+
+ public void new_list
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void new_node
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void show
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void update
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void remove
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void destroy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_visible
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void request_add_buddy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void request_add_chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void request_add_group
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleBlistUiOps
+ {
+ /*
+ * void (*new_list)(PurpleBuddyList * list)
+ */
+ void new_list;
+
+ /*
+ * void (*new_node)(PurpleBlistNode * node)
+ */
+ void new_node;
+
+ /*
+ * void (*show)(PurpleBuddyList * list)
+ */
+ void show;
+
+ /*
+ * void (*update)(PurpleBuddyList * list, PurpleBlistNode * node)
+ */
+ void update;
+
+ /*
+ * void (*remove)(PurpleBuddyList * list, PurpleBlistNode * node)
+ */
+ void remove;
+
+ /*
+ * void (*destroy)(PurpleBuddyList * list)
+ */
+ void destroy;
+
+ /*
+ * void (*set_visible)(PurpleBuddyList * list, gboolean show)
+ */
+ void set_visible;
+
+ /*
+ * void (*request_add_buddy)(PurpleAccount * account, char * username, char * group, char * alias)
+ */
+ void request_add_buddy;
+
+ /*
+ * void (*request_add_chat)(PurpleAccount * account, PurpleGroup * group, char * alias, char * name)
+ */
+ void request_add_chat;
+
+ /*
+ * void (*request_add_group)()
+ */
+ void request_add_group;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleBuddy.cs 9d8ce36c1a71a471396b8cdb2493b02756db4157
+++ libpurple/wrapper/PurpleBuddy.cs 9d8ce36c1a71a471396b8cdb2493b02756db4157
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleBuddy : UnmanagedWrapper<_PurpleBuddy>
+ {
+ public PurpleBuddy()
+ {
+ }
+
+ public PurpleBuddy(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleBuddy)Marshal.PtrToStructure(this.Reference, typeof(_PurpleBuddy));
+ }
+
+ public PurpleBlistNode node
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ public string server_alias
+ {
+ get
+ {
+ return this.Data.server_alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.server_alias = value;
+ }
+ }
+
+ public IntPtr proto_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBuddyIcon icon
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePresence presence
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleBuddy
+ {
+ /*
+ * PurpleBlistNode node
+ */
+ UNKNOWN node;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ /*
+ * char * server_alias
+ */
+ string server_alias;
+
+ /*
+ * void * proto_data
+ */
+ IntPtr proto_data;
+
+ /*
+ * PurpleBuddyIcon * icon
+ */
+ IntPtr icon;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * PurplePresence * presence
+ */
+ IntPtr presence;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleBuddyIconSpec.cs 255c5da9f53d8be99ad1c55a1efac6f8672cb788
+++ libpurple/wrapper/PurpleBuddyIconSpec.cs 255c5da9f53d8be99ad1c55a1efac6f8672cb788
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleBuddyIconSpec : UnmanagedWrapper<_PurpleBuddyIconSpec>
+ {
+ public PurpleBuddyIconSpec()
+ {
+ }
+
+ public PurpleBuddyIconSpec(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleBuddyIconSpec)Marshal.PtrToStructure(this.Reference, typeof(_PurpleBuddyIconSpec));
+ }
+
+ public string format
+ {
+ get
+ {
+ return this.Data.format;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.format = value;
+ }
+ }
+
+ public int min_width
+ {
+ get
+ {
+ return this.Data.min_width;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.min_width = value;
+ }
+ }
+
+ public int min_height
+ {
+ get
+ {
+ return this.Data.min_height;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.min_height = value;
+ }
+ }
+
+ public int max_width
+ {
+ get
+ {
+ return this.Data.max_width;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.max_width = value;
+ }
+ }
+
+ public int max_height
+ {
+ get
+ {
+ return this.Data.max_height;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.max_height = value;
+ }
+ }
+
+ public size_t max_filesize
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleIconScaleRules scale_rules
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleBuddyIconSpec
+ {
+ /*
+ * char * format
+ */
+ string format;
+
+ /*
+ * int min_width
+ */
+ int min_width;
+
+ /*
+ * int min_height
+ */
+ int min_height;
+
+ /*
+ * int max_width
+ */
+ int max_width;
+
+ /*
+ * int max_height
+ */
+ int max_height;
+
+ /*
+ * size_t max_filesize
+ */
+ UNKNOWN max_filesize;
+
+ /*
+ * PurpleIconScaleRules scale_rules
+ */
+ UNKNOWN scale_rules;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleBuddyList.cs d7d4f8b585d66d545f80a4e1f6e5b99c8dd0b4a6
+++ libpurple/wrapper/PurpleBuddyList.cs d7d4f8b585d66d545f80a4e1f6e5b99c8dd0b4a6
@@ -0,0 +1,119 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleBuddyList : UnmanagedWrapper<_PurpleBuddyList>
+ {
+ public PurpleBuddyList()
+ {
+ }
+
+ public PurpleBuddyList(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleBuddyList)Marshal.PtrToStructure(this.Reference, typeof(_PurpleBuddyList));
+ }
+
+ public PurpleBlistNode root
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable buddies
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleBuddyList
+ {
+ /*
+ * PurpleBlistNode * root
+ */
+ IntPtr root;
+
+ /*
+ * GHashTable * buddies
+ */
+ IntPtr buddies;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCertificate.cs e717b82338cbabe712e7694d9af148befc65404b
+++ libpurple/wrapper/PurpleCertificate.cs e717b82338cbabe712e7694d9af148befc65404b
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCertificate : UnmanagedWrapper<_PurpleCertificate>
+ {
+ public PurpleCertificate()
+ {
+ }
+
+ public PurpleCertificate(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCertificate)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCertificate));
+ }
+
+ public PurpleCertificateScheme scheme
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCertificate
+ {
+ /*
+ * PurpleCertificateScheme * scheme
+ */
+ IntPtr scheme;
+
+ /*
+ * gpointer data
+ */
+ IntPtr data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCertificatePool.cs 7c12fde31e228be96a7e50b39f2a928b5c97f397
+++ libpurple/wrapper/PurpleCertificatePool.cs 7c12fde31e228be96a7e50b39f2a928b5c97f397
@@ -0,0 +1,359 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCertificatePool : UnmanagedWrapper<_PurpleCertificatePool>
+ {
+ public PurpleCertificatePool()
+ {
+ }
+
+ public PurpleCertificatePool(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCertificatePool)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCertificatePool));
+ }
+
+ public string scheme_name
+ {
+ get
+ {
+ return this.Data.scheme_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.scheme_name = value;
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string fullname
+ {
+ get
+ {
+ return this.Data.fullname;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.fullname = value;
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool (* init)(void)
+ {
+ get
+ {
+ return this.Data.(* init)(void);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* init)(void) = value;
+ }
+ }
+
+ public void (* uninit)(void)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool (* cert_in_pool)(const gchar *id)
+ {
+ get
+ {
+ return this.Data.(* cert_in_pool)(const gchar *id);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* cert_in_pool)(const gchar *id) = value;
+ }
+ }
+
+ public PurpleCertificate (* get_cert)(const gchar *id)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool (* put_cert)(const gchar *id, PurpleCertificate *crt)
+ {
+ get
+ {
+ return this.Data.(* put_cert)(const gchar *id, PurpleCertificate *crt);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* put_cert)(const gchar *id, PurpleCertificate *crt) = value;
+ }
+ }
+
+ public bool (* delete_cert)(const gchar *id)
+ {
+ get
+ {
+ return this.Data.(* delete_cert)(const gchar *id);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* delete_cert)(const gchar *id) = value;
+ }
+ }
+
+ public GList (* get_idlist)(void)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCertificatePool
+ {
+ /*
+ * gchar * scheme_name
+ */
+ string scheme_name;
+
+ /*
+ * gchar * name
+ */
+ string name;
+
+ /*
+ * gchar * fullname
+ */
+ string fullname;
+
+ /*
+ * gpointer data
+ */
+ IntPtr data;
+
+ /*
+ * gboolean (* init)(void)
+ */
+ bool (* init)(void);
+
+ /*
+ * void (* uninit)(void)
+ */
+ void (* uninit)(void);
+
+ /*
+ * gboolean (* cert_in_pool)(const gchar *id)
+ */
+ bool (* cert_in_pool)(const gchar *id);
+
+ /*
+ * PurpleCertificate * (* get_cert)(const gchar *id)
+ */
+ IntPtr (* get_cert)(const gchar *id);
+
+ /*
+ * gboolean (* put_cert)(const gchar *id, PurpleCertificate *crt)
+ */
+ bool (* put_cert)(const gchar *id, PurpleCertificate *crt);
+
+ /*
+ * gboolean (* delete_cert)(const gchar *id)
+ */
+ bool (* delete_cert)(const gchar *id);
+
+ /*
+ * GList * (* get_idlist)(void)
+ */
+ IntPtr (* get_idlist)(void);
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCertificateScheme.cs 2faa1720fc4896dcde80c074b50b3c77de589b4a
+++ libpurple/wrapper/PurpleCertificateScheme.cs 2faa1720fc4896dcde80c074b50b3c77de589b4a
@@ -0,0 +1,399 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCertificateScheme : UnmanagedWrapper<_PurpleCertificateScheme>
+ {
+ public PurpleCertificateScheme()
+ {
+ }
+
+ public PurpleCertificateScheme(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCertificateScheme)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCertificateScheme));
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data. name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data. name = value;
+ }
+ }
+
+ public string fullname
+ {
+ get
+ {
+ return this.Data. fullname;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data. fullname = value;
+ }
+ }
+
+ public PurpleCertificate (* import_certificate)(const gchar * filename)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool (* export_certificate)(const gchar *filename, PurpleCertificate *crt)
+ {
+ get
+ {
+ return this.Data.(* export_certificate)(const gchar *filename, PurpleCertificate *crt);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* export_certificate)(const gchar *filename, PurpleCertificate *crt) = value;
+ }
+ }
+
+ public PurpleCertificate (* copy_certificate)(PurpleCertificate *crt)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void (* destroy_certificate)(PurpleCertificate * crt)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool signed_by
+ {
+ get
+ {
+ return this.Data.signed_by;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.signed_by = value;
+ }
+ }
+
+ public GByteArray (* get_fingerprint_sha1)(PurpleCertificate *crt)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string (* get_unique_id)(PurpleCertificate *crt)
+ {
+ get
+ {
+ return this.Data. (* get_unique_id)(PurpleCertificate *crt);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data. (* get_unique_id)(PurpleCertificate *crt) = value;
+ }
+ }
+
+ public string (* get_issuer_unique_id)(PurpleCertificate *crt)
+ {
+ get
+ {
+ return this.Data. (* get_issuer_unique_id)(PurpleCertificate *crt);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data. (* get_issuer_unique_id)(PurpleCertificate *crt) = value;
+ }
+ }
+
+ public string (* get_subject_name)(PurpleCertificate *crt)
+ {
+ get
+ {
+ return this.Data. (* get_subject_name)(PurpleCertificate *crt);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data. (* get_subject_name)(PurpleCertificate *crt) = value;
+ }
+ }
+
+ public bool (* check_subject_name)(PurpleCertificate *crt, const gchar *name)
+ {
+ get
+ {
+ return this.Data.(* check_subject_name)(PurpleCertificate *crt, const gchar *name);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* check_subject_name)(PurpleCertificate *crt, const gchar *name) = value;
+ }
+ }
+
+ public bool (* get_times)(PurpleCertificate *crt, time_t *activation, time_t *expiration)
+ {
+ get
+ {
+ return this.Data.(* get_times)(PurpleCertificate *crt, time_t *activation, time_t *expiration);
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.(* get_times)(PurpleCertificate *crt, time_t *activation, time_t *expiration) = value;
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCertificateScheme
+ {
+ /*
+ * gchar * name
+ */
+ string name;
+
+ /*
+ * gchar * fullname
+ */
+ string fullname;
+
+ /*
+ * PurpleCertificate * (* import_certificate)(const gchar * filename)
+ */
+ IntPtr (* import_certificate)(const gchar * filename);
+
+ /*
+ * gboolean (* export_certificate)(const gchar *filename, PurpleCertificate *crt)
+ */
+ bool (* export_certificate)(const gchar *filename, PurpleCertificate *crt);
+
+ /*
+ * PurpleCertificate * (* copy_certificate)(PurpleCertificate *crt)
+ */
+ IntPtr (* copy_certificate)(PurpleCertificate *crt);
+
+ /*
+ * void (* destroy_certificate)(PurpleCertificate * crt)
+ */
+ void (* destroy_certificate)(PurpleCertificate * crt);
+
+ /*
+ * gboolean (*signed_by)(PurpleCertificate * crt, PurpleCertificate * issuer)
+ */
+ bool signed_by;
+
+ /*
+ * GByteArray * (* get_fingerprint_sha1)(PurpleCertificate *crt)
+ */
+ IntPtr (* get_fingerprint_sha1)(PurpleCertificate *crt);
+
+ /*
+ * gchar * (* get_unique_id)(PurpleCertificate *crt)
+ */
+ string (* get_unique_id)(PurpleCertificate *crt);
+
+ /*
+ * gchar * (* get_issuer_unique_id)(PurpleCertificate *crt)
+ */
+ string (* get_issuer_unique_id)(PurpleCertificate *crt);
+
+ /*
+ * gchar * (* get_subject_name)(PurpleCertificate *crt)
+ */
+ string (* get_subject_name)(PurpleCertificate *crt);
+
+ /*
+ * gboolean (* check_subject_name)(PurpleCertificate *crt, const gchar *name)
+ */
+ bool (* check_subject_name)(PurpleCertificate *crt, const gchar *name);
+
+ /*
+ * gboolean (* get_times)(PurpleCertificate *crt, time_t *activation, time_t *expiration)
+ */
+ bool (* get_times)(PurpleCertificate *crt, time_t *activation, time_t *expiration);
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCertificateVerificationRequest.cs d85b01e3ad4c45d889fee9e718a0e7ab64b8bedc
+++ libpurple/wrapper/PurpleCertificateVerificationRequest.cs d85b01e3ad4c45d889fee9e718a0e7ab64b8bedc
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCertificateVerificationRequest : UnmanagedWrapper<_PurpleCertificateVerificationRequest>
+ {
+ public PurpleCertificateVerificationRequest()
+ {
+ }
+
+ public PurpleCertificateVerificationRequest(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCertificateVerificationRequest)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCertificateVerificationRequest));
+ }
+
+ public PurpleCertificateVerifier verifier
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleCertificateScheme scheme
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string subject_name
+ {
+ get
+ {
+ return this.Data.subject_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.subject_name = value;
+ }
+ }
+
+ public GList cert_chain
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleCertificateVerifiedCallback cb
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr cb_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCertificateVerificationRequest
+ {
+ /*
+ * PurpleCertificateVerifier * verifier
+ */
+ IntPtr verifier;
+
+ /*
+ * PurpleCertificateScheme * scheme
+ */
+ IntPtr scheme;
+
+ /*
+ * gchar * subject_name
+ */
+ string subject_name;
+
+ /*
+ * GList * cert_chain
+ */
+ IntPtr cert_chain;
+
+ /*
+ * gpointer data
+ */
+ IntPtr data;
+
+ /*
+ * PurpleCertificateVerifiedCallback cb
+ */
+ UNKNOWN cb;
+
+ /*
+ * gpointer cb_data
+ */
+ IntPtr cb_data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCertificateVerifier.cs 73640d112fa595880217d516429d2dd5dbca8c93
+++ libpurple/wrapper/PurpleCertificateVerifier.cs 73640d112fa595880217d516429d2dd5dbca8c93
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCertificateVerifier : UnmanagedWrapper<_PurpleCertificateVerifier>
+ {
+ public PurpleCertificateVerifier()
+ {
+ }
+
+ public PurpleCertificateVerifier(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCertificateVerifier)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCertificateVerifier));
+ }
+
+ public string scheme_name
+ {
+ get
+ {
+ return this.Data.scheme_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.scheme_name = value;
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public void (* start_verification)(PurpleCertificateVerificationRequest *vrq)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void (* destroy_request)(PurpleCertificateVerificationRequest *vrq)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCertificateVerifier
+ {
+ /*
+ * gchar * scheme_name
+ */
+ string scheme_name;
+
+ /*
+ * gchar * name
+ */
+ string name;
+
+ /*
+ * void (* start_verification)(PurpleCertificateVerificationRequest *vrq)
+ */
+ void (* start_verification)(PurpleCertificateVerificationRequest *vrq);
+
+ /*
+ * void (* destroy_request)(PurpleCertificateVerificationRequest *vrq)
+ */
+ void (* destroy_request)(PurpleCertificateVerificationRequest *vrq);
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleChat.cs 3fdefe40e788b383dec23cb7c1b6dba0cdaece1e
+++ libpurple/wrapper/PurpleChat.cs 3fdefe40e788b383dec23cb7c1b6dba0cdaece1e
@@ -0,0 +1,139 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleChat : UnmanagedWrapper<_PurpleChat>
+ {
+ public PurpleChat()
+ {
+ }
+
+ public PurpleChat(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleChat)Marshal.PtrToStructure(this.Reference, typeof(_PurpleChat));
+ }
+
+ public PurpleBlistNode node
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ public GHashTable components
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleChat
+ {
+ /*
+ * PurpleBlistNode node
+ */
+ UNKNOWN node;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ /*
+ * GHashTable * components
+ */
+ IntPtr components;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleCipherOps.cs dfbdf8790dd1757d66e8c32faaacf19ebfaf1a63
+++ libpurple/wrapper/PurpleCipherOps.cs dfbdf8790dd1757d66e8c32faaacf19ebfaf1a63
@@ -0,0 +1,419 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleCipherOps : UnmanagedWrapper<_PurpleCipherOps>
+ {
+ public PurpleCipherOps()
+ {
+ }
+
+ public PurpleCipherOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleCipherOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleCipherOps));
+ }
+
+ public void set_option
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr get_option
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void init
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void reset
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void uninit
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_iv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void append
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool digest
+ {
+ get
+ {
+ return this.Data.digest;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.digest = value;
+ }
+ }
+
+ public int encrypt
+ {
+ get
+ {
+ return this.Data.encrypt;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.encrypt = value;
+ }
+ }
+
+ public int decrypt
+ {
+ get
+ {
+ return this.Data.decrypt;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.decrypt = value;
+ }
+ }
+
+ public void set_salt
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public size_t get_salt_size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_key
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public size_t get_key_size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_batch_mode
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleCipherBatchMode get_batch_mode
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public size_t get_block_size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_key_with_len
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleCipherOps
+ {
+ /*
+ * void (*set_option)(PurpleCipherContext * context, gchar * name, void * value)
+ */
+ void set_option;
+
+ /*
+ * void * (*get_option)(PurpleCipherContext * context, gchar * name)
+ */
+ IntPtr get_option;
+
+ /*
+ * void (*init)(PurpleCipherContext * context, void * extra)
+ */
+ void init;
+
+ /*
+ * void (*reset)(PurpleCipherContext * context, void * extra)
+ */
+ void reset;
+
+ /*
+ * void (*uninit)(PurpleCipherContext * context)
+ */
+ void uninit;
+
+ /*
+ * void (*set_iv)(PurpleCipherContext * context, guchar * iv, size_t len)
+ */
+ void set_iv;
+
+ /*
+ * void (*append)(PurpleCipherContext * context, guchar * data, size_t len)
+ */
+ void append;
+
+ /*
+ * gboolean (*digest)(PurpleCipherContext * context, size_t in_len, guchar digest, size_t * out_len)
+ */
+ bool digest;
+
+ /*
+ * int (*encrypt)(PurpleCipherContext * context, guchar data, size_t len, guchar output, size_t * outlen)
+ */
+ int encrypt;
+
+ /*
+ * int (*decrypt)(PurpleCipherContext * context, guchar data, size_t len, guchar output, size_t * outlen)
+ */
+ int decrypt;
+
+ /*
+ * void (*set_salt)(PurpleCipherContext * context, guchar * salt)
+ */
+ void set_salt;
+
+ /*
+ * size_t (*get_salt_size)(PurpleCipherContext * context)
+ */
+ UNKNOWN get_salt_size;
+
+ /*
+ * void (*set_key)(PurpleCipherContext * context, guchar * key)
+ */
+ void set_key;
+
+ /*
+ * size_t (*get_key_size)(PurpleCipherContext * context)
+ */
+ UNKNOWN get_key_size;
+
+ /*
+ * void (*set_batch_mode)(PurpleCipherContext * context, PurpleCipherBatchMode mode)
+ */
+ void set_batch_mode;
+
+ /*
+ * PurpleCipherBatchMode (*get_batch_mode)(PurpleCipherContext * context)
+ */
+ UNKNOWN get_batch_mode;
+
+ /*
+ * size_t (*get_block_size)(PurpleCipherContext * context)
+ */
+ UNKNOWN get_block_size;
+
+ /*
+ * void (*set_key_with_len)(PurpleCipherContext * context, guchar * key, size_t len)
+ */
+ void set_key_with_len;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleClient.cs c1cdf84dae5d7e9377fff26a9d43f6f1fd942cfe
+++ libpurple/wrapper/PurpleClient.cs c1cdf84dae5d7e9377fff26a9d43f6f1fd942cfe
@@ -0,0 +1,54 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleClient
+ {
+ /*
+ * void purple_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConnection.cs e922961b95a6fa9c7f1649cbcd4afbbd14ec6c18
+++ libpurple/wrapper/PurpleConnection.cs e922961b95a6fa9c7f1649cbcd4afbbd14ec6c18
@@ -0,0 +1,319 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConnection : UnmanagedWrapper<_PurpleConnection>
+ {
+ public PurpleConnection()
+ {
+ }
+
+ public PurpleConnection(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConnection)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConnection));
+ }
+
+ public PurplePlugin prpl
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConnectionFlags flags
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConnectionState state
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string password
+ {
+ get
+ {
+ return this.Data.password;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.password = value;
+ }
+ }
+
+ public int inpa
+ {
+ get
+ {
+ return this.Data.inpa;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.inpa = value;
+ }
+ }
+
+ public GSList buddy_chats
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr proto_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string display_name
+ {
+ get
+ {
+ return this.Data.display_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.display_name = value;
+ }
+ }
+
+ public uint keepalive
+ {
+ get
+ {
+ return this.Data.keepalive;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.keepalive = value;
+ }
+ }
+
+ public bool wants_to_die
+ {
+ get
+ {
+ return this.Data.wants_to_die;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.wants_to_die = value;
+ }
+ }
+
+ public uint disconnect_timeout
+ {
+ get
+ {
+ return this.Data.disconnect_timeout;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.disconnect_timeout = value;
+ }
+ }
+
+ public time_t last_received
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConnection
+ {
+ /*
+ * PurplePlugin * prpl
+ */
+ IntPtr prpl;
+
+ /*
+ * PurpleConnectionFlags flags
+ */
+ UNKNOWN flags;
+
+ /*
+ * PurpleConnectionState state
+ */
+ UNKNOWN state;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * char * password
+ */
+ string password;
+
+ /*
+ * int inpa
+ */
+ int inpa;
+
+ /*
+ * GSList * buddy_chats
+ */
+ IntPtr buddy_chats;
+
+ /*
+ * void * proto_data
+ */
+ IntPtr proto_data;
+
+ /*
+ * char * display_name
+ */
+ string display_name;
+
+ /*
+ * guint keepalive
+ */
+ uint keepalive;
+
+ /*
+ * gboolean wants_to_die
+ */
+ bool wants_to_die;
+
+ /*
+ * guint disconnect_timeout
+ */
+ uint disconnect_timeout;
+
+ /*
+ * time_t last_received
+ */
+ UNKNOWN last_received;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleContact.cs 66ba1bb0b1d8006a3dc9cf06aede310f943758eb
+++ libpurple/wrapper/PurpleContact.cs 66ba1bb0b1d8006a3dc9cf06aede310f943758eb
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleContact : UnmanagedWrapper<_PurpleContact>
+ {
+ public PurpleContact()
+ {
+ }
+
+ public PurpleContact(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleContact)Marshal.PtrToStructure(this.Reference, typeof(_PurpleContact));
+ }
+
+ public PurpleBlistNode node
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ public int totalsize
+ {
+ get
+ {
+ return this.Data.totalsize;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.totalsize = value;
+ }
+ }
+
+ public int currentsize
+ {
+ get
+ {
+ return this.Data.currentsize;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.currentsize = value;
+ }
+ }
+
+ public int online
+ {
+ get
+ {
+ return this.Data.online;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.online = value;
+ }
+ }
+
+ public PurpleBuddy priority
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool priority_valid
+ {
+ get
+ {
+ return this.Data.priority_valid;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.priority_valid = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleContact
+ {
+ /*
+ * PurpleBlistNode node
+ */
+ UNKNOWN node;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ /*
+ * int totalsize
+ */
+ int totalsize;
+
+ /*
+ * int currentsize
+ */
+ int currentsize;
+
+ /*
+ * int online
+ */
+ int online;
+
+ /*
+ * PurpleBuddy * priority
+ */
+ IntPtr priority;
+
+ /*
+ * gboolean priority_valid
+ */
+ bool priority_valid;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConvChat.cs d2f7eb228a16735d1c446f4a3bd338b2dda27e35
+++ libpurple/wrapper/PurpleConvChat.cs d2f7eb228a16735d1c446f4a3bd338b2dda27e35
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConvChat : UnmanagedWrapper<_PurpleConvChat>
+ {
+ public PurpleConvChat()
+ {
+ }
+
+ public PurpleConvChat(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConvChat)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConvChat));
+ }
+
+ public PurpleConversation conv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList in_room
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList ignored
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public char who
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public char topic
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int id
+ {
+ get
+ {
+ return this.Data.id;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.id = value;
+ }
+ }
+
+ public string nick
+ {
+ get
+ {
+ return this.Data.nick;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.nick = value;
+ }
+ }
+
+ public bool left
+ {
+ get
+ {
+ return this.Data.left;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.left = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConvChat
+ {
+ /*
+ * PurpleConversation * conv
+ */
+ IntPtr conv;
+
+ /*
+ * GList * in_room
+ */
+ IntPtr in_room;
+
+ /*
+ * GList * ignored
+ */
+ IntPtr ignored;
+
+ /*
+ * char * who
+ */
+ IntPtr who;
+
+ /*
+ * char * topic
+ */
+ IntPtr topic;
+
+ /*
+ * int id
+ */
+ int id;
+
+ /*
+ * char * nick
+ */
+ string nick;
+
+ /*
+ * gboolean left
+ */
+ bool left;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConvChatBuddy.cs b39d3f662b398221d4b0a0c43144162f4d5b326a
+++ libpurple/wrapper/PurpleConvChatBuddy.cs b39d3f662b398221d4b0a0c43144162f4d5b326a
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConvChatBuddy : UnmanagedWrapper<_PurpleConvChatBuddy>
+ {
+ public PurpleConvChatBuddy()
+ {
+ }
+
+ public PurpleConvChatBuddy(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConvChatBuddy)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConvChatBuddy));
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ public string alias_key
+ {
+ get
+ {
+ return this.Data.alias_key;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias_key = value;
+ }
+ }
+
+ public bool buddy
+ {
+ get
+ {
+ return this.Data.buddy;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.buddy = value;
+ }
+ }
+
+ public PurpleConvChatBuddyFlags flags
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConvChatBuddy
+ {
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ /*
+ * char * alias_key
+ */
+ string alias_key;
+
+ /*
+ * gboolean buddy
+ */
+ bool buddy;
+
+ /*
+ * PurpleConvChatBuddyFlags flags
+ */
+ UNKNOWN flags;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConvIm.cs 1867ff35ee88c963fab8287bb239e9bbb888809f
+++ libpurple/wrapper/PurpleConvIm.cs 1867ff35ee88c963fab8287bb239e9bbb888809f
@@ -0,0 +1,179 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConvIm : UnmanagedWrapper<_PurpleConvIm>
+ {
+ public PurpleConvIm()
+ {
+ }
+
+ public PurpleConvIm(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConvIm)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConvIm));
+ }
+
+ public PurpleConversation conv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleTypingState typing_state
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public uint typing_timeout
+ {
+ get
+ {
+ return this.Data.typing_timeout;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.typing_timeout = value;
+ }
+ }
+
+ public time_t type_again
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public uint send_typed_timeout
+ {
+ get
+ {
+ return this.Data.send_typed_timeout;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.send_typed_timeout = value;
+ }
+ }
+
+ public PurpleBuddyIcon icon
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConvIm
+ {
+ /*
+ * PurpleConversation * conv
+ */
+ IntPtr conv;
+
+ /*
+ * PurpleTypingState typing_state
+ */
+ UNKNOWN typing_state;
+
+ /*
+ * guint typing_timeout
+ */
+ uint typing_timeout;
+
+ /*
+ * time_t type_again
+ */
+ UNKNOWN type_again;
+
+ /*
+ * guint send_typed_timeout
+ */
+ uint send_typed_timeout;
+
+ /*
+ * PurpleBuddyIcon * icon
+ */
+ IntPtr icon;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConvMessage.cs 13c7a00605eea942022941986eb3cf57e603b6f3
+++ libpurple/wrapper/PurpleConvMessage.cs 13c7a00605eea942022941986eb3cf57e603b6f3
@@ -0,0 +1,179 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConvMessage : UnmanagedWrapper<_PurpleConvMessage>
+ {
+ public PurpleConvMessage()
+ {
+ }
+
+ public PurpleConvMessage(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConvMessage)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConvMessage));
+ }
+
+ public string who
+ {
+ get
+ {
+ return this.Data.who;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.who = value;
+ }
+ }
+
+ public string what
+ {
+ get
+ {
+ return this.Data.what;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.what = value;
+ }
+ }
+
+ public PurpleMessageFlags flags
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public time_t when
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConversation conv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string alias
+ {
+ get
+ {
+ return this.Data.alias;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.alias = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConvMessage
+ {
+ /*
+ * char * who
+ */
+ string who;
+
+ /*
+ * char * what
+ */
+ string what;
+
+ /*
+ * PurpleMessageFlags flags
+ */
+ UNKNOWN flags;
+
+ /*
+ * time_t when
+ */
+ UNKNOWN when;
+
+ /*
+ * PurpleConversation * conv
+ */
+ IntPtr conv;
+
+ /*
+ * char * alias
+ */
+ string alias;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConversation.cs cf27ac6b37d0ee0ed575ef2005a899dc445b6859
+++ libpurple/wrapper/PurpleConversation.cs cf27ac6b37d0ee0ed575ef2005a899dc445b6859
@@ -0,0 +1,342 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConversation : UnmanagedWrapper<_PurpleConversation>
+ {
+ public PurpleConversation()
+ {
+ }
+
+ public PurpleConversation(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConversation)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConversation));
+ }
+
+ public PurpleConversationType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string title
+ {
+ get
+ {
+ return this.Data.title;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.title = value;
+ }
+ }
+
+ public bool logging
+ {
+ get
+ {
+ return this.Data.logging;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.logging = value;
+ }
+ }
+
+ public GList logs
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public union {
+ PurpleConvIm *im
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConvChat chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr misc
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConversationUiOps ui_ops
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConnectionFlags features
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList message_history
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConversation
+ {
+ /*
+ * PurpleConversationType type
+ */
+ UNKNOWN type;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * char * title
+ */
+ string title;
+
+ /*
+ * gboolean logging
+ */
+ bool logging;
+
+ /*
+ * GList * logs
+ */
+ IntPtr logs;
+
+ /*
+ * union {
+ PurpleConvIm *im
+ */
+ UNKNOWN {
+ PurpleConvIm *im;
+
+ /*
+ * PurpleConvChat * chat
+ */
+ IntPtr chat;
+
+ /*
+ * void * misc
+ */
+ IntPtr misc;
+
+ /*
+ * PurpleConversationUiOps * ui_ops
+ */
+ IntPtr ui_ops;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * GHashTable * data
+ */
+ IntPtr data;
+
+ /*
+ * PurpleConnectionFlags features
+ */
+ UNKNOWN features;
+
+ /*
+ * GList * message_history
+ */
+ IntPtr message_history;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleConversationUiOps.cs 69112eb4a0ceb5bd549fa42828c211e484e25fb9
+++ libpurple/wrapper/PurpleConversationUiOps.cs 69112eb4a0ceb5bd549fa42828c211e484e25fb9
@@ -0,0 +1,439 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleConversationUiOps : UnmanagedWrapper<_PurpleConversationUiOps>
+ {
+ public PurpleConversationUiOps()
+ {
+ }
+
+ public PurpleConversationUiOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleConversationUiOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleConversationUiOps));
+ }
+
+ public void create_conversation
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void destroy_conversation
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void write_chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void write_im
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void write_conv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_add_users
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_rename_user
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_remove_users
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_update_user
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void present
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool has_focus
+ {
+ get
+ {
+ return this.Data.has_focus;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.has_focus = value;
+ }
+ }
+
+ public bool custom_smiley_add
+ {
+ get
+ {
+ return this.Data.custom_smiley_add;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.custom_smiley_add = value;
+ }
+ }
+
+ public void custom_smiley_write
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void custom_smiley_close
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void send_confirm
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleConversationUiOps
+ {
+ /*
+ * void (*create_conversation)(PurpleConversation * conv)
+ */
+ void create_conversation;
+
+ /*
+ * void (*destroy_conversation)(PurpleConversation * conv)
+ */
+ void destroy_conversation;
+
+ /*
+ * void (*write_chat)(PurpleConversation * conv, char * who, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ void write_chat;
+
+ /*
+ * void (*write_im)(PurpleConversation * conv, char * who, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ void write_im;
+
+ /*
+ * void (*write_conv)(PurpleConversation * conv, char * name, char * alias, char * message, PurpleMessageFlags flags, time_t mtime)
+ */
+ void write_conv;
+
+ /*
+ * void (*chat_add_users)(PurpleConversation * conv, GList * cbuddies, gboolean new_arrivals)
+ */
+ void chat_add_users;
+
+ /*
+ * void (*chat_rename_user)(PurpleConversation * conv, char * old_name, char * new_name, char * new_alias)
+ */
+ void chat_rename_user;
+
+ /*
+ * void (*chat_remove_users)(PurpleConversation * conv, GList * users)
+ */
+ void chat_remove_users;
+
+ /*
+ * void (*chat_update_user)(PurpleConversation * conv, char * user)
+ */
+ void chat_update_user;
+
+ /*
+ * void (*present)(PurpleConversation * conv)
+ */
+ void present;
+
+ /*
+ * gboolean (*has_focus)(PurpleConversation * conv)
+ */
+ bool has_focus;
+
+ /*
+ * gboolean (*custom_smiley_add)(PurpleConversation * conv, char * smile, gboolean remote)
+ */
+ bool custom_smiley_add;
+
+ /*
+ * void (*custom_smiley_write)(PurpleConversation * conv, char * smile, guchar * data, gsize size)
+ */
+ void custom_smiley_write;
+
+ /*
+ * void (*custom_smiley_close)(PurpleConversation * conv, char * smile)
+ */
+ void custom_smiley_close;
+
+ /*
+ * void (*send_confirm)(PurpleConversation * conv, char * message)
+ */
+ void send_confirm;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleEventLoopUiOps.cs 47c20a415a683ca8d8e93508faf7c4229cb0e5b5
+++ libpurple/wrapper/PurpleEventLoopUiOps.cs 47c20a415a683ca8d8e93508faf7c4229cb0e5b5
@@ -0,0 +1,239 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleEventLoopUiOps : UnmanagedWrapper<_PurpleEventLoopUiOps>
+ {
+ public PurpleEventLoopUiOps()
+ {
+ }
+
+ public PurpleEventLoopUiOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleEventLoopUiOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleEventLoopUiOps));
+ }
+
+ public uint timeout_add
+ {
+ get
+ {
+ return this.Data.timeout_add;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.timeout_add = value;
+ }
+ }
+
+ public bool timeout_remove
+ {
+ get
+ {
+ return this.Data.timeout_remove;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.timeout_remove = value;
+ }
+ }
+
+ public uint input_add
+ {
+ get
+ {
+ return this.Data.input_add;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.input_add = value;
+ }
+ }
+
+ public bool input_remove
+ {
+ get
+ {
+ return this.Data.input_remove;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.input_remove = value;
+ }
+ }
+
+ public int input_get_error
+ {
+ get
+ {
+ return this.Data.input_get_error;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.input_get_error = value;
+ }
+ }
+
+ public uint timeout_add_seconds
+ {
+ get
+ {
+ return this.Data.timeout_add_seconds;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.timeout_add_seconds = value;
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleEventLoopUiOps
+ {
+ /*
+ * guint (*timeout_add)(guint interval, GSourceFunc function, gpointer data)
+ */
+ uint timeout_add;
+
+ /*
+ * gboolean (*timeout_remove)(guint handle)
+ */
+ bool timeout_remove;
+
+ /*
+ * guint (*input_add)(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer user_data)
+ */
+ uint input_add;
+
+ /*
+ * gboolean (*input_remove)(guint handle)
+ */
+ bool input_remove;
+
+ /*
+ * int (*input_get_error)(int fd, int * error)
+ */
+ int input_get_error;
+
+ /*
+ * guint (*timeout_add_seconds)(guint interval, GSourceFunc function, gpointer data)
+ */
+ uint timeout_add_seconds;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleGroup.cs 22098e5d15e0d66d82812d9f4929516891ddbbf0
+++ libpurple/wrapper/PurpleGroup.cs 22098e5d15e0d66d82812d9f4929516891ddbbf0
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleGroup : UnmanagedWrapper<_PurpleGroup>
+ {
+ public PurpleGroup()
+ {
+ }
+
+ public PurpleGroup(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleGroup)Marshal.PtrToStructure(this.Reference, typeof(_PurpleGroup));
+ }
+
+ public PurpleBlistNode node
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public int totalsize
+ {
+ get
+ {
+ return this.Data.totalsize;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.totalsize = value;
+ }
+ }
+
+ public int currentsize
+ {
+ get
+ {
+ return this.Data.currentsize;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.currentsize = value;
+ }
+ }
+
+ public int online
+ {
+ get
+ {
+ return this.Data.online;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.online = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleGroup
+ {
+ /*
+ * PurpleBlistNode node
+ */
+ UNKNOWN node;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * int totalsize
+ */
+ int totalsize;
+
+ /*
+ * int currentsize
+ */
+ int currentsize;
+
+ /*
+ * int online
+ */
+ int online;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleKeyValuePair.cs f4586393f96da8b38dc1c3fdd97befeff36a4502
+++ libpurple/wrapper/PurpleKeyValuePair.cs f4586393f96da8b38dc1c3fdd97befeff36a4502
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleKeyValuePair : UnmanagedWrapper<_PurpleKeyValuePair>
+ {
+ public PurpleKeyValuePair()
+ {
+ }
+
+ public PurpleKeyValuePair(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleKeyValuePair)Marshal.PtrToStructure(this.Reference, typeof(_PurpleKeyValuePair));
+ }
+
+ public string key
+ {
+ get
+ {
+ return this.Data.key;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.key = value;
+ }
+ }
+
+ public IntPtr value
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleKeyValuePair
+ {
+ /*
+ * gchar * key
+ */
+ string key;
+
+ /*
+ * void * value
+ */
+ IntPtr value;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleLog.cs fb63edc33f8b39be269652c1fa0716fa08d4f3e8
+++ libpurple/wrapper/PurpleLog.cs fb63edc33f8b39be269652c1fa0716fa08d4f3e8
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleLog : UnmanagedWrapper<_PurpleLog>
+ {
+ public PurpleLog()
+ {
+ }
+
+ public PurpleLog(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleLog)Marshal.PtrToStructure(this.Reference, typeof(_PurpleLog));
+ }
+
+ public PurpleLogType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleConversation conv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public time_t time
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleLogLogger logger
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr logger_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public struct tm *tm
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleLog
+ {
+ /*
+ * PurpleLogType type
+ */
+ UNKNOWN type;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * PurpleConversation * conv
+ */
+ IntPtr conv;
+
+ /*
+ * time_t time
+ */
+ UNKNOWN time;
+
+ /*
+ * PurpleLogLogger * logger
+ */
+ IntPtr logger;
+
+ /*
+ * void * logger_data
+ */
+ IntPtr logger_data;
+
+ /*
+ * struct tm *tm
+ */
+ UNKNOWN tm *tm;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleLogCommonLoggerData.cs 542283ebad3d78f2825aef0e7876298f16229a54
+++ libpurple/wrapper/PurpleLogCommonLoggerData.cs 542283ebad3d78f2825aef0e7876298f16229a54
@@ -0,0 +1,119 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleLogCommonLoggerData : UnmanagedWrapper<_PurpleLogCommonLoggerData>
+ {
+ public PurpleLogCommonLoggerData()
+ {
+ }
+
+ public PurpleLogCommonLoggerData(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleLogCommonLoggerData)Marshal.PtrToStructure(this.Reference, typeof(_PurpleLogCommonLoggerData));
+ }
+
+ public string path
+ {
+ get
+ {
+ return this.Data.path;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.path = value;
+ }
+ }
+
+ public FILE file
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr extra_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleLogCommonLoggerData
+ {
+ /*
+ * char * path
+ */
+ string path;
+
+ /*
+ * FILE * file
+ */
+ IntPtr file;
+
+ /*
+ * void * extra_data
+ */
+ IntPtr extra_data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleLogLogger.cs 24333eed2e73b7a816969625c605a841d20aea72
+++ libpurple/wrapper/PurpleLogLogger.cs 24333eed2e73b7a816969625c605a841d20aea72
@@ -0,0 +1,399 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleLogLogger : UnmanagedWrapper<_PurpleLogLogger>
+ {
+ public PurpleLogLogger()
+ {
+ }
+
+ public PurpleLogLogger(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleLogLogger)Marshal.PtrToStructure(this.Reference, typeof(_PurpleLogLogger));
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string id
+ {
+ get
+ {
+ return this.Data.id;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.id = value;
+ }
+ }
+
+ public void create
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public gsize write
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void finalize
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList list
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string read
+ {
+ get
+ {
+ return this.Data.read;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.read = value;
+ }
+ }
+
+ public int size
+ {
+ get
+ {
+ return this.Data.size;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.size = value;
+ }
+ }
+
+ public int total_size
+ {
+ get
+ {
+ return this.Data.total_size;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.total_size = value;
+ }
+ }
+
+ public GList list_syslog
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_log_sets
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool remove
+ {
+ get
+ {
+ return this.Data.remove;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.remove = value;
+ }
+ }
+
+ public bool is_deletable
+ {
+ get
+ {
+ return this.Data.is_deletable;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.is_deletable = value;
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleLogLogger
+ {
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * char * id
+ */
+ string id;
+
+ /*
+ * void (*create)(PurpleLog * log)
+ */
+ void create;
+
+ /*
+ * gsize (*write)(PurpleLog * log, PurpleMessageFlags type, char * from, time_t time, char * message)
+ */
+ UNKNOWN write;
+
+ /*
+ * void (*finalize)(PurpleLog * log)
+ */
+ void finalize;
+
+ /*
+ * GList * (*list)(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ IntPtr list;
+
+ /*
+ * char * (*read)(PurpleLog * log, PurpleLogReadFlags * flags)
+ */
+ string read;
+
+ /*
+ * int (*size)(PurpleLog * log)
+ */
+ int size;
+
+ /*
+ * int (*total_size)(PurpleLogType type, char * name, PurpleAccount * account)
+ */
+ int total_size;
+
+ /*
+ * GList * (*list_syslog)(PurpleAccount * account)
+ */
+ IntPtr list_syslog;
+
+ /*
+ * void (*get_log_sets)(PurpleLogSetCallback cb, GHashTable * sets)
+ */
+ void get_log_sets;
+
+ /*
+ * gboolean (*remove)(PurpleLog * log)
+ */
+ bool remove;
+
+ /*
+ * gboolean (*is_deletable)(PurpleLog * log)
+ */
+ bool is_deletable;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleLogSet.cs ee511a3d084d44930d23af9c9a97176300c94c05
+++ libpurple/wrapper/PurpleLogSet.cs ee511a3d084d44930d23af9c9a97176300c94c05
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleLogSet : UnmanagedWrapper<_PurpleLogSet>
+ {
+ public PurpleLogSet()
+ {
+ }
+
+ public PurpleLogSet(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleLogSet)Marshal.PtrToStructure(this.Reference, typeof(_PurpleLogSet));
+ }
+
+ public PurpleLogType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool buddy
+ {
+ get
+ {
+ return this.Data.buddy;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.buddy = value;
+ }
+ }
+
+ public string normalized_name
+ {
+ get
+ {
+ return this.Data.normalized_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.normalized_name = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleLogSet
+ {
+ /*
+ * PurpleLogType type
+ */
+ UNKNOWN type;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * gboolean buddy
+ */
+ bool buddy;
+
+ /*
+ * char * normalized_name
+ */
+ string normalized_name;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleMenuAction.cs 5c99cee5c84338b0823b7e63c8bea9c95474ca12
+++ libpurple/wrapper/PurpleMenuAction.cs 5c99cee5c84338b0823b7e63c8bea9c95474ca12
@@ -0,0 +1,139 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleMenuAction : UnmanagedWrapper<_PurpleMenuAction>
+ {
+ public PurpleMenuAction()
+ {
+ }
+
+ public PurpleMenuAction(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleMenuAction)Marshal.PtrToStructure(this.Reference, typeof(_PurpleMenuAction));
+ }
+
+ public string label
+ {
+ get
+ {
+ return this.Data.label;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.label = value;
+ }
+ }
+
+ public PurpleCallback callback
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList children
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleMenuAction
+ {
+ /*
+ * char * label
+ */
+ string label;
+
+ /*
+ * PurpleCallback callback
+ */
+ UNKNOWN callback;
+
+ /*
+ * gpointer data
+ */
+ IntPtr data;
+
+ /*
+ * GList * children
+ */
+ IntPtr children;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePlugin.cs f12e0cf51121b6abbc825d3834d37ee78b2cc02c
+++ libpurple/wrapper/PurplePlugin.cs f12e0cf51121b6abbc825d3834d37ee78b2cc02c
@@ -0,0 +1,339 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePlugin : UnmanagedWrapper<_PurplePlugin>
+ {
+ public PurplePlugin()
+ {
+ }
+
+ public PurplePlugin(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePlugin)Marshal.PtrToStructure(this.Reference, typeof(_PurplePlugin));
+ }
+
+ public bool native_plugin
+ {
+ get
+ {
+ return this.Data.native_plugin;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.native_plugin = value;
+ }
+ }
+
+ public bool loaded
+ {
+ get
+ {
+ return this.Data.loaded;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.loaded = value;
+ }
+ }
+
+ public IntPtr handle
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string path
+ {
+ get
+ {
+ return this.Data.path;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.path = value;
+ }
+ }
+
+ public PurplePluginInfo info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string error
+ {
+ get
+ {
+ return this.Data.error;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.error = value;
+ }
+ }
+
+ public IntPtr ipc_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr extra
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool unloadable
+ {
+ get
+ {
+ return this.Data.unloadable;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.unloadable = value;
+ }
+ }
+
+ public GList dependent_plugins
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePlugin
+ {
+ /*
+ * gboolean native_plugin
+ */
+ bool native_plugin;
+
+ /*
+ * gboolean loaded
+ */
+ bool loaded;
+
+ /*
+ * void * handle
+ */
+ IntPtr handle;
+
+ /*
+ * char * path
+ */
+ string path;
+
+ /*
+ * PurplePluginInfo * info
+ */
+ IntPtr info;
+
+ /*
+ * char * error
+ */
+ string error;
+
+ /*
+ * void * ipc_data
+ */
+ IntPtr ipc_data;
+
+ /*
+ * void * extra
+ */
+ IntPtr extra;
+
+ /*
+ * gboolean unloadable
+ */
+ bool unloadable;
+
+ /*
+ * GList * dependent_plugins
+ */
+ IntPtr dependent_plugins;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePluginAction.cs 4cd3291351280d040a84a7dcfcd7280f35384f3e
+++ libpurple/wrapper/PurplePluginAction.cs 4cd3291351280d040a84a7dcfcd7280f35384f3e
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePluginAction : UnmanagedWrapper<_PurplePluginAction>
+ {
+ public PurplePluginAction()
+ {
+ }
+
+ public PurplePluginAction(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePluginAction)Marshal.PtrToStructure(this.Reference, typeof(_PurplePluginAction));
+ }
+
+ public string label
+ {
+ get
+ {
+ return this.Data.label;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.label = value;
+ }
+ }
+
+ public void callback
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePlugin plugin
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr context
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr user_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePluginAction
+ {
+ /*
+ * char * label
+ */
+ string label;
+
+ /*
+ * void (*callback)( )
+ */
+ void callback;
+
+ /*
+ * PurplePlugin * plugin
+ */
+ IntPtr plugin;
+
+ /*
+ * gpointer context
+ */
+ IntPtr context;
+
+ /*
+ * gpointer user_data
+ */
+ IntPtr user_data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePluginInfo.cs 77bd6db85498b2a0aeb1601e7d2bfebf2ea49744
+++ libpurple/wrapper/PurplePluginInfo.cs 77bd6db85498b2a0aeb1601e7d2bfebf2ea49744
@@ -0,0 +1,579 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePluginInfo : UnmanagedWrapper<_PurplePluginInfo>
+ {
+ public PurplePluginInfo()
+ {
+ }
+
+ public PurplePluginInfo(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePluginInfo)Marshal.PtrToStructure(this.Reference, typeof(_PurplePluginInfo));
+ }
+
+ public unsigned int magic
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public unsigned int major_version
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public unsigned int minor_version
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePluginType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string ui_requirement
+ {
+ get
+ {
+ return this.Data.ui_requirement;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.ui_requirement = value;
+ }
+ }
+
+ public unsigned long flags
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList dependencies
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePluginPriority priority
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string id
+ {
+ get
+ {
+ return this.Data.id;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.id = value;
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public string version
+ {
+ get
+ {
+ return this.Data.version;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.version = value;
+ }
+ }
+
+ public string summary
+ {
+ get
+ {
+ return this.Data.summary;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.summary = value;
+ }
+ }
+
+ public string description
+ {
+ get
+ {
+ return this.Data.description;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.description = value;
+ }
+ }
+
+ public string author
+ {
+ get
+ {
+ return this.Data.author;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.author = value;
+ }
+ }
+
+ public string homepage
+ {
+ get
+ {
+ return this.Data.homepage;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.homepage = value;
+ }
+ }
+
+ public bool load
+ {
+ get
+ {
+ return this.Data.load;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.load = value;
+ }
+ }
+
+ public bool unload
+ {
+ get
+ {
+ return this.Data.unload;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.unload = value;
+ }
+ }
+
+ public void destroy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr extra_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePluginUiInfo prefs_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList actions
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePluginInfo
+ {
+ /*
+ * unsigned int magic
+ */
+ UNKNOWN int magic;
+
+ /*
+ * unsigned int major_version
+ */
+ UNKNOWN int major_version;
+
+ /*
+ * unsigned int minor_version
+ */
+ UNKNOWN int minor_version;
+
+ /*
+ * PurplePluginType type
+ */
+ UNKNOWN type;
+
+ /*
+ * char * ui_requirement
+ */
+ string ui_requirement;
+
+ /*
+ * unsigned long flags
+ */
+ UNKNOWN long flags;
+
+ /*
+ * GList * dependencies
+ */
+ IntPtr dependencies;
+
+ /*
+ * PurplePluginPriority priority
+ */
+ UNKNOWN priority;
+
+ /*
+ * char * id
+ */
+ string id;
+
+ /*
+ * char * name
+ */
+ string name;
+
+ /*
+ * char * version
+ */
+ string version;
+
+ /*
+ * char * summary
+ */
+ string summary;
+
+ /*
+ * char * description
+ */
+ string description;
+
+ /*
+ * char * author
+ */
+ string author;
+
+ /*
+ * char * homepage
+ */
+ string homepage;
+
+ /*
+ * gboolean (*load)(PurplePlugin * plugin)
+ */
+ bool load;
+
+ /*
+ * gboolean (*unload)(PurplePlugin * plugin)
+ */
+ bool unload;
+
+ /*
+ * void (*destroy)(PurplePlugin * plugin)
+ */
+ void destroy;
+
+ /*
+ * void * ui_info
+ */
+ IntPtr ui_info;
+
+ /*
+ * void * extra_info
+ */
+ IntPtr extra_info;
+
+ /*
+ * PurplePluginUiInfo * prefs_info
+ */
+ IntPtr prefs_info;
+
+ /*
+ * GList * (*actions)(PurplePlugin * plugin, gpointer context)
+ */
+ IntPtr actions;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePluginLoaderInfo.cs 6b51b690a94a2e2c70eeefb7128554e440af19ab
+++ libpurple/wrapper/PurplePluginLoaderInfo.cs 6b51b690a94a2e2c70eeefb7128554e440af19ab
@@ -0,0 +1,239 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePluginLoaderInfo : UnmanagedWrapper<_PurplePluginLoaderInfo>
+ {
+ public PurplePluginLoaderInfo()
+ {
+ }
+
+ public PurplePluginLoaderInfo(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePluginLoaderInfo)Marshal.PtrToStructure(this.Reference, typeof(_PurplePluginLoaderInfo));
+ }
+
+ public GList exts
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool probe
+ {
+ get
+ {
+ return this.Data.probe;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.probe = value;
+ }
+ }
+
+ public bool load
+ {
+ get
+ {
+ return this.Data.load;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.load = value;
+ }
+ }
+
+ public bool unload
+ {
+ get
+ {
+ return this.Data.unload;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.unload = value;
+ }
+ }
+
+ public void destroy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePluginLoaderInfo
+ {
+ /*
+ * GList * exts
+ */
+ IntPtr exts;
+
+ /*
+ * gboolean (*probe)(PurplePlugin * plugin)
+ */
+ bool probe;
+
+ /*
+ * gboolean (*load)(PurplePlugin * plugin)
+ */
+ bool load;
+
+ /*
+ * gboolean (*unload)(PurplePlugin * plugin)
+ */
+ bool unload;
+
+ /*
+ * void (*destroy)(PurplePlugin * plugin)
+ */
+ void destroy;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePluginProtocolInfo.cs 673ba3030b371b8a3ba3a1bea66589a719905cfb
+++ libpurple/wrapper/PurplePluginProtocolInfo.cs 673ba3030b371b8a3ba3a1bea66589a719905cfb
@@ -0,0 +1,1439 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePluginProtocolInfo : UnmanagedWrapper<_PurplePluginProtocolInfo>
+ {
+ public PurplePluginProtocolInfo()
+ {
+ }
+
+ public PurplePluginProtocolInfo(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePluginProtocolInfo)Marshal.PtrToStructure(this.Reference, typeof(_PurplePluginProtocolInfo));
+ }
+
+ public PurpleProtocolOptions options
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList user_splits
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList protocol_options
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleBuddyIconSpec icon_spec
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *(*list_icon)(PurpleAccount *account, PurpleBuddy *buddy)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *(*list_emblem)(PurpleBuddy *buddy)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string status_text
+ {
+ get
+ {
+ return this.Data.status_text;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.status_text = value;
+ }
+ }
+
+ public void tooltip_text
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList status_types
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList blist_node_menu
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList chat_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable chat_info_defaults
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void login
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void close
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int send_im
+ {
+ get
+ {
+ return this.Data.send_im;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.send_im = value;
+ }
+ }
+
+ public void set_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public unsigned int (*send_typing)(PurpleConnection *, const char *name, PurpleTypingState state)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_status
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_idle
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void change_passwd
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void add_buddy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void add_buddies
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void remove_buddy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void remove_buddies
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void add_permit
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void add_deny
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void rem_permit
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void rem_deny
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_permit_deny
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void join_chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void reject_chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string get_chat_name
+ {
+ get
+ {
+ return this.Data.get_chat_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.get_chat_name = value;
+ }
+ }
+
+ public void chat_invite
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_leave
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void chat_whisper
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int chat_send
+ {
+ get
+ {
+ return this.Data.chat_send;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.chat_send = value;
+ }
+ }
+
+ public void keepalive
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void register_user
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_cb_info
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_cb_away
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void alias_buddy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void group_buddy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void rename_group
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void buddy_free
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void convo_closed
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *(*normalize)(const PurpleAccount *, const char *who)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_buddy_icon
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void remove_group
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string get_cb_real_name
+ {
+ get
+ {
+ return this.Data.get_cb_real_name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.get_cb_real_name = value;
+ }
+ }
+
+ public void set_chat_topic
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleChat find_blist_chat
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleRoomlist roomlist_get_list
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void roomlist_cancel
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void roomlist_expand_category
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool can_receive_file
+ {
+ get
+ {
+ return this.Data.can_receive_file;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.can_receive_file = value;
+ }
+ }
+
+ public void send_file
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleXfer new_xfer
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool offline_message
+ {
+ get
+ {
+ return this.Data.offline_message;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.offline_message = value;
+ }
+ }
+
+ public PurpleWhiteboardPrplOps whiteboard_prpl_ops
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int send_raw
+ {
+ get
+ {
+ return this.Data.send_raw;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.send_raw = value;
+ }
+ }
+
+ public string roomlist_room_serialize
+ {
+ get
+ {
+ return this.Data.roomlist_room_serialize;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.roomlist_room_serialize = value;
+ }
+ }
+
+ public void unregister_user
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool send_attention
+ {
+ get
+ {
+ return this.Data.send_attention;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.send_attention = value;
+ }
+ }
+
+ public GList get_attention_types
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public unsigned long struct_size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable get_account_text_table
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool initiate_media
+ {
+ get
+ {
+ return this.Data.initiate_media;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.initiate_media = value;
+ }
+ }
+
+ public PurpleMediaCaps get_media_caps
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePluginProtocolInfo
+ {
+ /*
+ * PurpleProtocolOptions options
+ */
+ UNKNOWN options;
+
+ /*
+ * GList * user_splits
+ */
+ IntPtr user_splits;
+
+ /*
+ * GList * protocol_options
+ */
+ IntPtr protocol_options;
+
+ /*
+ * PurpleBuddyIconSpec icon_spec
+ */
+ UNKNOWN icon_spec;
+
+ /*
+ * const char *(*list_icon)(PurpleAccount *account, PurpleBuddy *buddy)
+ */
+ UNKNOWN char *(*list_icon)(PurpleAccount *account, PurpleBuddy *buddy);
+
+ /*
+ * const char *(*list_emblem)(PurpleBuddy *buddy)
+ */
+ UNKNOWN char *(*list_emblem)(PurpleBuddy *buddy);
+
+ /*
+ * char * (*status_text)(PurpleBuddy * buddy)
+ */
+ string status_text;
+
+ /*
+ * void (*tooltip_text)(PurpleBuddy * buddy, PurpleNotifyUserInfo * user_info, gboolean full)
+ */
+ void tooltip_text;
+
+ /*
+ * GList * (*status_types)(PurpleAccount * account)
+ */
+ IntPtr status_types;
+
+ /*
+ * GList * (*blist_node_menu)(PurpleBlistNode * node)
+ */
+ IntPtr blist_node_menu;
+
+ /*
+ * GList * (*chat_info)( )
+ */
+ IntPtr chat_info;
+
+ /*
+ * GHashTable * (*chat_info_defaults)( , char * chat_name)
+ */
+ IntPtr chat_info_defaults;
+
+ /*
+ * void (*login)( )
+ */
+ void login;
+
+ /*
+ * void (*close)( )
+ */
+ void close;
+
+ /*
+ * int (*send_im)( , char * who, char * message, PurpleMessageFlags flags)
+ */
+ int send_im;
+
+ /*
+ * void (*set_info)( , char * info)
+ */
+ void set_info;
+
+ /*
+ * unsigned int (*send_typing)(PurpleConnection *, const char *name, PurpleTypingState state)
+ */
+ UNKNOWN int (*send_typing)(PurpleConnection *, const char *name, PurpleTypingState state);
+
+ /*
+ * void (*get_info)( , char * who)
+ */
+ void get_info;
+
+ /*
+ * void (*set_status)(PurpleAccount * account, PurpleStatus * status)
+ */
+ void set_status;
+
+ /*
+ * void (*set_idle)( , int idletime)
+ */
+ void set_idle;
+
+ /*
+ * void (*change_passwd)( , char * old_pass, char * new_pass)
+ */
+ void change_passwd;
+
+ /*
+ * void (*add_buddy)( , PurpleBuddy * buddy, PurpleGroup * group)
+ */
+ void add_buddy;
+
+ /*
+ * void (*add_buddies)( , GList * buddies, GList * groups)
+ */
+ void add_buddies;
+
+ /*
+ * void (*remove_buddy)( , PurpleBuddy * buddy, PurpleGroup * group)
+ */
+ void remove_buddy;
+
+ /*
+ * void (*remove_buddies)( , GList * buddies, GList * groups)
+ */
+ void remove_buddies;
+
+ /*
+ * void (*add_permit)( , char * name)
+ */
+ void add_permit;
+
+ /*
+ * void (*add_deny)( , char * name)
+ */
+ void add_deny;
+
+ /*
+ * void (*rem_permit)( , char * name)
+ */
+ void rem_permit;
+
+ /*
+ * void (*rem_deny)( , char * name)
+ */
+ void rem_deny;
+
+ /*
+ * void (*set_permit_deny)( )
+ */
+ void set_permit_deny;
+
+ /*
+ * void (*join_chat)( , GHashTable * components)
+ */
+ void join_chat;
+
+ /*
+ * void (*reject_chat)( , GHashTable * components)
+ */
+ void reject_chat;
+
+ /*
+ * char * (*get_chat_name)(GHashTable * components)
+ */
+ string get_chat_name;
+
+ /*
+ * void (*chat_invite)( , int id, char * message, char * who)
+ */
+ void chat_invite;
+
+ /*
+ * void (*chat_leave)( , int id)
+ */
+ void chat_leave;
+
+ /*
+ * void (*chat_whisper)( , int id, char * who, char * message)
+ */
+ void chat_whisper;
+
+ /*
+ * int (*chat_send)( , int id, char * message, PurpleMessageFlags flags)
+ */
+ int chat_send;
+
+ /*
+ * void (*keepalive)( )
+ */
+ void keepalive;
+
+ /*
+ * void (*register_user)( )
+ */
+ void register_user;
+
+ /*
+ * void (*get_cb_info)( , , char * who)
+ */
+ void get_cb_info;
+
+ /*
+ * void (*get_cb_away)( , , char * who)
+ */
+ void get_cb_away;
+
+ /*
+ * void (*alias_buddy)( , char * who, char * alias)
+ */
+ void alias_buddy;
+
+ /*
+ * void (*group_buddy)( , char * who, char * old_group, char * new_group)
+ */
+ void group_buddy;
+
+ /*
+ * void (*rename_group)( , char * old_name, PurpleGroup * group, GList * moved_buddies)
+ */
+ void rename_group;
+
+ /*
+ * void (*buddy_free)( )
+ */
+ void buddy_free;
+
+ /*
+ * void (*convo_closed)( , char * who)
+ */
+ void convo_closed;
+
+ /*
+ * const char *(*normalize)(const PurpleAccount *, const char *who)
+ */
+ UNKNOWN char *(*normalize)(const PurpleAccount *, const char *who);
+
+ /*
+ * void (*set_buddy_icon)( , PurpleStoredImage * img)
+ */
+ void set_buddy_icon;
+
+ /*
+ * void (*remove_group)(PurpleConnection * gc, PurpleGroup * group)
+ */
+ void remove_group;
+
+ /*
+ * char * (*get_cb_real_name)(PurpleConnection * gc, int id, char * who)
+ */
+ string get_cb_real_name;
+
+ /*
+ * void (*set_chat_topic)(PurpleConnection * gc, int id, char * topic)
+ */
+ void set_chat_topic;
+
+ /*
+ * PurpleChat * (*find_blist_chat)(PurpleAccount * account, char * name)
+ */
+ IntPtr find_blist_chat;
+
+ /*
+ * PurpleRoomlist * (*roomlist_get_list)(PurpleConnection * gc)
+ */
+ IntPtr roomlist_get_list;
+
+ /*
+ * void (*roomlist_cancel)(PurpleRoomlist * list)
+ */
+ void roomlist_cancel;
+
+ /*
+ * void (*roomlist_expand_category)(PurpleRoomlist * list, PurpleRoomlistRoom * category)
+ */
+ void roomlist_expand_category;
+
+ /*
+ * gboolean (*can_receive_file)( , char * who)
+ */
+ bool can_receive_file;
+
+ /*
+ * void (*send_file)( , char * who, char * filename)
+ */
+ void send_file;
+
+ /*
+ * PurpleXfer * (*new_xfer)( , char * who)
+ */
+ IntPtr new_xfer;
+
+ /*
+ * gboolean (*offline_message)(PurpleBuddy * buddy)
+ */
+ bool offline_message;
+
+ /*
+ * PurpleWhiteboardPrplOps * whiteboard_prpl_ops
+ */
+ IntPtr whiteboard_prpl_ops;
+
+ /*
+ * int (*send_raw)(PurpleConnection * gc, char * buf, int len)
+ */
+ int send_raw;
+
+ /*
+ * char * (*roomlist_room_serialize)(PurpleRoomlistRoom * room)
+ */
+ string roomlist_room_serialize;
+
+ /*
+ * void (*unregister_user)( , PurpleAccountUnregistrationCb cb, void * user_data)
+ */
+ void unregister_user;
+
+ /*
+ * gboolean (*send_attention)(PurpleConnection * gc, char * username, guint type)
+ */
+ bool send_attention;
+
+ /*
+ * GList * (*get_attention_types)(PurpleAccount * acct)
+ */
+ IntPtr get_attention_types;
+
+ /*
+ * unsigned long struct_size
+ */
+ UNKNOWN long struct_size;
+
+ /*
+ * GHashTable * (*get_account_text_table)(PurpleAccount * account)
+ */
+ IntPtr get_account_text_table;
+
+ /*
+ * gboolean (*initiate_media)(PurpleAccount * account, char * who, PurpleMediaSessionType type)
+ */
+ bool initiate_media;
+
+ /*
+ * PurpleMediaCaps (*get_media_caps)(PurpleAccount * account, char * who)
+ */
+ UNKNOWN get_media_caps;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePluginUiInfo.cs d44b1f15f1472669ab1ffdbd57ac38d3a411e627
+++ libpurple/wrapper/PurplePluginUiInfo.cs d44b1f15f1472669ab1ffdbd57ac38d3a411e627
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePluginUiInfo : UnmanagedWrapper<_PurplePluginUiInfo>
+ {
+ public PurplePluginUiInfo()
+ {
+ }
+
+ public PurplePluginUiInfo(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePluginUiInfo)Marshal.PtrToStructure(this.Reference, typeof(_PurplePluginUiInfo));
+ }
+
+ public PurplePluginPrefFrame get_plugin_pref_frame
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int page_num
+ {
+ get
+ {
+ return this.Data.page_num;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.page_num = value;
+ }
+ }
+
+ public PurplePluginPrefFrame frame
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePluginUiInfo
+ {
+ /*
+ * PurplePluginPrefFrame * (*get_plugin_pref_frame)(PurplePlugin * plugin)
+ */
+ IntPtr get_plugin_pref_frame;
+
+ /*
+ * int page_num
+ */
+ int page_num;
+
+ /*
+ * PurplePluginPrefFrame * frame
+ */
+ IntPtr frame;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurplePounce.cs c806f60a8c94c13e33a0ca53e67fd5025a76fb06
+++ libpurple/wrapper/PurplePounce.cs c806f60a8c94c13e33a0ca53e67fd5025a76fb06
@@ -0,0 +1,219 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurplePounce : UnmanagedWrapper<_PurplePounce>
+ {
+ public PurplePounce()
+ {
+ }
+
+ public PurplePounce(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurplePounce)Marshal.PtrToStructure(this.Reference, typeof(_PurplePounce));
+ }
+
+ public string ui_type
+ {
+ get
+ {
+ return this.Data.ui_type;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.ui_type = value;
+ }
+ }
+
+ public PurplePounceEvent events
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurplePounceOption options
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount pouncer
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string pouncee
+ {
+ get
+ {
+ return this.Data.pouncee;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.pouncee = value;
+ }
+ }
+
+ public GHashTable actions
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool save
+ {
+ get
+ {
+ return this.Data.save;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.save = value;
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurplePounce
+ {
+ /*
+ * char * ui_type
+ */
+ string ui_type;
+
+ /*
+ * PurplePounceEvent events
+ */
+ UNKNOWN events;
+
+ /*
+ * PurplePounceOption options
+ */
+ UNKNOWN options;
+
+ /*
+ * PurpleAccount * pouncer
+ */
+ IntPtr pouncer;
+
+ /*
+ * char * pouncee
+ */
+ string pouncee;
+
+ /*
+ * GHashTable * actions
+ */
+ IntPtr actions;
+
+ /*
+ * gboolean save
+ */
+ bool save;
+
+ /*
+ * void * data
+ */
+ IntPtr data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleRequestField.cs 82ed38c768253b58f4db7c62d30de741fc25aebd
+++ libpurple/wrapper/PurpleRequestField.cs 82ed38c768253b58f4db7c62d30de741fc25aebd
@@ -0,0 +1,746 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleRequestField : UnmanagedWrapper<_PurpleRequestField>
+ {
+ public PurpleRequestField()
+ {
+ }
+
+ public PurpleRequestField(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleRequestField)Marshal.PtrToStructure(this.Reference, typeof(_PurpleRequestField));
+ }
+
+ public PurpleRequestFieldType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleRequestFieldGroup group
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string id
+ {
+ get
+ {
+ return this.Data.id;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.id = value;
+ }
+ }
+
+ public string label
+ {
+ get
+ {
+ return this.Data.label;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.label = value;
+ }
+ }
+
+ public string type_hint
+ {
+ get
+ {
+ return this.Data.type_hint;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.type_hint = value;
+ }
+ }
+
+ public bool visible
+ {
+ get
+ {
+ return this.Data.visible;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.visible = value;
+ }
+ }
+
+ public bool required
+ {
+ get
+ {
+ return this.Data.required;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.required = value;
+ }
+ }
+
+ public union {
+ struct
+ {
+ gboolean multiline
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool masked
+ {
+ get
+ {
+ return this.Data.masked;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.masked = value;
+ }
+ }
+
+ public bool editable
+ {
+ get
+ {
+ return this.Data.editable;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.editable = value;
+ }
+ }
+
+ public string default_value
+ {
+ get
+ {
+ return this.Data.default_value;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.default_value = value;
+ }
+ }
+
+ public string value
+ {
+ get
+ {
+ return this.Data.value;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.value = value;
+ }
+ }
+
+ public struct {
+ int default_value
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int value
+ {
+ get
+ {
+ return this.Data.value;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.value = value;
+ }
+ }
+
+ public struct {
+ gboolean default_value
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool value
+ {
+ get
+ {
+ return this.Data.value;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.value = value;
+ }
+ }
+
+ public struct {
+ int default_value
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int value
+ {
+ get
+ {
+ return this.Data.value;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.value = value;
+ }
+ }
+
+ public GList labels
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public struct {
+ GList *items
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable item_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList selected
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GHashTable selected_table
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool multiple_selection
+ {
+ get
+ {
+ return this.Data.multiple_selection;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.multiple_selection = value;
+ }
+ }
+
+ public struct {
+ PurpleAccount *default_account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool show_all
+ {
+ get
+ {
+ return this.Data.show_all;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.show_all = value;
+ }
+ }
+
+ public PurpleFilterAccountFunc filter_func
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public struct {
+ unsigned int scale_x
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public unsigned int scale_y
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *buffer
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public gsize size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleRequestField
+ {
+ /*
+ * PurpleRequestFieldType type
+ */
+ UNKNOWN type;
+
+ /*
+ * PurpleRequestFieldGroup * group
+ */
+ IntPtr group;
+
+ /*
+ * char * id
+ */
+ string id;
+
+ /*
+ * char * label
+ */
+ string label;
+
+ /*
+ * char * type_hint
+ */
+ string type_hint;
+
+ /*
+ * gboolean visible
+ */
+ bool visible;
+
+ /*
+ * gboolean required
+ */
+ bool required;
+
+ /*
+ * union {
+ struct
+ {
+ gboolean multiline
+ */
+ UNKNOWN {
+ struct
+ {
+ gboolean multiline;
+
+ /*
+ * gboolean masked
+ */
+ bool masked;
+
+ /*
+ * gboolean editable
+ */
+ bool editable;
+
+ /*
+ * char * default_value
+ */
+ string default_value;
+
+ /*
+ * char * value
+ */
+ string value;
+
+ /*
+ * struct {
+ int default_value
+ */
+ UNKNOWN {
+ int default_value;
+
+ /*
+ * int value
+ */
+ int value;
+
+ /*
+ * struct {
+ gboolean default_value
+ */
+ UNKNOWN {
+ gboolean default_value;
+
+ /*
+ * gboolean value
+ */
+ bool value;
+
+ /*
+ * struct {
+ int default_value
+ */
+ UNKNOWN {
+ int default_value;
+
+ /*
+ * int value
+ */
+ int value;
+
+ /*
+ * GList * labels
+ */
+ IntPtr labels;
+
+ /*
+ * struct {
+ GList *items
+ */
+ UNKNOWN {
+ GList *items;
+
+ /*
+ * GHashTable * item_data
+ */
+ IntPtr item_data;
+
+ /*
+ * GList * selected
+ */
+ IntPtr selected;
+
+ /*
+ * GHashTable * selected_table
+ */
+ IntPtr selected_table;
+
+ /*
+ * gboolean multiple_selection
+ */
+ bool multiple_selection;
+
+ /*
+ * struct {
+ PurpleAccount *default_account
+ */
+ UNKNOWN {
+ PurpleAccount *default_account;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * gboolean show_all
+ */
+ bool show_all;
+
+ /*
+ * PurpleFilterAccountFunc filter_func
+ */
+ UNKNOWN filter_func;
+
+ /*
+ * struct {
+ unsigned int scale_x
+ */
+ UNKNOWN {
+ unsigned int scale_x;
+
+ /*
+ * unsigned int scale_y
+ */
+ UNKNOWN int scale_y;
+
+ /*
+ * const char *buffer
+ */
+ UNKNOWN char *buffer;
+
+ /*
+ * gsize size
+ */
+ UNKNOWN size;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleRoomlist.cs 08642c5fed77f18bdeea8bf7ff313ac3b712f300
+++ libpurple/wrapper/PurpleRoomlist.cs 08642c5fed77f18bdeea8bf7ff313ac3b712f300
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleRoomlist : UnmanagedWrapper<_PurpleRoomlist>
+ {
+ public PurpleRoomlist()
+ {
+ }
+
+ public PurpleRoomlist(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleRoomlist)Marshal.PtrToStructure(this.Reference, typeof(_PurpleRoomlist));
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList fields
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList rooms
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool in_progress
+ {
+ get
+ {
+ return this.Data.in_progress;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.in_progress = value;
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr proto_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public uint ref
+ {
+ get
+ {
+ return this.Data.ref;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.ref = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleRoomlist
+ {
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * GList * fields
+ */
+ IntPtr fields;
+
+ /*
+ * GList * rooms
+ */
+ IntPtr rooms;
+
+ /*
+ * gboolean in_progress
+ */
+ bool in_progress;
+
+ /*
+ * gpointer ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * gpointer proto_data
+ */
+ IntPtr proto_data;
+
+ /*
+ * guint ref
+ */
+ uint ref;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleRoomlistField.cs 54abfd05f6a266d97f37d3269d095dc164409ab0
+++ libpurple/wrapper/PurpleRoomlistField.cs 54abfd05f6a266d97f37d3269d095dc164409ab0
@@ -0,0 +1,139 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleRoomlistField : UnmanagedWrapper<_PurpleRoomlistField>
+ {
+ public PurpleRoomlistField()
+ {
+ }
+
+ public PurpleRoomlistField(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleRoomlistField)Marshal.PtrToStructure(this.Reference, typeof(_PurpleRoomlistField));
+ }
+
+ public PurpleRoomlistFieldType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string label
+ {
+ get
+ {
+ return this.Data.label;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.label = value;
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public bool hidden
+ {
+ get
+ {
+ return this.Data.hidden;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.hidden = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleRoomlistField
+ {
+ /*
+ * PurpleRoomlistFieldType type
+ */
+ UNKNOWN type;
+
+ /*
+ * gchar * label
+ */
+ string label;
+
+ /*
+ * gchar * name
+ */
+ string name;
+
+ /*
+ * gboolean hidden
+ */
+ bool hidden;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleRoomlistRoom.cs f6f805c34e479e361dceb39d429b642abb7ec604
+++ libpurple/wrapper/PurpleRoomlistRoom.cs f6f805c34e479e361dceb39d429b642abb7ec604
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleRoomlistRoom : UnmanagedWrapper<_PurpleRoomlistRoom>
+ {
+ public PurpleRoomlistRoom()
+ {
+ }
+
+ public PurpleRoomlistRoom(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleRoomlistRoom)Marshal.PtrToStructure(this.Reference, typeof(_PurpleRoomlistRoom));
+ }
+
+ public PurpleRoomlistRoomType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string name
+ {
+ get
+ {
+ return this.Data.name;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.name = value;
+ }
+ }
+
+ public GList fields
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleRoomlistRoom parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool expanded_once
+ {
+ get
+ {
+ return this.Data.expanded_once;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.expanded_once = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleRoomlistRoom
+ {
+ /*
+ * PurpleRoomlistRoomType type
+ */
+ UNKNOWN type;
+
+ /*
+ * gchar * name
+ */
+ string name;
+
+ /*
+ * GList * fields
+ */
+ IntPtr fields;
+
+ /*
+ * PurpleRoomlistRoom * parent
+ */
+ IntPtr parent;
+
+ /*
+ * gboolean expanded_once
+ */
+ bool expanded_once;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleRoomlistUiOps.cs 17f0fe2a6a13145b9f8d7cc8384b2220df208ddc
+++ libpurple/wrapper/PurpleRoomlistUiOps.cs 17f0fe2a6a13145b9f8d7cc8384b2220df208ddc
@@ -0,0 +1,259 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleRoomlistUiOps : UnmanagedWrapper<_PurpleRoomlistUiOps>
+ {
+ public PurpleRoomlistUiOps()
+ {
+ }
+
+ public PurpleRoomlistUiOps(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleRoomlistUiOps)Marshal.PtrToStructure(this.Reference, typeof(_PurpleRoomlistUiOps));
+ }
+
+ public void show_with_account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void create
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_fields
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void add_room
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void in_progress
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void destroy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleRoomlistUiOps
+ {
+ /*
+ * void (*show_with_account)(PurpleAccount * account)
+ */
+ void show_with_account;
+
+ /*
+ * void (*create)(PurpleRoomlist * list)
+ */
+ void create;
+
+ /*
+ * void (*set_fields)(PurpleRoomlist * list, GList * fields)
+ */
+ void set_fields;
+
+ /*
+ * void (*add_room)(PurpleRoomlist * list, PurpleRoomlistRoom * room)
+ */
+ void add_room;
+
+ /*
+ * void (*in_progress)(PurpleRoomlist * list, gboolean flag)
+ */
+ void in_progress;
+
+ /*
+ * void (*destroy)(PurpleRoomlist * list)
+ */
+ void destroy;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSoundTheme.cs 646b0d842501cc124b0d882d53e7f9c458cf0c63
+++ libpurple/wrapper/PurpleSoundTheme.cs 646b0d842501cc124b0d882d53e7f9c458cf0c63
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSoundTheme : UnmanagedWrapper<_PurpleSoundTheme>
+ {
+ public PurpleSoundTheme()
+ {
+ }
+
+ public PurpleSoundTheme(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSoundTheme)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSoundTheme));
+ }
+
+ public PurpleTheme parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr priv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSoundTheme
+ {
+ /*
+ * PurpleTheme parent
+ */
+ UNKNOWN parent;
+
+ /*
+ * gpointer priv
+ */
+ IntPtr priv;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSoundThemeClass.cs 4ba0beb14540e0f3ab3804f9c031264b2b41509d
+++ libpurple/wrapper/PurpleSoundThemeClass.cs 4ba0beb14540e0f3ab3804f9c031264b2b41509d
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSoundThemeClass : UnmanagedWrapper<_PurpleSoundThemeClass>
+ {
+ public PurpleSoundThemeClass()
+ {
+ }
+
+ public PurpleSoundThemeClass(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSoundThemeClass)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSoundThemeClass));
+ }
+
+ public PurpleThemeClass parent_class
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSoundThemeClass
+ {
+ /*
+ * PurpleThemeClass parent_class
+ */
+ UNKNOWN parent_class;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSoundThemeLoader.cs 4874060a52b4fd847d08bef980ea09edc82de4d6
+++ libpurple/wrapper/PurpleSoundThemeLoader.cs 4874060a52b4fd847d08bef980ea09edc82de4d6
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSoundThemeLoader : UnmanagedWrapper<_PurpleSoundThemeLoader>
+ {
+ public PurpleSoundThemeLoader()
+ {
+ }
+
+ public PurpleSoundThemeLoader(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSoundThemeLoader)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSoundThemeLoader));
+ }
+
+ public PurpleThemeLoader parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSoundThemeLoader
+ {
+ /*
+ * PurpleThemeLoader parent
+ */
+ UNKNOWN parent;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSoundThemeLoaderClass.cs 51ca03c6c82c4f1f2be42b4ce56b7847203c3764
+++ libpurple/wrapper/PurpleSoundThemeLoaderClass.cs 51ca03c6c82c4f1f2be42b4ce56b7847203c3764
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSoundThemeLoaderClass : UnmanagedWrapper<_PurpleSoundThemeLoaderClass>
+ {
+ public PurpleSoundThemeLoaderClass()
+ {
+ }
+
+ public PurpleSoundThemeLoaderClass(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSoundThemeLoaderClass)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSoundThemeLoaderClass));
+ }
+
+ public PurpleThemeLoaderClass parent_class
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSoundThemeLoaderClass
+ {
+ /*
+ * PurpleThemeLoaderClass parent_class
+ */
+ UNKNOWN parent_class;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSrvResponse.cs 71a8af48e75675384fa20f8c75bf61827ecf691e
+++ libpurple/wrapper/PurpleSrvResponse.cs 71a8af48e75675384fa20f8c75bf61827ecf691e
@@ -0,0 +1,139 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSrvResponse : UnmanagedWrapper<_PurpleSrvResponse>
+ {
+ public PurpleSrvResponse()
+ {
+ }
+
+ public PurpleSrvResponse(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSrvResponse)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSrvResponse));
+ }
+
+ public char hostname[256]
+ {
+ get
+ {
+ return this.Data.hostname[256];
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.hostname[256] = value;
+ }
+ }
+
+ public int port
+ {
+ get
+ {
+ return this.Data.port;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.port = value;
+ }
+ }
+
+ public int weight
+ {
+ get
+ {
+ return this.Data.weight;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.weight = value;
+ }
+ }
+
+ public int pref
+ {
+ get
+ {
+ return this.Data.pref;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.pref = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSrvResponse
+ {
+ /*
+ * char hostname[256]
+ */
+ char hostname[256];
+
+ /*
+ * int port
+ */
+ int port;
+
+ /*
+ * int weight
+ */
+ int weight;
+
+ /*
+ * int pref
+ */
+ int pref;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleSslConnection.cs 59cfad734514f9e61db3176c344193bfe98e2e30
+++ libpurple/wrapper/PurpleSslConnection.cs 59cfad734514f9e61db3176c344193bfe98e2e30
@@ -0,0 +1,299 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleSslConnection : UnmanagedWrapper<_PurpleSslConnection>
+ {
+ public PurpleSslConnection()
+ {
+ }
+
+ public PurpleSslConnection(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleSslConnection)Marshal.PtrToStructure(this.Reference, typeof(_PurpleSslConnection));
+ }
+
+ public string host
+ {
+ get
+ {
+ return this.Data.host;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.host = value;
+ }
+ }
+
+ public int port
+ {
+ get
+ {
+ return this.Data.port;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.port = value;
+ }
+ }
+
+ public IntPtr connect_cb_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleSslInputFunction connect_cb
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleSslErrorFunction error_cb
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr recv_cb_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleSslInputFunction recv_cb
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public int fd
+ {
+ get
+ {
+ return this.Data.fd;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.fd = value;
+ }
+ }
+
+ public uint inpa
+ {
+ get
+ {
+ return this.Data.inpa;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.inpa = value;
+ }
+ }
+
+ public PurpleProxyConnectData connect_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr private_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleCertificateVerifier verifier
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleSslConnection
+ {
+ /*
+ * char * host
+ */
+ string host;
+
+ /*
+ * int port
+ */
+ int port;
+
+ /*
+ * void * connect_cb_data
+ */
+ IntPtr connect_cb_data;
+
+ /*
+ * PurpleSslInputFunction connect_cb
+ */
+ UNKNOWN connect_cb;
+
+ /*
+ * PurpleSslErrorFunction error_cb
+ */
+ UNKNOWN error_cb;
+
+ /*
+ * void * recv_cb_data
+ */
+ IntPtr recv_cb_data;
+
+ /*
+ * PurpleSslInputFunction recv_cb
+ */
+ UNKNOWN recv_cb;
+
+ /*
+ * int fd
+ */
+ int fd;
+
+ /*
+ * guint inpa
+ */
+ uint inpa;
+
+ /*
+ * PurpleProxyConnectData * connect_data
+ */
+ IntPtr connect_data;
+
+ /*
+ * void * private_data
+ */
+ IntPtr private_data;
+
+ /*
+ * PurpleCertificateVerifier * verifier
+ */
+ IntPtr verifier;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleStunNatDiscovery.cs 1e6c28d62d9b005d7a9952b652320b84fc3005b3
+++ libpurple/wrapper/PurpleStunNatDiscovery.cs 1e6c28d62d9b005d7a9952b652320b84fc3005b3
@@ -0,0 +1,159 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleStunNatDiscovery : UnmanagedWrapper<_PurpleStunNatDiscovery>
+ {
+ public PurpleStunNatDiscovery()
+ {
+ }
+
+ public PurpleStunNatDiscovery(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleStunNatDiscovery)Marshal.PtrToStructure(this.Reference, typeof(_PurpleStunNatDiscovery));
+ }
+
+ public PurpleStunStatus status
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleStunNatType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public char publicip[16]
+ {
+ get
+ {
+ return this.Data.publicip[16];
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.publicip[16] = value;
+ }
+ }
+
+ public string servername
+ {
+ get
+ {
+ return this.Data.servername;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.servername = value;
+ }
+ }
+
+ public time_t lookup_time
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleStunNatDiscovery
+ {
+ /*
+ * PurpleStunStatus status
+ */
+ UNKNOWN status;
+
+ /*
+ * PurpleStunNatType type
+ */
+ UNKNOWN type;
+
+ /*
+ * char publicip[16]
+ */
+ char publicip[16];
+
+ /*
+ * char * servername
+ */
+ string servername;
+
+ /*
+ * time_t lookup_time
+ */
+ UNKNOWN lookup_time;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleTheme.cs 850e7391336f48f1b6978f691c3c96339f44b240
+++ libpurple/wrapper/PurpleTheme.cs 850e7391336f48f1b6978f691c3c96339f44b240
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleTheme : UnmanagedWrapper<_PurpleTheme>
+ {
+ public PurpleTheme()
+ {
+ }
+
+ public PurpleTheme(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleTheme)Marshal.PtrToStructure(this.Reference, typeof(_PurpleTheme));
+ }
+
+ public GObject parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr priv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleTheme
+ {
+ /*
+ * GObject parent
+ */
+ UNKNOWN parent;
+
+ /*
+ * gpointer priv
+ */
+ IntPtr priv;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleThemeClass.cs 63bbdf64916118dff29160be0e785b73eb9527db
+++ libpurple/wrapper/PurpleThemeClass.cs 63bbdf64916118dff29160be0e785b73eb9527db
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleThemeClass : UnmanagedWrapper<_PurpleThemeClass>
+ {
+ public PurpleThemeClass()
+ {
+ }
+
+ public PurpleThemeClass(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleThemeClass)Marshal.PtrToStructure(this.Reference, typeof(_PurpleThemeClass));
+ }
+
+ public GObjectClass parent_class
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleThemeClass
+ {
+ /*
+ * GObjectClass parent_class
+ */
+ UNKNOWN parent_class;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleThemeLoader.cs 8c2e4a3d0d1061e6b03a452d89e39a5aa7fd3d66
+++ libpurple/wrapper/PurpleThemeLoader.cs 8c2e4a3d0d1061e6b03a452d89e39a5aa7fd3d66
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleThemeLoader : UnmanagedWrapper<_PurpleThemeLoader>
+ {
+ public PurpleThemeLoader()
+ {
+ }
+
+ public PurpleThemeLoader(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleThemeLoader)Marshal.PtrToStructure(this.Reference, typeof(_PurpleThemeLoader));
+ }
+
+ public GObject parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr priv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleThemeLoader
+ {
+ /*
+ * GObject parent
+ */
+ UNKNOWN parent;
+
+ /*
+ * gpointer priv
+ */
+ IntPtr priv;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleThemeLoaderClass.cs e1b1ccc78ad0b7f7993f6ce81deb27695b971f77
+++ libpurple/wrapper/PurpleThemeLoaderClass.cs e1b1ccc78ad0b7f7993f6ce81deb27695b971f77
@@ -0,0 +1,99 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleThemeLoaderClass : UnmanagedWrapper<_PurpleThemeLoaderClass>
+ {
+ public PurpleThemeLoaderClass()
+ {
+ }
+
+ public PurpleThemeLoaderClass(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleThemeLoaderClass)Marshal.PtrToStructure(this.Reference, typeof(_PurpleThemeLoaderClass));
+ }
+
+ public GObjectClass parent_class
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleTheme ((*purple_theme_loader_build)(const gchar*))
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleThemeLoaderClass
+ {
+ /*
+ * GObjectClass parent_class
+ */
+ UNKNOWN parent_class;
+
+ /*
+ * PurpleTheme * ((*purple_theme_loader_build)(const gchar*))
+ */
+ IntPtr ((*purple_theme_loader_build)(const gchar*));
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleThemeManager.cs 28677fb8db28b583ea3c80b57d9b33137444c9a5
+++ libpurple/wrapper/PurpleThemeManager.cs 28677fb8db28b583ea3c80b57d9b33137444c9a5
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleThemeManager : UnmanagedWrapper<_PurpleThemeManager>
+ {
+ public PurpleThemeManager()
+ {
+ }
+
+ public PurpleThemeManager(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleThemeManager)Marshal.PtrToStructure(this.Reference, typeof(_PurpleThemeManager));
+ }
+
+ public GObject parent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleThemeManager
+ {
+ /*
+ * GObject parent
+ */
+ UNKNOWN parent;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleThemeManagerClass.cs 66901bd9b2fd40cdb3b94d8861e71f19e1ede31f
+++ libpurple/wrapper/PurpleThemeManagerClass.cs 66901bd9b2fd40cdb3b94d8861e71f19e1ede31f
@@ -0,0 +1,79 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleThemeManagerClass : UnmanagedWrapper<_PurpleThemeManagerClass>
+ {
+ public PurpleThemeManagerClass()
+ {
+ }
+
+ public PurpleThemeManagerClass(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleThemeManagerClass)Marshal.PtrToStructure(this.Reference, typeof(_PurpleThemeManagerClass));
+ }
+
+ public GObjectClass parent_class
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleThemeManagerClass
+ {
+ /*
+ * GObjectClass parent_class
+ */
+ UNKNOWN parent_class;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleWhiteboard.cs 4047f484a13bd44b7207c627694aa1243d7cdb60
+++ libpurple/wrapper/PurpleWhiteboard.cs 4047f484a13bd44b7207c627694aa1243d7cdb60
@@ -0,0 +1,671 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleWhiteboard : UnmanagedWrapper<_PurpleWhiteboard>
+ {
+ public PurpleWhiteboard()
+ {
+ }
+
+ public PurpleWhiteboard(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleWhiteboard)Marshal.PtrToStructure(this.Reference, typeof(_PurpleWhiteboard));
+ }
+
+ public int state
+ {
+ get
+ {
+ return this.Data.state;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.state = value;
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string who
+ {
+ get
+ {
+ return this.Data.who;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.who = value;
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr proto_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleWhiteboardPrplOps prpl_ops
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public GList draw_list
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public typedef struct _PurpleWhiteboardUiOps
+{
+ void (*create)(PurpleWhiteboard *wb)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void destroy
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_dimensions
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_brush
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void draw_point
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void draw_line
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void clear
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public struct _PurpleWhiteboardPrplOps
+{
+ void (*start)(PurpleWhiteboard *wb)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void end
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_dimensions
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_dimensions
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void get_brush
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void set_brush
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void send_draw_list
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void clear
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved1
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved2
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved3
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void _purple_reserved4
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleWhiteboard
+ {
+ /*
+ * int state
+ */
+ int state;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * char * who
+ */
+ string who;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * void * proto_data
+ */
+ IntPtr proto_data;
+
+ /*
+ * PurpleWhiteboardPrplOps * prpl_ops
+ */
+ IntPtr prpl_ops;
+
+ /*
+ * GList * draw_list
+ */
+ IntPtr draw_list;
+
+ /*
+ * typedef struct _PurpleWhiteboardUiOps
+{
+ void (*create)(PurpleWhiteboard *wb)
+ */
+ UNKNOWN struct _PurpleWhiteboardUiOps
+{
+ void (*create)(PurpleWhiteboard *wb);
+
+ /*
+ * void (*destroy)(PurpleWhiteboard * wb)
+ */
+ void destroy;
+
+ /*
+ * void (*set_dimensions)(PurpleWhiteboard * wb, int width, int height)
+ */
+ void set_dimensions;
+
+ /*
+ * void (*set_brush)(PurpleWhiteboard * wb, int size, int color)
+ */
+ void set_brush;
+
+ /*
+ * void (*draw_point)(PurpleWhiteboard * wb, int x, int y, int color, int size)
+ */
+ void draw_point;
+
+ /*
+ * void (*draw_line)(PurpleWhiteboard * wb, int x1, int y1, int x2, int y2, int color, int size)
+ */
+ void draw_line;
+
+ /*
+ * void (*clear)(PurpleWhiteboard * wb)
+ */
+ void clear;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ /*
+ * struct _PurpleWhiteboardPrplOps
+{
+ void (*start)(PurpleWhiteboard *wb)
+ */
+ UNKNOWN _PurpleWhiteboardPrplOps
+{
+ void (*start)(PurpleWhiteboard *wb);
+
+ /*
+ * void (*end)(PurpleWhiteboard * wb)
+ */
+ void end;
+
+ /*
+ * void (*get_dimensions)(PurpleWhiteboard * wb, int * width, int * height)
+ */
+ void get_dimensions;
+
+ /*
+ * void (*set_dimensions)(PurpleWhiteboard * wb, int width, int height)
+ */
+ void set_dimensions;
+
+ /*
+ * void (*get_brush)(PurpleWhiteboard * wb, int * size, int * color)
+ */
+ void get_brush;
+
+ /*
+ * void (*set_brush)(PurpleWhiteboard * wb, int size, int color)
+ */
+ void set_brush;
+
+ /*
+ * void (*send_draw_list)(PurpleWhiteboard * wb, GList * draw_list)
+ */
+ void send_draw_list;
+
+ /*
+ * void (*clear)(PurpleWhiteboard * wb)
+ */
+ void clear;
+
+ /*
+ * void (*_purple_reserved1)()
+ */
+ void _purple_reserved1;
+
+ /*
+ * void (*_purple_reserved2)()
+ */
+ void _purple_reserved2;
+
+ /*
+ * void (*_purple_reserved3)()
+ */
+ void _purple_reserved3;
+
+ /*
+ * void (*_purple_reserved4)()
+ */
+ void _purple_reserved4;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/PurpleXfer.cs fd7446d6268545b9a660de3548500211effa1065
+++ libpurple/wrapper/PurpleXfer.cs fd7446d6268545b9a660de3548500211effa1065
@@ -0,0 +1,702 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class PurpleXfer : UnmanagedWrapper<_PurpleXfer>
+ {
+ public PurpleXfer()
+ {
+ }
+
+ public PurpleXfer(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_PurpleXfer)Marshal.PtrToStructure(this.Reference, typeof(_PurpleXfer));
+ }
+
+ public uint ref
+ {
+ get
+ {
+ return this.Data.ref;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.ref = value;
+ }
+ }
+
+ public PurpleXferType type
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleAccount account
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string who
+ {
+ get
+ {
+ return this.Data.who;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.who = value;
+ }
+ }
+
+ public string message
+ {
+ get
+ {
+ return this.Data.message;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.message = value;
+ }
+ }
+
+ public string filename
+ {
+ get
+ {
+ return this.Data.filename;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.filename = value;
+ }
+ }
+
+ public string local_filename
+ {
+ get
+ {
+ return this.Data.local_filename;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.local_filename = value;
+ }
+ }
+
+ public size_t size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public FILE dest_fp
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public string remote_ip
+ {
+ get
+ {
+ return this.Data.remote_ip;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.remote_ip = value;
+ }
+ }
+
+ public int local_port
+ {
+ get
+ {
+ return this.Data.local_port;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.local_port = value;
+ }
+ }
+
+ public int remote_port
+ {
+ get
+ {
+ return this.Data.remote_port;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.remote_port = value;
+ }
+ }
+
+ public int fd
+ {
+ get
+ {
+ return this.Data.fd;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.fd = value;
+ }
+ }
+
+ public int watcher
+ {
+ get
+ {
+ return this.Data.watcher;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.watcher = value;
+ }
+ }
+
+ public size_t bytes_sent
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public size_t bytes_remaining
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public time_t start_time
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public time_t end_time
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public size_t current_buffer_size
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleXferStatusType status
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public struct {
+ void (*init)(PurpleXfer *xfer)
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void request_denied
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void start
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void end
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void cancel_send
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void cancel_recv
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public gssize read
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public gssize write
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public void ack
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public PurpleXferUiOps ui_ops
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr ui_data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public IntPtr data
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _PurpleXfer
+ {
+ /*
+ * guint ref
+ */
+ uint ref;
+
+ /*
+ * PurpleXferType type
+ */
+ UNKNOWN type;
+
+ /*
+ * PurpleAccount * account
+ */
+ IntPtr account;
+
+ /*
+ * char * who
+ */
+ string who;
+
+ /*
+ * char * message
+ */
+ string message;
+
+ /*
+ * char * filename
+ */
+ string filename;
+
+ /*
+ * char * local_filename
+ */
+ string local_filename;
+
+ /*
+ * size_t size
+ */
+ UNKNOWN size;
+
+ /*
+ * FILE * dest_fp
+ */
+ IntPtr dest_fp;
+
+ /*
+ * char * remote_ip
+ */
+ string remote_ip;
+
+ /*
+ * int local_port
+ */
+ int local_port;
+
+ /*
+ * int remote_port
+ */
+ int remote_port;
+
+ /*
+ * int fd
+ */
+ int fd;
+
+ /*
+ * int watcher
+ */
+ int watcher;
+
+ /*
+ * size_t bytes_sent
+ */
+ UNKNOWN bytes_sent;
+
+ /*
+ * size_t bytes_remaining
+ */
+ UNKNOWN bytes_remaining;
+
+ /*
+ * time_t start_time
+ */
+ UNKNOWN start_time;
+
+ /*
+ * time_t end_time
+ */
+ UNKNOWN end_time;
+
+ /*
+ * size_t current_buffer_size
+ */
+ UNKNOWN current_buffer_size;
+
+ /*
+ * PurpleXferStatusType status
+ */
+ UNKNOWN status;
+
+ /*
+ * struct {
+ void (*init)(PurpleXfer *xfer)
+ */
+ UNKNOWN {
+ void (*init)(PurpleXfer *xfer);
+
+ /*
+ * void (*request_denied)(PurpleXfer * xfer)
+ */
+ void request_denied;
+
+ /*
+ * void (*start)(PurpleXfer * xfer)
+ */
+ void start;
+
+ /*
+ * void (*end)(PurpleXfer * xfer)
+ */
+ void end;
+
+ /*
+ * void (*cancel_send)(PurpleXfer * xfer)
+ */
+ void cancel_send;
+
+ /*
+ * void (*cancel_recv)(PurpleXfer * xfer)
+ */
+ void cancel_recv;
+
+ /*
+ * gssize (*read)(guchar ** buffer, PurpleXfer * xfer)
+ */
+ UNKNOWN read;
+
+ /*
+ * gssize (*write)(guchar * buffer, size_t size, PurpleXfer * xfer)
+ */
+ UNKNOWN write;
+
+ /*
+ * void (*ack)(PurpleXfer * xfer, guchar * buffer, size_t size)
+ */
+ void ack;
+
+ /*
+ * PurpleXferUiOps * ui_ops
+ */
+ IntPtr ui_ops;
+
+ /*
+ * void * ui_data
+ */
+ IntPtr ui_data;
+
+ /*
+ * void * data
+ */
+ IntPtr data;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Request.cs 58f6df146e5eca66831ddfdb2271c0838a2d91f7
+++ libpurple/wrapper/Request.cs 58f6df146e5eca66831ddfdb2271c0838a2d91f7
@@ -0,0 +1,1143 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Request
+ {
+ /*
+ * PurpleRequestFields * purple_request_fields_new()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields_new();
+
+ public static PurpleRequestFields FieldsNew()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_fields_destroy(PurpleRequestFields * fields)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_fields_destroy(IntPtr fields);
+
+ public static void FieldsDestroy(PurpleRequestFields fields)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_fields_add_group(PurpleRequestFields * fields, PurpleRequestFieldGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_fields_add_group(IntPtr fields, IntPtr group);
+
+ public static void FieldsAddGroup(PurpleRequestFields fields, PurpleRequestFieldGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_fields_get_groups(PurpleRequestFields * fields)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields_get_groups(IntPtr fields);
+
+ public static GList FieldsGetGroups(PurpleRequestFields fields)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_fields_exists(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_fields_exists(IntPtr fields, string id);
+
+ public static bool FieldsExists(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_fields_get_required(PurpleRequestFields * fields)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields_get_required(IntPtr fields);
+
+ public static GList FieldsGetRequired(PurpleRequestFields fields)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_fields_is_field_required(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_fields_is_field_required(IntPtr fields, string id);
+
+ public static bool FieldsIsFieldRequired(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_fields_all_required_filled(PurpleRequestFields * fields)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_fields_all_required_filled(IntPtr fields);
+
+ public static bool FieldsAllRequiredFilled(PurpleRequestFields fields)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_fields_get_field(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields_get_field(IntPtr fields, string id);
+
+ public static PurpleRequestField FieldsGetField(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_fields_get_string(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_fields_get_string(IntPtr fields, string id);
+
+ public static string FieldsGetString(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_fields_get_integer(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_fields_get_integer(IntPtr fields, string id);
+
+ public static int FieldsGetInteger(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_fields_get_bool(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_fields_get_bool(IntPtr fields, string id);
+
+ public static bool FieldsGetBool(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_fields_get_choice(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_fields_get_choice(IntPtr fields, string id);
+
+ public static int FieldsGetChoice(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_request_fields_get_account(PurpleRequestFields * fields, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields_get_account(IntPtr fields, string id);
+
+ public static PurpleAccount FieldsGetAccount(PurpleRequestFields fields, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestFieldGroup * purple_request_field_group_new(char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_group_new(string title);
+
+ public static PurpleRequestFieldGroup FieldGroupNew(string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_group_destroy(PurpleRequestFieldGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_group_destroy(IntPtr group);
+
+ public static void FieldGroupDestroy(PurpleRequestFieldGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_group_add_field(PurpleRequestFieldGroup * group, PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_group_add_field(IntPtr group, IntPtr field);
+
+ public static void FieldGroupAddField(PurpleRequestFieldGroup group, PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_group_get_title(PurpleRequestFieldGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_group_get_title(IntPtr group);
+
+ public static string FieldGroupGetTitle(PurpleRequestFieldGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_field_group_get_fields(PurpleRequestFieldGroup * group)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_group_get_fields(IntPtr group);
+
+ public static GList FieldGroupGetFields(PurpleRequestFieldGroup group)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_new(char * id, char * text, PurpleRequestFieldType type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_new(string id, string text, UNKNOWN type);
+
+ public static PurpleRequestField FieldNew(string id, string text, PurpleRequestFieldType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_destroy(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_destroy(IntPtr field);
+
+ public static void FieldDestroy(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_set_label(PurpleRequestField * field, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_set_label(IntPtr field, string label);
+
+ public static void FieldSetLabel(PurpleRequestField field, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_set_visible(PurpleRequestField * field, gboolean visible)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_set_visible(IntPtr field, bool visible);
+
+ public static void FieldSetVisible(PurpleRequestField field, bool visible)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_set_type_hint(PurpleRequestField * field, char * type_hint)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_set_type_hint(IntPtr field, string type_hint);
+
+ public static void FieldSetTypeHint(PurpleRequestField field, string type_hint)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_set_required(PurpleRequestField * field, gboolean required)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_set_required(IntPtr field, bool required);
+
+ public static void FieldSetRequired(PurpleRequestField field, bool required)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestFieldType purple_request_field_get_type(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_request_field_get_type(IntPtr field);
+
+ public static PurpleRequestFieldType FieldGetType(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestFieldGroup * purple_request_field_get_group(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_get_group(IntPtr field);
+
+ public static PurpleRequestFieldGroup FieldGetGroup(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_get_id(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_get_id(IntPtr field);
+
+ public static string FieldGetId(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_get_label(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_get_label(IntPtr field);
+
+ public static string FieldGetLabel(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_is_visible(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_is_visible(IntPtr field);
+
+ public static bool FieldIsVisible(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_get_type_hint(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_get_type_hint(IntPtr field);
+
+ public static string FieldGetTypeHint(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_is_required(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_is_required(IntPtr field);
+
+ public static bool FieldIsRequired(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gpointer purple_request_field_get_ui_data(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_get_ui_data(IntPtr field);
+
+ public static IntPtr FieldGetUiData(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_set_ui_data(PurpleRequestField * field, gpointer ui_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_set_ui_data(IntPtr field, IntPtr ui_data);
+
+ public static void FieldSetUiData(PurpleRequestField field, IntPtr ui_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_string_new(char * id, char * text, char * default_value, gboolean multiline)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_string_new(string id, string text, string default_value, bool multiline);
+
+ public static PurpleRequestField FieldStringNew(string id, string text, string default_value, bool multiline)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_string_set_default_value(PurpleRequestField * field, char * default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_string_set_default_value(IntPtr field, string default_value);
+
+ public static void FieldStringSetDefaultValue(PurpleRequestField field, string default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_string_set_value(PurpleRequestField * field, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_string_set_value(IntPtr field, string value);
+
+ public static void FieldStringSetValue(PurpleRequestField field, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_string_set_masked(PurpleRequestField * field, gboolean masked)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_string_set_masked(IntPtr field, bool masked);
+
+ public static void FieldStringSetMasked(PurpleRequestField field, bool masked)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_string_set_editable(PurpleRequestField * field, gboolean editable)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_string_set_editable(IntPtr field, bool editable);
+
+ public static void FieldStringSetEditable(PurpleRequestField field, bool editable)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_string_get_default_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_string_get_default_value(IntPtr field);
+
+ public static string FieldStringGetDefaultValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_string_get_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_string_get_value(IntPtr field);
+
+ public static string FieldStringGetValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_string_is_multiline(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_string_is_multiline(IntPtr field);
+
+ public static bool FieldStringIsMultiline(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_string_is_masked(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_string_is_masked(IntPtr field);
+
+ public static bool FieldStringIsMasked(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_string_is_editable(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_string_is_editable(IntPtr field);
+
+ public static bool FieldStringIsEditable(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_int_new(char * id, char * text, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_int_new(string id, string text, int default_value);
+
+ public static PurpleRequestField FieldIntNew(string id, string text, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_int_set_default_value(PurpleRequestField * field, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_int_set_default_value(IntPtr field, int default_value);
+
+ public static void FieldIntSetDefaultValue(PurpleRequestField field, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_int_set_value(PurpleRequestField * field, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_int_set_value(IntPtr field, int value);
+
+ public static void FieldIntSetValue(PurpleRequestField field, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_int_get_default_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_int_get_default_value(IntPtr field);
+
+ public static int FieldIntGetDefaultValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_int_get_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_int_get_value(IntPtr field);
+
+ public static int FieldIntGetValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_bool_new(char * id, char * text, gboolean default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_bool_new(string id, string text, bool default_value);
+
+ public static PurpleRequestField FieldBoolNew(string id, string text, bool default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_bool_set_default_value(PurpleRequestField * field, gboolean default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_bool_set_default_value(IntPtr field, bool default_value);
+
+ public static void FieldBoolSetDefaultValue(PurpleRequestField field, bool default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_bool_set_value(PurpleRequestField * field, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_bool_set_value(IntPtr field, bool value);
+
+ public static void FieldBoolSetValue(PurpleRequestField field, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_bool_get_default_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_bool_get_default_value(IntPtr field);
+
+ public static bool FieldBoolGetDefaultValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_bool_get_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_bool_get_value(IntPtr field);
+
+ public static bool FieldBoolGetValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_choice_new(char * id, char * text, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_choice_new(string id, string text, int default_value);
+
+ public static PurpleRequestField FieldChoiceNew(string id, string text, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_choice_add(PurpleRequestField * field, char * label)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_choice_add(IntPtr field, string label);
+
+ public static void FieldChoiceAdd(PurpleRequestField field, string label)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_choice_set_default_value(PurpleRequestField * field, int default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_choice_set_default_value(IntPtr field, int default_value);
+
+ public static void FieldChoiceSetDefaultValue(PurpleRequestField field, int default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_choice_set_value(PurpleRequestField * field, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_choice_set_value(IntPtr field, int value);
+
+ public static void FieldChoiceSetValue(PurpleRequestField field, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_choice_get_default_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_choice_get_default_value(IntPtr field);
+
+ public static int FieldChoiceGetDefaultValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_choice_get_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_choice_get_value(IntPtr field);
+
+ public static int FieldChoiceGetValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_field_choice_get_labels(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_choice_get_labels(IntPtr field);
+
+ public static GList FieldChoiceGetLabels(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_list_new(char * id, char * text)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_list_new(string id, string text);
+
+ public static PurpleRequestField FieldListNew(string id, string text)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_list_set_multi_select(PurpleRequestField * field, gboolean multi_select)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_list_set_multi_select(IntPtr field, bool multi_select);
+
+ public static void FieldListSetMultiSelect(PurpleRequestField field, bool multi_select)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_list_get_multi_select(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_list_get_multi_select(IntPtr field);
+
+ public static bool FieldListGetMultiSelect(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_field_list_get_data(PurpleRequestField * field, char * text)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_list_get_data(IntPtr field, string text);
+
+ public static IntPtr FieldListGetData(PurpleRequestField field, string text)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_list_add(PurpleRequestField * field, char * item, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_list_add(IntPtr field, string item, IntPtr data);
+
+ public static void FieldListAdd(PurpleRequestField field, string item, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_list_add_selected(PurpleRequestField * field, char * item)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_list_add_selected(IntPtr field, string item);
+
+ public static void FieldListAddSelected(PurpleRequestField field, string item)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_list_clear_selected(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_list_clear_selected(IntPtr field);
+
+ public static void FieldListClearSelected(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_list_set_selected(PurpleRequestField * field, GList * items)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_list_set_selected(IntPtr field, IntPtr items);
+
+ public static void FieldListSetSelected(PurpleRequestField field, GList items)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_list_is_selected(PurpleRequestField * field, char * item)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_list_is_selected(IntPtr field, string item);
+
+ public static bool FieldListIsSelected(PurpleRequestField field, string item)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_field_list_get_selected(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_list_get_selected(IntPtr field);
+
+ public static GList FieldListGetSelected(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_request_field_list_get_items(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_list_get_items(IntPtr field);
+
+ public static GList FieldListGetItems(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_label_new(char * id, char * text)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_label_new(string id, string text);
+
+ public static PurpleRequestField FieldLabelNew(string id, string text)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_image_new(char * id, char * text, char * buf, gsize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_image_new(string id, string text, string buf, UNKNOWN size);
+
+ public static PurpleRequestField FieldImageNew(string id, string text, string buf, gsize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_image_set_scale(PurpleRequestField * field, unsigned int, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_image_set_scale(IntPtr field, UNKNOWN int, UNKNOWN int);
+
+ public static void FieldImageSetScale(PurpleRequestField field, unsigned int, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_request_field_image_get_buffer(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_request_field_image_get_buffer(IntPtr field);
+
+ public static string FieldImageGetBuffer(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gsize purple_request_field_image_get_size(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_request_field_image_get_size(IntPtr field);
+
+ public static gsize FieldImageGetSize(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_image_get_scale_x(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_image_get_scale_x(IntPtr field);
+
+ public static int FieldImageGetScaleX(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_request_field_image_get_scale_y(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_request_field_image_get_scale_y(IntPtr field);
+
+ public static int FieldImageGetScaleY(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestField * purple_request_field_account_new(char * id, char * text, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_account_new(string id, string text, IntPtr account);
+
+ public static PurpleRequestField FieldAccountNew(string id, string text, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_account_set_default_value(PurpleRequestField * field, PurpleAccount * default_value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_account_set_default_value(IntPtr field, IntPtr default_value);
+
+ public static void FieldAccountSetDefaultValue(PurpleRequestField field, PurpleAccount default_value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_account_set_value(PurpleRequestField * field, PurpleAccount * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_account_set_value(IntPtr field, IntPtr value);
+
+ public static void FieldAccountSetValue(PurpleRequestField field, PurpleAccount value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_account_set_show_all(PurpleRequestField * field, gboolean show_all)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_account_set_show_all(IntPtr field, bool show_all);
+
+ public static void FieldAccountSetShowAll(PurpleRequestField field, bool show_all)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_field_account_set_filter(PurpleRequestField * field, PurpleFilterAccountFunc filter_func)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_field_account_set_filter(IntPtr field, UNKNOWN filter_func);
+
+ public static void FieldAccountSetFilter(PurpleRequestField field, PurpleFilterAccountFunc filter_func)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_request_field_account_get_default_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_account_get_default_value(IntPtr field);
+
+ public static PurpleAccount FieldAccountGetDefaultValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_request_field_account_get_value(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_field_account_get_value(IntPtr field);
+
+ public static PurpleAccount FieldAccountGetValue(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_request_field_account_get_show_all(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_request_field_account_get_show_all(IntPtr field);
+
+ public static bool FieldAccountGetShowAll(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleFilterAccountFunc purple_request_field_account_get_filter(PurpleRequestField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_request_field_account_get_filter(IntPtr field);
+
+ public static PurpleFilterAccountFunc FieldAccountGetFilter(PurpleRequestField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_input(void * handle, char * title, char * primary, char * secondary, char * default_value, gboolean multiline, gboolean masked, gchar * hint, char * ok_text, GCallback ok_cb, char * cancel_text, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_input(IntPtr handle, string title, string primary, string secondary, string default_value, bool multiline, bool masked, string hint, string ok_text, UNKNOWN ok_cb, string cancel_text, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data);
+
+ public static IntPtr Input(IntPtr handle, string title, string primary, string secondary, string default_value, bool multiline, bool masked, string hint, string ok_text, GCallback ok_cb, string cancel_text, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_choice(void * handle, char * title, char * primary, char * secondary, int default_value, char * ok_text, GCallback ok_cb, char * cancel_text, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_choice(IntPtr handle, string title, string primary, string secondary, int default_value, string ok_text, UNKNOWN ok_cb, string cancel_text, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data, ...);
+
+ public static IntPtr Choice(IntPtr handle, string title, string primary, string secondary, int default_value, string ok_text, GCallback ok_cb, string cancel_text, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_choice_varg(void * handle, char * title, char * primary, char * secondary, int default_value, char * ok_text, GCallback ok_cb, char * cancel_text, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data, va_list choices)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_choice_varg(IntPtr handle, string title, string primary, string secondary, int default_value, string ok_text, UNKNOWN ok_cb, string cancel_text, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data, UNKNOWN choices);
+
+ public static IntPtr ChoiceVarg(IntPtr handle, string title, string primary, string secondary, int default_value, string ok_text, GCallback ok_cb, string cancel_text, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data, va_list choices)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_action(void * handle, char * title, char * primary, char * secondary, int default_action, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data, size_t action_count, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_action(IntPtr handle, string title, string primary, string secondary, int default_action, IntPtr account, string who, IntPtr conv, IntPtr user_data, UNKNOWN action_count, ...);
+
+ public static IntPtr Action(IntPtr handle, string title, string primary, string secondary, int default_action, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data, size_t action_count, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_action_varg(void * handle, char * title, char * primary, char * secondary, int default_action, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data, size_t action_count, va_list actions)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_action_varg(IntPtr handle, string title, string primary, string secondary, int default_action, IntPtr account, string who, IntPtr conv, IntPtr user_data, UNKNOWN action_count, UNKNOWN actions);
+
+ public static IntPtr ActionVarg(IntPtr handle, string title, string primary, string secondary, int default_action, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data, size_t action_count, va_list actions)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_fields(void * handle, char * title, char * primary, char * secondary, PurpleRequestFields * fields, char * ok_text, GCallback ok_cb, char * cancel_text, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_fields(IntPtr handle, string title, string primary, string secondary, IntPtr fields, string ok_text, UNKNOWN ok_cb, string cancel_text, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data);
+
+ public static IntPtr Fields(IntPtr handle, string title, string primary, string secondary, PurpleRequestFields fields, string ok_text, GCallback ok_cb, string cancel_text, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_close(PurpleRequestType type, void * uihandle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_close(UNKNOWN type, IntPtr uihandle);
+
+ public static void Close(PurpleRequestType type, IntPtr uihandle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_close_with_handle(void * handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_close_with_handle(IntPtr handle);
+
+ public static void CloseWithHandle(IntPtr handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_file(void * handle, char * title, char * filename, gboolean savedialog, GCallback ok_cb, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_file(IntPtr handle, string title, string filename, bool savedialog, UNKNOWN ok_cb, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data);
+
+ public static IntPtr File(IntPtr handle, string title, string filename, bool savedialog, GCallback ok_cb, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_request_folder(void * handle, char * title, char * dirname, GCallback ok_cb, GCallback cancel_cb, PurpleAccount * account, char * who, PurpleConversation * conv, void * user_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_folder(IntPtr handle, string title, string dirname, UNKNOWN ok_cb, UNKNOWN cancel_cb, IntPtr account, string who, IntPtr conv, IntPtr user_data);
+
+ public static IntPtr Folder(IntPtr handle, string title, string dirname, GCallback ok_cb, GCallback cancel_cb, PurpleAccount account, string who, PurpleConversation conv, IntPtr user_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_request_set_ui_ops(PurpleRequestUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_request_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleRequestUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRequestUiOps * purple_request_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_request_get_ui_ops();
+
+ public static PurpleRequestUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Roomlist.cs 06d1c2d0585bc501f6b22dfd52e561ec54c77d8a
+++ libpurple/wrapper/Roomlist.cs 06d1c2d0585bc501f6b22dfd52e561ec54c77d8a
@@ -0,0 +1,263 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Roomlist
+ {
+ /*
+ * void purple_roomlist_show_with_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_show_with_account(IntPtr account);
+
+ public static void ShowWithAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlist * purple_roomlist_new(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_roomlist_new(IntPtr account);
+
+ public static PurpleRoomlist New(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_ref(PurpleRoomlist * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_ref(IntPtr list);
+
+ public static void Ref(PurpleRoomlist list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_unref(PurpleRoomlist * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_unref(IntPtr list);
+
+ public static void Unref(PurpleRoomlist list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_set_fields(PurpleRoomlist * list, GList * fields)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_set_fields(IntPtr list, IntPtr fields);
+
+ public static void SetFields(PurpleRoomlist list, GList fields)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_set_in_progress(PurpleRoomlist * list, gboolean in_progress)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_set_in_progress(IntPtr list, bool in_progress);
+
+ public static void SetInProgress(PurpleRoomlist list, bool in_progress)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_roomlist_get_in_progress(PurpleRoomlist * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_roomlist_get_in_progress(IntPtr list);
+
+ public static bool GetInProgress(PurpleRoomlist list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_room_add(PurpleRoomlist * list, PurpleRoomlistRoom * room)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_room_add(IntPtr list, IntPtr room);
+
+ public static void RoomAdd(PurpleRoomlist list, PurpleRoomlistRoom room)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlist * purple_roomlist_get_list(PurpleConnection * gc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_roomlist_get_list(IntPtr gc);
+
+ public static PurpleRoomlist GetList(PurpleConnection gc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_cancel_get_list(PurpleRoomlist * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_cancel_get_list(IntPtr list);
+
+ public static void CancelGetList(PurpleRoomlist list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_expand_category(PurpleRoomlist * list, PurpleRoomlistRoom * category)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_expand_category(IntPtr list, IntPtr category);
+
+ public static void ExpandCategory(PurpleRoomlist list, PurpleRoomlistRoom category)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlistRoom * purple_roomlist_room_new(PurpleRoomlistRoomType type, gchar * name, PurpleRoomlistRoom * parent)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_roomlist_room_new(UNKNOWN type, string name, IntPtr parent);
+
+ public static PurpleRoomlistRoom RoomNew(PurpleRoomlistRoomType type, string name, PurpleRoomlistRoom parent)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_room_add_field(PurpleRoomlist * list, PurpleRoomlistRoom * room, gconstpointer field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_room_add_field(IntPtr list, IntPtr room, UNKNOWN field);
+
+ public static void RoomAddField(PurpleRoomlist list, PurpleRoomlistRoom room, gconstpointer field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_room_join(PurpleRoomlist * list, PurpleRoomlistRoom * room)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_room_join(IntPtr list, IntPtr room);
+
+ public static void RoomJoin(PurpleRoomlist list, PurpleRoomlistRoom room)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlistRoomType purple_roomlist_room_get_type(PurpleRoomlistRoom * room)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_roomlist_room_get_type(IntPtr room);
+
+ public static PurpleRoomlistRoomType RoomGetType(PurpleRoomlistRoom room)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlistField * purple_roomlist_field_new(PurpleRoomlistFieldType type, gchar * label, gchar * name, gboolean hidden)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_roomlist_field_new(UNKNOWN type, string label, string name, bool hidden);
+
+ public static PurpleRoomlistField FieldNew(PurpleRoomlistFieldType type, string label, string name, bool hidden)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlistFieldType purple_roomlist_field_get_type(PurpleRoomlistField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_roomlist_field_get_type(IntPtr field);
+
+ public static PurpleRoomlistFieldType FieldGetType(PurpleRoomlistField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_roomlist_field_get_hidden(PurpleRoomlistField * field)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_roomlist_field_get_hidden(IntPtr field);
+
+ public static bool FieldGetHidden(PurpleRoomlistField field)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_roomlist_set_ui_ops(PurpleRoomlistUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_roomlist_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleRoomlistUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleRoomlistUiOps * purple_roomlist_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_roomlist_get_ui_ops();
+
+ public static PurpleRoomlistUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Savedstatuses.cs 3fb330b94d622dfbe907a38f56a4e57d48bedb5d
+++ libpurple/wrapper/Savedstatuses.cs 3fb330b94d622dfbe907a38f56a4e57d48bedb5d
@@ -0,0 +1,406 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Savedstatuses
+ {
+ /*
+ * PurpleSavedStatus * purple_savedstatus_new(char * title, PurpleStatusPrimitive type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_new(string title, UNKNOWN type);
+
+ public static PurpleSavedStatus SavedstatusNew(string title, PurpleStatusPrimitive type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_set_title(PurpleSavedStatus * status, char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_set_title(IntPtr status, string title);
+
+ public static void SavedstatusSetTitle(PurpleSavedStatus status, string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_set_type(PurpleSavedStatus * status, PurpleStatusPrimitive type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_set_type(IntPtr status, UNKNOWN type);
+
+ public static void SavedstatusSetType(PurpleSavedStatus status, PurpleStatusPrimitive type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_set_message(PurpleSavedStatus * status, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_set_message(IntPtr status, string message);
+
+ public static void SavedstatusSetMessage(PurpleSavedStatus status, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_set_substatus(PurpleSavedStatus * status, PurpleAccount * account, PurpleStatusType * type, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_set_substatus(IntPtr status, IntPtr account, IntPtr type, string message);
+
+ public static void SavedstatusSetSubstatus(PurpleSavedStatus status, PurpleAccount account, PurpleStatusType type, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_unset_substatus(PurpleSavedStatus * saved_status, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_unset_substatus(IntPtr saved_status, IntPtr account);
+
+ public static void SavedstatusUnsetSubstatus(PurpleSavedStatus saved_status, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_savedstatus_delete(char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_savedstatus_delete(string title);
+
+ public static bool SavedstatusDelete(string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_delete_by_status(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_delete_by_status(IntPtr saved_status);
+
+ public static void SavedstatusDeleteByStatus(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_savedstatuses_get_all()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatuses_get_all();
+
+ public static GList GetAll()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_savedstatuses_get_popular(unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatuses_get_popular(UNKNOWN int);
+
+ public static GList GetPopular(unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_get_current()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_get_current();
+
+ public static PurpleSavedStatus SavedstatusGetCurrent()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_get_default()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_get_default();
+
+ public static PurpleSavedStatus SavedstatusGetDefault()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_get_idleaway()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_get_idleaway();
+
+ public static PurpleSavedStatus SavedstatusGetIdleaway()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_savedstatus_is_idleaway()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_savedstatus_is_idleaway();
+
+ public static bool SavedstatusIsIdleaway()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_set_idleaway(gboolean idleaway)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_set_idleaway(bool idleaway);
+
+ public static void SavedstatusSetIdleaway(bool idleaway)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_get_startup()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_get_startup();
+
+ public static PurpleSavedStatus SavedstatusGetStartup()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_find(char * title)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_find(string title);
+
+ public static PurpleSavedStatus SavedstatusFind(string title)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_find_by_creation_time(time_t creation_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_find_by_creation_time(UNKNOWN creation_time);
+
+ public static PurpleSavedStatus SavedstatusFindByCreationTime(time_t creation_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatus * purple_savedstatus_find_transient_by_type_and_message(PurpleStatusPrimitive type, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_find_transient_by_type_and_message(UNKNOWN type, string message);
+
+ public static PurpleSavedStatus SavedstatusFindTransientByTypeAndMessage(PurpleStatusPrimitive type, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_savedstatus_is_transient(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_savedstatus_is_transient(IntPtr saved_status);
+
+ public static bool SavedstatusIsTransient(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_savedstatus_get_title(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_savedstatus_get_title(IntPtr saved_status);
+
+ public static string SavedstatusGetTitle(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusPrimitive purple_savedstatus_get_type(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_savedstatus_get_type(IntPtr saved_status);
+
+ public static PurpleStatusPrimitive SavedstatusGetType(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_savedstatus_get_message(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_savedstatus_get_message(IntPtr saved_status);
+
+ public static string SavedstatusGetMessage(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_savedstatus_get_creation_time(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_savedstatus_get_creation_time(IntPtr saved_status);
+
+ public static time_t SavedstatusGetCreationTime(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_savedstatus_has_substatuses(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_savedstatus_has_substatuses(IntPtr saved_status);
+
+ public static bool SavedstatusHasSubstatuses(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSavedStatusSub * purple_savedstatus_get_substatus(PurpleSavedStatus * saved_status, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_get_substatus(IntPtr saved_status, IntPtr account);
+
+ public static PurpleSavedStatusSub SavedstatusGetSubstatus(PurpleSavedStatus saved_status, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_savedstatus_substatus_get_type(PurpleSavedStatusSub * substatus)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatus_substatus_get_type(IntPtr substatus);
+
+ public static PurpleStatusType SavedstatusSubstatusGetType(PurpleSavedStatusSub substatus)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_savedstatus_substatus_get_message(PurpleSavedStatusSub * substatus)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_savedstatus_substatus_get_message(IntPtr substatus);
+
+ public static string SavedstatusSubstatusGetMessage(PurpleSavedStatusSub substatus)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_activate(PurpleSavedStatus * saved_status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_activate(IntPtr saved_status);
+
+ public static void SavedstatusActivate(PurpleSavedStatus saved_status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatus_activate_for_account(PurpleSavedStatus * saved_status, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatus_activate_for_account(IntPtr saved_status, IntPtr account);
+
+ public static void SavedstatusActivateForAccount(PurpleSavedStatus saved_status, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_savedstatuses_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_savedstatuses_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatuses_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatuses_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_savedstatuses_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_savedstatuses_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Server.cs c8d4cc5379d85fdbf15cc5bc8d9722bb1877eedd
+++ libpurple/wrapper/Server.cs c8d4cc5379d85fdbf15cc5bc8d9722bb1877eedd
@@ -0,0 +1,384 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Server
+ {
+ /*
+ * int serv_send_typing(PurpleConnection * gc, char * name, PurpleTypingState state)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int serv_send_typing(IntPtr gc, string name, UNKNOWN state);
+
+ public static int ServSendTyping(PurpleConnection gc, string name, PurpleTypingState state)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_move_buddy( , , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_move_buddy(UNKNOWN , UNKNOWN , UNKNOWN );
+
+ public static void ServMoveBuddy( , , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int serv_send_im( , , , PurpleMessageFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int serv_send_im(UNKNOWN , UNKNOWN , UNKNOWN , UNKNOWN flags);
+
+ public static int ServSendIm( , , , PurpleMessageFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAttentionType * purple_get_attention_type_from_code(PurpleAccount * account, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_get_attention_type_from_code(IntPtr account, uint type_code);
+
+ public static PurpleAttentionType GetAttentionTypeFromCode(PurpleAccount account, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_send_attention(PurpleConnection * gc, char * who, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_send_attention(IntPtr gc, string who, uint type_code);
+
+ public static void ServSendAttention(PurpleConnection gc, string who, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_attention(PurpleConnection * gc, char * who, guint type_code)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_attention(IntPtr gc, string who, uint type_code);
+
+ public static void ServGotAttention(PurpleConnection gc, string who, uint type_code)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_get_info( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_get_info(UNKNOWN , UNKNOWN );
+
+ public static void ServGetInfo( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_set_info( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_set_info(UNKNOWN , UNKNOWN );
+
+ public static void ServSetInfo( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_add_permit( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_add_permit(UNKNOWN , UNKNOWN );
+
+ public static void ServAddPermit( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_add_deny( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_add_deny(UNKNOWN , UNKNOWN );
+
+ public static void ServAddDeny( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_rem_permit( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_rem_permit(UNKNOWN , UNKNOWN );
+
+ public static void ServRemPermit( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_rem_deny( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_rem_deny(UNKNOWN , UNKNOWN );
+
+ public static void ServRemDeny( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_set_permit_deny( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_set_permit_deny(UNKNOWN );
+
+ public static void ServSetPermitDeny( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_chat_invite( , , , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_chat_invite(UNKNOWN , UNKNOWN , UNKNOWN , UNKNOWN );
+
+ public static void ServChatInvite( , , , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_chat_leave( , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_chat_leave(UNKNOWN , UNKNOWN );
+
+ public static void ServChatLeave( , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_chat_whisper( , , , )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_chat_whisper(UNKNOWN , UNKNOWN , UNKNOWN , UNKNOWN );
+
+ public static void ServChatWhisper( , , , )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int serv_chat_send( , , , PurpleMessageFlags flags)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int serv_chat_send(UNKNOWN , UNKNOWN , UNKNOWN , UNKNOWN flags);
+
+ public static int ServChatSend( , , , PurpleMessageFlags flags)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_alias_buddy( )
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_alias_buddy(UNKNOWN );
+
+ public static void ServAliasBuddy( )
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_alias(PurpleConnection * gc, char * who, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_alias(IntPtr gc, string who, string alias);
+
+ public static void ServGotAlias(PurpleConnection gc, string who, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_serv_got_private_alias(PurpleConnection * gc, char * who, char * alias)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_serv_got_private_alias(IntPtr gc, string who, string alias);
+
+ public static void ServGotPrivateAlias(PurpleConnection gc, string who, string alias)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_typing(PurpleConnection * gc, char * name, int timeout, PurpleTypingState state)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_typing(IntPtr gc, string name, int timeout, UNKNOWN state);
+
+ public static void ServGotTyping(PurpleConnection gc, string name, int timeout, PurpleTypingState state)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_typing_stopped(PurpleConnection * gc, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_typing_stopped(IntPtr gc, string name);
+
+ public static void ServGotTypingStopped(PurpleConnection gc, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_im(PurpleConnection * gc, char * who, char * msg, PurpleMessageFlags flags, time_t mtime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_im(IntPtr gc, string who, string msg, UNKNOWN flags, UNKNOWN mtime);
+
+ public static void ServGotIm(PurpleConnection gc, string who, string msg, PurpleMessageFlags flags, time_t mtime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_join_chat( , GHashTable * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_join_chat(UNKNOWN , IntPtr data);
+
+ public static void ServJoinChat( , GHashTable data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_reject_chat( , GHashTable * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_reject_chat(UNKNOWN , IntPtr data);
+
+ public static void ServRejectChat( , GHashTable data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_chat_invite(PurpleConnection * gc, char * name, char * who, char * message, GHashTable * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_chat_invite(IntPtr gc, string name, string who, string message, IntPtr data);
+
+ public static void ServGotChatInvite(PurpleConnection gc, string name, string who, string message, GHashTable data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * serv_got_joined_chat(PurpleConnection * gc, int id, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr serv_got_joined_chat(IntPtr gc, int id, string name);
+
+ public static PurpleConversation ServGotJoinedChat(PurpleConnection gc, int id, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_serv_got_join_chat_failed(PurpleConnection * gc, GHashTable * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_serv_got_join_chat_failed(IntPtr gc, IntPtr data);
+
+ public static void ServGotJoinChatFailed(PurpleConnection gc, GHashTable data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_chat_left(PurpleConnection * g, int id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_chat_left(IntPtr g, int id);
+
+ public static void ServGotChatLeft(PurpleConnection g, int id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_got_chat_in(PurpleConnection * g, int id, char * who, PurpleMessageFlags flags, char * message, time_t mtime)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_got_chat_in(IntPtr g, int id, string who, UNKNOWN flags, string message, UNKNOWN mtime);
+
+ public static void ServGotChatIn(PurpleConnection g, int id, string who, PurpleMessageFlags flags, string message, time_t mtime)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void serv_send_file(PurpleConnection * gc, char * who, char * file)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void serv_send_file(IntPtr gc, string who, string file);
+
+ public static void ServSendFile(PurpleConnection gc, string who, string file)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Signals.cs 0fd710084b6210ac2048951e6185e31946a31d48
+++ libpurple/wrapper/Signals.cs 0fd710084b6210ac2048951e6185e31946a31d48
@@ -0,0 +1,604 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Signals
+ {
+ /*
+ * gulong purple_signal_register(void * instance, char * signal, PurpleSignalMarshalFunc marshal, PurpleValue * ret_value, int num_values, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_signal_register(IntPtr instance, string signal, UNKNOWN marshal, IntPtr ret_value, int num_values, ...);
+
+ public static ulong SignalRegister(IntPtr instance, string signal, PurpleSignalMarshalFunc marshal, PurpleValue ret_value, int num_values, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signal_unregister(void * instance, char * signal)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signal_unregister(IntPtr instance, string signal);
+
+ public static void SignalUnregister(IntPtr instance, string signal)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signals_unregister_by_instance(void * instance)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signals_unregister_by_instance(IntPtr instance);
+
+ public static void UnregisterByInstance(IntPtr instance)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signal_get_values(void * instance, char * signal, PurpleValue ** ret_value, int * num_values, PurpleValue *** values)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signal_get_values(IntPtr instance, string signal, IntPtr ret_value, IntPtr num_values, IntPtr values);
+
+ public static void SignalGetValues(IntPtr instance, string signal, PurpleValue ret_value, int num_values, PurpleValue values)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_signal_connect_priority(void * instance, char * signal, void * handle, PurpleCallback func, void * data, int priority)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_signal_connect_priority(IntPtr instance, string signal, IntPtr handle, UNKNOWN func, IntPtr data, int priority);
+
+ public static ulong SignalConnectPriority(IntPtr instance, string signal, IntPtr handle, PurpleCallback func, IntPtr data, int priority)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_signal_connect(void * instance, char * signal, void * handle, PurpleCallback func, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_signal_connect(IntPtr instance, string signal, IntPtr handle, UNKNOWN func, IntPtr data);
+
+ public static ulong SignalConnect(IntPtr instance, string signal, IntPtr handle, PurpleCallback func, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_signal_connect_priority_vargs(void * instance, char * signal, void * handle, PurpleCallback func, void * data, int priority)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_signal_connect_priority_vargs(IntPtr instance, string signal, IntPtr handle, UNKNOWN func, IntPtr data, int priority);
+
+ public static ulong SignalConnectPriorityVargs(IntPtr instance, string signal, IntPtr handle, PurpleCallback func, IntPtr data, int priority)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gulong purple_signal_connect_vargs(void * instance, char * signal, void * handle, PurpleCallback func, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_signal_connect_vargs(IntPtr instance, string signal, IntPtr handle, UNKNOWN func, IntPtr data);
+
+ public static ulong SignalConnectVargs(IntPtr instance, string signal, IntPtr handle, PurpleCallback func, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signal_disconnect(void * instance, char * signal, void * handle, PurpleCallback func)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signal_disconnect(IntPtr instance, string signal, IntPtr handle, UNKNOWN func);
+
+ public static void SignalDisconnect(IntPtr instance, string signal, IntPtr handle, PurpleCallback func)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signals_disconnect_by_handle(void * handle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signals_disconnect_by_handle(IntPtr handle);
+
+ public static void DisconnectByHandle(IntPtr handle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signal_emit(void * instance, char * signal, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signal_emit(IntPtr instance, string signal, ...);
+
+ public static void SignalEmit(IntPtr instance, string signal, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signal_emit_vargs(void * instance, char * signal, va_list args)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signal_emit_vargs(IntPtr instance, string signal, UNKNOWN args);
+
+ public static void SignalEmitVargs(IntPtr instance, string signal, va_list args)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_signal_emit_return_1(void * instance, char * signal, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_signal_emit_return_1(IntPtr instance, string signal, ...);
+
+ public static IntPtr SignalEmitReturn1(IntPtr instance, string signal, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_signal_emit_vargs_return_1(void * instance, char * signal, va_list args)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_signal_emit_vargs_return_1(IntPtr instance, string signal, UNKNOWN args);
+
+ public static IntPtr SignalEmitVargsReturn1(IntPtr instance, string signal, va_list args)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signals_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signals_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_signals_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_signals_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_int(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__INT_INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__INT_INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_intInt(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_INT_INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_INT_INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerIntInt(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_INT_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_INT_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerIntPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_UINT_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_UINT_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerUintUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalVoid_pointerPointerPointerUintUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_INT__INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_INT__INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalInt_int(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_INT__INT_INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_INT__INT_INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalInt_intInt(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_INT__POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_INT__POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalInt_pointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalInt_pointerPointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointerPointerUint(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_pointerPointerPointerPointerPointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_BOOLEAN__INT_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_BOOLEAN__INT_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalBoolean_intPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_POINTER__POINTER_INT(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_POINTER__POINTER_INT(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalPointer_pointerInt(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_POINTER__POINTER_INT64(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_POINTER__POINTER_INT64(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalPointer_pointerInt64(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_POINTER__POINTER_INT_BOOLEAN(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_POINTER__POINTER_INT_BOOLEAN(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalPointer_pointerIntBoolean(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_POINTER__POINTER_INT64_BOOLEAN(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_POINTER__POINTER_INT64_BOOLEAN(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalPointer_pointerInt64Boolean(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_marshal_POINTER__POINTER_POINTER(PurpleCallback cb, va_list args, void * data, void ** return_val)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_marshal_POINTER__POINTER_POINTER(UNKNOWN cb, UNKNOWN args, IntPtr data, IntPtr return_val);
+
+ public static void MarshalPointer_pointerPointer(PurpleCallback cb, va_list args, IntPtr data, void return_val)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Smiley.cs 925c41152f40e63c74859bd6e35e8926965fbc11
+++ libpurple/wrapper/Smiley.cs 925c41152f40e63c74859bd6e35e8926965fbc11
@@ -0,0 +1,186 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Smiley
+ {
+ /*
+ * GType purple_smiley_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_smiley_get_type();
+
+ public static GType GetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_smiley_delete(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_smiley_delete(IntPtr smiley);
+
+ public static void Delete(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_smiley_set_shortcut(PurpleSmiley * smiley, char * shortcut)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_smiley_set_shortcut(IntPtr smiley, string shortcut);
+
+ public static bool SetShortcut(PurpleSmiley smiley, string shortcut)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_smiley_set_data(PurpleSmiley * smiley, guchar * smiley_data, size_t smiley_data_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_smiley_set_data(IntPtr smiley, IntPtr smiley_data, UNKNOWN smiley_data_len);
+
+ public static void SetData(PurpleSmiley smiley, guchar smiley_data, size_t smiley_data_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_smiley_get_shortcut(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_smiley_get_shortcut(IntPtr smiley);
+
+ public static string GetShortcut(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_smiley_get_checksum(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_smiley_get_checksum(IntPtr smiley);
+
+ public static string GetChecksum(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStoredImage * purple_smiley_get_stored_image(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_smiley_get_stored_image(IntPtr smiley);
+
+ public static PurpleStoredImage GetStoredImage(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gconstpointer purple_smiley_get_data(PurpleSmiley * smiley, size_t * len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_smiley_get_data(IntPtr smiley, IntPtr len);
+
+ public static gconstpointer GetData(PurpleSmiley smiley, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_smiley_get_extension(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_smiley_get_extension(IntPtr smiley);
+
+ public static string GetExtension(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_smiley_get_full_path(PurpleSmiley * smiley)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_smiley_get_full_path(IntPtr smiley);
+
+ public static string GetFullPath(PurpleSmiley smiley)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_smileys_get_storing_dir()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_smileys_get_storing_dir();
+
+ public static string SmileysGetStoringDir()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_smileys_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_smileys_init();
+
+ public static void SmileysInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_smileys_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_smileys_uninit();
+
+ public static void SmileysUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Sound.cs d6a62cb1846c649def2c5d80628c1c7344d9d49e
+++ libpurple/wrapper/Sound.cs d6a62cb1846c649def2c5d80628c1c7344d9d49e
@@ -0,0 +1,120 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Sound
+ {
+ /*
+ * void purple_sound_play_file(char * filename, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_play_file(string filename, IntPtr account);
+
+ public static void PlayFile(string filename, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_sound_play_event(PurpleSoundEventID event, PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_play_event(UNKNOWN event, IntPtr account);
+
+ public static void PlayEvent(PurpleSoundEventID event, PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_sound_set_ui_ops(PurpleSoundUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleSoundUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSoundUiOps * purple_sound_get_ui_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_sound_get_ui_ops();
+
+ public static PurpleSoundUiOps GetUiOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_sound_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_sound_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_sounds_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_sounds_get_handle();
+
+ public static IntPtr SoundsGetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/SoundTheme.cs 97b59c04a2c2850d4b9ddce97d4009e4e6a9f618
+++ libpurple/wrapper/SoundTheme.cs 97b59c04a2c2850d4b9ddce97d4009e4e6a9f618
@@ -0,0 +1,87 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class SoundTheme
+ {
+ /*
+ * GType purple_sound_theme_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_sound_theme_get_type();
+
+ public static GType SoundThemeGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_sound_theme_get_file(PurpleSoundTheme * theme, gchar * event)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_sound_theme_get_file(IntPtr theme, string event);
+
+ public static string SoundThemeGetFile(PurpleSoundTheme theme, string event)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_sound_theme_get_file_full(PurpleSoundTheme * theme, gchar * event)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_sound_theme_get_file_full(IntPtr theme, string event);
+
+ public static string SoundThemeGetFileFull(PurpleSoundTheme theme, string event)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_sound_theme_set_file(PurpleSoundTheme * theme, gchar * event, gchar * filename)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_sound_theme_set_file(IntPtr theme, string event, string filename);
+
+ public static void SoundThemeSetFile(PurpleSoundTheme theme, string event, string filename)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/SoundThemeLoader.cs 07073de018578231cf88e9577d33314cfd5518d0
+++ libpurple/wrapper/SoundThemeLoader.cs 07073de018578231cf88e9577d33314cfd5518d0
@@ -0,0 +1,54 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class SoundThemeLoader
+ {
+ /*
+ * GType purple_sound_theme_loader_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_sound_theme_loader_get_type();
+
+ public static GType SoundThemeLoaderGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Sslconn.cs c8f81f649e5b441d78df1c73354269b451ed2c61
+++ libpurple/wrapper/Sslconn.cs c8f81f649e5b441d78df1c73354269b451ed2c61
@@ -0,0 +1,175 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Sslconn
+ {
+ /*
+ * gboolean purple_ssl_is_supported()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_ssl_is_supported();
+
+ public static bool SslIsSupported()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSslConnection * purple_ssl_connect(PurpleAccount * account, char * host, int port, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ssl_connect(IntPtr account, string host, int port, UNKNOWN func, UNKNOWN error_func, IntPtr data);
+
+ public static PurpleSslConnection SslConnect(PurpleAccount account, string host, int port, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSslConnection * purple_ssl_connect_fd(PurpleAccount * account, int fd, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ssl_connect_fd(IntPtr account, int fd, UNKNOWN func, UNKNOWN error_func, IntPtr data);
+
+ public static PurpleSslConnection SslConnectFd(PurpleAccount account, int fd, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSslConnection * purple_ssl_connect_with_host_fd(PurpleAccount * account, int fd, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, char * host, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ssl_connect_with_host_fd(IntPtr account, int fd, UNKNOWN func, UNKNOWN error_func, string host, IntPtr data);
+
+ public static PurpleSslConnection SslConnectWithHostFd(PurpleAccount account, int fd, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, string host, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ssl_input_add(PurpleSslConnection * gsc, PurpleSslInputFunction func, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ssl_input_add(IntPtr gsc, UNKNOWN func, IntPtr data);
+
+ public static void SslInputAdd(PurpleSslConnection gsc, PurpleSslInputFunction func, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ssl_close(PurpleSslConnection * gsc)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ssl_close(IntPtr gsc);
+
+ public static void SslClose(PurpleSslConnection gsc)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_ssl_read(PurpleSslConnection * gsc, void * buffer, size_t len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_ssl_read(IntPtr gsc, IntPtr buffer, UNKNOWN len);
+
+ public static size_t SslRead(PurpleSslConnection gsc, IntPtr buffer, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_ssl_write(PurpleSslConnection * gsc, void * buffer, size_t len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_ssl_write(IntPtr gsc, IntPtr buffer, UNKNOWN len);
+
+ public static size_t SslWrite(PurpleSslConnection gsc, IntPtr buffer, size_t len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ssl_set_ops(PurpleSslOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ssl_set_ops(IntPtr ops);
+
+ public static void SslSetOps(PurpleSslOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleSslOps * purple_ssl_get_ops()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_ssl_get_ops();
+
+ public static PurpleSslOps SslGetOps()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ssl_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ssl_init();
+
+ public static void SslInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_ssl_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_ssl_uninit();
+
+ public static void SslUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Status.cs a78b9598f49b5f628422ce46f731c49b49c09506
+++ libpurple/wrapper/Status.cs a78b9598f49b5f628422ce46f731c49b49c09506
@@ -0,0 +1,923 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Status
+ {
+ /*
+ * char * purple_primitive_get_id_from_type(PurpleStatusPrimitive type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_primitive_get_id_from_type(UNKNOWN type);
+
+ public static string PrimitiveGetIdFromType(PurpleStatusPrimitive type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_primitive_get_name_from_type(PurpleStatusPrimitive type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_primitive_get_name_from_type(UNKNOWN type);
+
+ public static string PrimitiveGetNameFromType(PurpleStatusPrimitive type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusPrimitive purple_primitive_get_type_from_id(char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_primitive_get_type_from_id(string id);
+
+ public static PurpleStatusPrimitive PrimitiveGetTypeFromId(string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_status_type_new_full(PurpleStatusPrimitive primitive, char * id, char * name, gboolean saveable, gboolean user_settable, gboolean independent)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_new_full(UNKNOWN primitive, string id, string name, bool saveable, bool user_settable, bool independent);
+
+ public static PurpleStatusType TypeNewFull(PurpleStatusPrimitive primitive, string id, string name, bool saveable, bool user_settable, bool independent)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_status_type_new(PurpleStatusPrimitive primitive, char * id, char * name, gboolean user_settable)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_new(UNKNOWN primitive, string id, string name, bool user_settable);
+
+ public static PurpleStatusType TypeNew(PurpleStatusPrimitive primitive, string id, string name, bool user_settable)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_status_type_new_with_attrs(PurpleStatusPrimitive primitive, char * id, char * name, gboolean saveable, gboolean user_settable, gboolean independent, char * attr_id, char * attr_name, PurpleValue * attr_value, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_new_with_attrs(UNKNOWN primitive, string id, string name, bool saveable, bool user_settable, bool independent, string attr_id, string attr_name, IntPtr attr_value, ...);
+
+ public static PurpleStatusType TypeNewWithAttrs(PurpleStatusPrimitive primitive, string id, string name, bool saveable, bool user_settable, bool independent, string attr_id, string attr_name, PurpleValue attr_value, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_type_destroy(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_type_destroy(IntPtr status_type);
+
+ public static void TypeDestroy(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_type_set_primary_attr(PurpleStatusType * status_type, char * attr_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_type_set_primary_attr(IntPtr status_type, string attr_id);
+
+ public static void TypeSetPrimaryAttr(PurpleStatusType status_type, string attr_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_type_add_attr(PurpleStatusType * status_type, char * id, char * name, PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_type_add_attr(IntPtr status_type, string id, string name, IntPtr value);
+
+ public static void TypeAddAttr(PurpleStatusType status_type, string id, string name, PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_type_add_attrs(PurpleStatusType * status_type, char * id, char * name, PurpleValue * value, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_type_add_attrs(IntPtr status_type, string id, string name, IntPtr value, ...);
+
+ public static void TypeAddAttrs(PurpleStatusType status_type, string id, string name, PurpleValue value, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_type_add_attrs_vargs(PurpleStatusType * status_type, va_list args)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_type_add_attrs_vargs(IntPtr status_type, UNKNOWN args);
+
+ public static void TypeAddAttrsVargs(PurpleStatusType status_type, va_list args)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusPrimitive purple_status_type_get_primitive(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_status_type_get_primitive(IntPtr status_type);
+
+ public static PurpleStatusPrimitive TypeGetPrimitive(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_type_get_id(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_type_get_id(IntPtr status_type);
+
+ public static string TypeGetId(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_type_get_name(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_type_get_name(IntPtr status_type);
+
+ public static string TypeGetName(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_type_is_saveable(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_type_is_saveable(IntPtr status_type);
+
+ public static bool TypeIsSaveable(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_type_is_user_settable(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_type_is_user_settable(IntPtr status_type);
+
+ public static bool TypeIsUserSettable(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_type_is_independent(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_type_is_independent(IntPtr status_type);
+
+ public static bool TypeIsIndependent(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_type_is_exclusive(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_type_is_exclusive(IntPtr status_type);
+
+ public static bool TypeIsExclusive(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_type_is_available(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_type_is_available(IntPtr status_type);
+
+ public static bool TypeIsAvailable(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_type_get_primary_attr(PurpleStatusType * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_type_get_primary_attr(IntPtr type);
+
+ public static string TypeGetPrimaryAttr(PurpleStatusType type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusAttr * purple_status_type_get_attr(PurpleStatusType * status_type, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_get_attr(IntPtr status_type, string id);
+
+ public static PurpleStatusAttr TypeGetAttr(PurpleStatusType status_type, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_status_type_get_attrs(PurpleStatusType * status_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_get_attrs(IntPtr status_type);
+
+ public static GList TypeGetAttrs(PurpleStatusType status_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_status_type_find_with_id(GList * status_types, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_type_find_with_id(IntPtr status_types, string id);
+
+ public static PurpleStatusType TypeFindWithId(GList status_types, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusAttr * purple_status_attr_new(char * id, char * name, PurpleValue * value_type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_attr_new(string id, string name, IntPtr value_type);
+
+ public static PurpleStatusAttr AttrNew(string id, string name, PurpleValue value_type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_attr_destroy(PurpleStatusAttr * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_attr_destroy(IntPtr attr);
+
+ public static void AttrDestroy(PurpleStatusAttr attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_attr_get_id(PurpleStatusAttr * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_attr_get_id(IntPtr attr);
+
+ public static string AttrGetId(PurpleStatusAttr attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_attr_get_name(PurpleStatusAttr * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_attr_get_name(IntPtr attr);
+
+ public static string AttrGetName(PurpleStatusAttr attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleValue * purple_status_attr_get_value(PurpleStatusAttr * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_attr_get_value(IntPtr attr);
+
+ public static PurpleValue AttrGetValue(PurpleStatusAttr attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatus * purple_status_new(PurpleStatusType * status_type, PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_new(IntPtr status_type, IntPtr presence);
+
+ public static PurpleStatus New(PurpleStatusType status_type, PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_destroy(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_destroy(IntPtr status);
+
+ public static void Destroy(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_active(PurpleStatus * status, gboolean active)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_active(IntPtr status, bool active);
+
+ public static void SetActive(PurpleStatus status, bool active)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_active_with_attrs(PurpleStatus * status, gboolean active, va_list args)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_active_with_attrs(IntPtr status, bool active, UNKNOWN args);
+
+ public static void SetActiveWithAttrs(PurpleStatus status, bool active, va_list args)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_active_with_attrs_list(PurpleStatus * status, gboolean active, GList * attrs)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_active_with_attrs_list(IntPtr status, bool active, IntPtr attrs);
+
+ public static void SetActiveWithAttrsList(PurpleStatus status, bool active, GList attrs)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_attr_boolean(PurpleStatus * status, char * id, gboolean value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_attr_boolean(IntPtr status, string id, bool value);
+
+ public static void SetAttrBoolean(PurpleStatus status, string id, bool value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_attr_int(PurpleStatus * status, char * id, int value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_attr_int(IntPtr status, string id, int value);
+
+ public static void SetAttrInt(PurpleStatus status, string id, int value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_set_attr_string(PurpleStatus * status, char * id, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_set_attr_string(IntPtr status, string id, string value);
+
+ public static void SetAttrString(PurpleStatus status, string id, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatusType * purple_status_get_type(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_get_type(IntPtr status);
+
+ public static PurpleStatusType GetType(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_status_get_presence(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_get_presence(IntPtr status);
+
+ public static PurplePresence GetPresence(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_get_id(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_get_id(IntPtr status);
+
+ public static string GetId(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_get_name(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_get_name(IntPtr status);
+
+ public static string GetName(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_is_independent(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_is_independent(IntPtr status);
+
+ public static bool IsIndependent(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_is_exclusive(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_is_exclusive(IntPtr status);
+
+ public static bool IsExclusive(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_is_available(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_is_available(IntPtr status);
+
+ public static bool IsAvailable(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_is_active(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_is_active(IntPtr status);
+
+ public static bool IsActive(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_is_online(PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_is_online(IntPtr status);
+
+ public static bool IsOnline(PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleValue * purple_status_get_attr_value(PurpleStatus * status, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_get_attr_value(IntPtr status, string id);
+
+ public static PurpleValue GetAttrValue(PurpleStatus status, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_status_get_attr_boolean(PurpleStatus * status, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_status_get_attr_boolean(IntPtr status, string id);
+
+ public static bool GetAttrBoolean(PurpleStatus status, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_status_get_attr_int(PurpleStatus * status, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_status_get_attr_int(IntPtr status, string id);
+
+ public static int GetAttrInt(PurpleStatus status, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_status_get_attr_string(PurpleStatus * status, char * id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_status_get_attr_string(IntPtr status, string id);
+
+ public static string GetAttrString(PurpleStatus status, string id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_status_compare(PurpleStatus * status1, PurpleStatus * status2)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_status_compare(IntPtr status1, IntPtr status2);
+
+ public static int Compare(PurpleStatus status1, PurpleStatus status2)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_presence_new(PurplePresenceContext context)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_new(UNKNOWN context);
+
+ public static PurplePresence PresenceNew(PurplePresenceContext context)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_presence_new_for_account(PurpleAccount * account)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_new_for_account(IntPtr account);
+
+ public static PurplePresence PresenceNewForAccount(PurpleAccount account)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_presence_new_for_conv(PurpleConversation * conv)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_new_for_conv(IntPtr conv);
+
+ public static PurplePresence PresenceNewForConv(PurpleConversation conv)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresence * purple_presence_new_for_buddy(PurpleBuddy * buddy)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_new_for_buddy(IntPtr buddy);
+
+ public static PurplePresence PresenceNewForBuddy(PurpleBuddy buddy)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_destroy(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_destroy(IntPtr presence);
+
+ public static void PresenceDestroy(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_add_status(PurplePresence * presence, PurpleStatus * status)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_add_status(IntPtr presence, IntPtr status);
+
+ public static void PresenceAddStatus(PurplePresence presence, PurpleStatus status)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_add_list(PurplePresence * presence, GList * source_list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_add_list(IntPtr presence, IntPtr source_list);
+
+ public static void PresenceAddList(PurplePresence presence, GList source_list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_set_status_active(PurplePresence * presence, char * status_id, gboolean active)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_set_status_active(IntPtr presence, string status_id, bool active);
+
+ public static void PresenceSetStatusActive(PurplePresence presence, string status_id, bool active)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_switch_status(PurplePresence * presence, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_switch_status(IntPtr presence, string status_id);
+
+ public static void PresenceSwitchStatus(PurplePresence presence, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_set_idle(PurplePresence * presence, gboolean idle, time_t idle_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_set_idle(IntPtr presence, bool idle, UNKNOWN idle_time);
+
+ public static void PresenceSetIdle(PurplePresence presence, bool idle, time_t idle_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_presence_set_login_time(PurplePresence * presence, time_t login_time)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_presence_set_login_time(IntPtr presence, UNKNOWN login_time);
+
+ public static void PresenceSetLoginTime(PurplePresence presence, time_t login_time)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurplePresenceContext purple_presence_get_context(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_presence_get_context(IntPtr presence);
+
+ public static PurplePresenceContext PresenceGetContext(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleAccount * purple_presence_get_account(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_account(IntPtr presence);
+
+ public static PurpleAccount PresenceGetAccount(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleConversation * purple_presence_get_conversation(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_conversation(IntPtr presence);
+
+ public static PurpleConversation PresenceGetConversation(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_presence_get_chat_user(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_presence_get_chat_user(IntPtr presence);
+
+ public static string PresenceGetChatUser(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleBuddy * purple_presence_get_buddy(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_buddy(IntPtr presence);
+
+ public static PurpleBuddy PresenceGetBuddy(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_presence_get_statuses(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_statuses(IntPtr presence);
+
+ public static GList PresenceGetStatuses(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatus * purple_presence_get_status(PurplePresence * presence, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_status(IntPtr presence, string status_id);
+
+ public static PurpleStatus PresenceGetStatus(PurplePresence presence, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStatus * purple_presence_get_active_status(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_presence_get_active_status(IntPtr presence);
+
+ public static PurpleStatus PresenceGetActiveStatus(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_presence_is_available(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_presence_is_available(IntPtr presence);
+
+ public static bool PresenceIsAvailable(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_presence_is_online(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_presence_is_online(IntPtr presence);
+
+ public static bool PresenceIsOnline(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_presence_is_status_active(PurplePresence * presence, char * status_id)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_presence_is_status_active(IntPtr presence, string status_id);
+
+ public static bool PresenceIsStatusActive(PurplePresence presence, string status_id)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_presence_is_status_primitive_active(PurplePresence * presence, PurpleStatusPrimitive primitive)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_presence_is_status_primitive_active(IntPtr presence, UNKNOWN primitive);
+
+ public static bool PresenceIsStatusPrimitiveActive(PurplePresence presence, PurpleStatusPrimitive primitive)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_presence_is_idle(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_presence_is_idle(IntPtr presence);
+
+ public static bool PresenceIsIdle(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_presence_get_idle_time(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_presence_get_idle_time(IntPtr presence);
+
+ public static time_t PresenceGetIdleTime(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_presence_get_login_time(PurplePresence * presence)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_presence_get_login_time(IntPtr presence);
+
+ public static time_t PresenceGetLoginTime(PurplePresence presence)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint purple_presence_compare(PurplePresence * presence1, PurplePresence * presence2)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_presence_compare(IntPtr presence1, IntPtr presence2);
+
+ public static int PresenceCompare(PurplePresence presence1, PurplePresence presence2)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_status_get_handle()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_status_get_handle();
+
+ public static IntPtr GetHandle()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_status_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_status_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Stringref.cs cb8fae5638d0f19730bdf5f89c13b5f0ffa858eb
+++ libpurple/wrapper/Stringref.cs cb8fae5638d0f19730bdf5f89c13b5f0ffa858eb
@@ -0,0 +1,131 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Stringref
+ {
+ /*
+ * PurpleStringref * purple_stringref_new(char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_stringref_new(string value);
+
+ public static PurpleStringref New(string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStringref * purple_stringref_new_noref(char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_stringref_new_noref(string value);
+
+ public static PurpleStringref NewNoref(string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStringref * purple_stringref_printf(char * format, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_stringref_printf(string format, ...);
+
+ public static PurpleStringref Printf(string format, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleStringref * purple_stringref_ref(PurpleStringref * stringref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_stringref_ref(IntPtr stringref);
+
+ public static PurpleStringref Ref(PurpleStringref stringref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_stringref_unref(PurpleStringref * stringref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_stringref_unref(IntPtr stringref);
+
+ public static void Unref(PurpleStringref stringref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_stringref_value(PurpleStringref * stringref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_stringref_value(IntPtr stringref);
+
+ public static string Value(PurpleStringref stringref)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_stringref_cmp(PurpleStringref * s1, PurpleStringref * s2)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_stringref_cmp(IntPtr s1, IntPtr s2);
+
+ public static int Cmp(PurpleStringref s1, PurpleStringref s2)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * size_t purple_stringref_len(PurpleStringref * stringref)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_stringref_len(IntPtr stringref);
+
+ public static size_t Len(PurpleStringref stringref)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Stun.cs 823ec1061beb72e0731adc751d4a97c29a41024a
+++ libpurple/wrapper/Stun.cs 823ec1061beb72e0731adc751d4a97c29a41024a
@@ -0,0 +1,65 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Stun
+ {
+ /*
+ * PurpleStunNatDiscovery * purple_stun_discover(StunCallback cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_stun_discover(UNKNOWN cb);
+
+ public static PurpleStunNatDiscovery Discover(StunCallback cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_stun_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_stun_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Theme.cs a873f44078f3d2b5cf679a8a65eff307abb6fb29
+++ libpurple/wrapper/Theme.cs a873f44078f3d2b5cf679a8a65eff307abb6fb29
@@ -0,0 +1,186 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Theme
+ {
+ /*
+ * GType purple_theme_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_theme_get_type();
+
+ public static GType GetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_name(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_name(IntPtr theme);
+
+ public static string GetName(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_set_name(PurpleTheme * theme, gchar * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_set_name(IntPtr theme, string name);
+
+ public static void SetName(PurpleTheme theme, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_description(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_description(IntPtr theme);
+
+ public static string GetDescription(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_set_description(PurpleTheme * theme, gchar * description)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_set_description(IntPtr theme, string description);
+
+ public static void SetDescription(PurpleTheme theme, string description)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_author(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_author(IntPtr theme);
+
+ public static string GetAuthor(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_set_author(PurpleTheme * theme, gchar * author)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_set_author(IntPtr theme, string author);
+
+ public static void SetAuthor(PurpleTheme theme, string author)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_type_string(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_type_string(IntPtr theme);
+
+ public static string GetTypeString(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_dir(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_dir(IntPtr theme);
+
+ public static string GetDir(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_set_dir(PurpleTheme * theme, gchar * dir)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_set_dir(IntPtr theme, string dir);
+
+ public static void SetDir(PurpleTheme theme, string dir)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_image(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_image(IntPtr theme);
+
+ public static string GetImage(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_get_image_full(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_get_image_full(IntPtr theme);
+
+ public static string GetImageFull(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_set_image(PurpleTheme * theme, gchar * img)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_set_image(IntPtr theme, string img);
+
+ public static void SetImage(PurpleTheme theme, string img)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/ThemeLoader.cs c14ce89a6a75a3a91bb1febb0f757979b55b1935
+++ libpurple/wrapper/ThemeLoader.cs c14ce89a6a75a3a91bb1febb0f757979b55b1935
@@ -0,0 +1,76 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class ThemeLoader
+ {
+ /*
+ * GType purple_theme_loader_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_theme_loader_get_type();
+
+ public static GType ThemeLoaderGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_theme_loader_get_type_string(PurpleThemeLoader * self)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_theme_loader_get_type_string(IntPtr self);
+
+ public static string ThemeLoaderGetTypeString(PurpleThemeLoader self)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleTheme * purple_theme_loader_build(PurpleThemeLoader * loader, gchar * dir)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_theme_loader_build(IntPtr loader, string dir);
+
+ public static PurpleTheme ThemeLoaderBuild(PurpleThemeLoader loader, string dir)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/ThemeManager.cs d66bc75c091f8a5b9a2746eddcf760a87648c593
+++ libpurple/wrapper/ThemeManager.cs d66bc75c091f8a5b9a2746eddcf760a87648c593
@@ -0,0 +1,153 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class ThemeManager
+ {
+ /*
+ * GType purple_theme_manager_get_type()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_theme_manager_get_type();
+
+ public static GType ThemeManagerGetType()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_init();
+
+ public static void ThemeManagerInit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_uninit();
+
+ public static void ThemeManagerUninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_refresh()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_refresh();
+
+ public static void ThemeManagerRefresh()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleTheme * purple_theme_manager_find_theme(gchar * name, gchar * type)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_theme_manager_find_theme(string name, string type);
+
+ public static PurpleTheme ThemeManagerFindTheme(string name, string type)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_add_theme(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_add_theme(IntPtr theme);
+
+ public static void ThemeManagerAddTheme(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_remove_theme(PurpleTheme * theme)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_remove_theme(IntPtr theme);
+
+ public static void ThemeManagerRemoveTheme(PurpleTheme theme)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_register_type(PurpleThemeLoader * loader)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_register_type(IntPtr loader);
+
+ public static void ThemeManagerRegisterType(PurpleThemeLoader loader)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_unregister_type(PurpleThemeLoader * loader)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_unregister_type(IntPtr loader);
+
+ public static void ThemeManagerUnregisterType(PurpleThemeLoader loader)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_theme_manager_for_each_theme(PTFunc func)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_theme_manager_for_each_theme(UNKNOWN func);
+
+ public static void ThemeManagerForEachTheme(PTFunc func)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Upnp.cs 47f3b76061e6611a90a1bd54d8420a2aa2fa7129
+++ libpurple/wrapper/Upnp.cs 47f3b76061e6611a90a1bd54d8420a2aa2fa7129
@@ -0,0 +1,98 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Upnp
+ {
+ /*
+ * void purple_upnp_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_upnp_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_upnp_discover(PurpleUPnPCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_upnp_discover(UNKNOWN cb, IntPtr cb_data);
+
+ public static void Discover(PurpleUPnPCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_upnp_cancel_port_mapping(UPnPMappingAddRemove * mapping_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_upnp_cancel_port_mapping(IntPtr mapping_data);
+
+ public static void CancelPortMapping(UPnPMappingAddRemove mapping_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * UPnPMappingAddRemove * purple_upnp_set_port_mapping(unsigned short, , PurpleUPnPCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_upnp_set_port_mapping(UNKNOWN short, UNKNOWN , UNKNOWN cb, IntPtr cb_data);
+
+ public static UPnPMappingAddRemove SetPortMapping(unsigned short, , PurpleUPnPCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * UPnPMappingAddRemove * purple_upnp_remove_port_mapping(unsigned short, , PurpleUPnPCallback cb, gpointer cb_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_upnp_remove_port_mapping(UNKNOWN short, UNKNOWN , UNKNOWN cb, IntPtr cb_data);
+
+ public static UPnPMappingAddRemove RemovePortMapping(unsigned short, , PurpleUPnPCallback cb, IntPtr cb_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Util.cs 376a59fd945abe66a83e00cdc2d152b2f97bd2bd
+++ libpurple/wrapper/Util.cs 376a59fd945abe66a83e00cdc2d152b2f97bd2bd
@@ -0,0 +1,1000 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Util
+ {
+ /*
+ * PurpleMenuAction * purple_menu_action_new(char * label, PurpleCallback callback, gpointer data, GList * children)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_menu_action_new(string label, UNKNOWN callback, IntPtr data, IntPtr children);
+
+ public static PurpleMenuAction MenuActionNew(string label, PurpleCallback callback, IntPtr data, GList children)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_menu_action_free(PurpleMenuAction * act)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_menu_action_free(IntPtr act);
+
+ public static void MenuActionFree(PurpleMenuAction act)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_set_current_song(char * title, char * artist, char * album)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_set_current_song(string title, string artist, string album);
+
+ public static void SetCurrentSong(string title, string artist, string album)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_init()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_init();
+
+ public static void Init()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_uninit()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_uninit();
+
+ public static void Uninit()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_base16_encode(guchar * data, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_base16_encode(IntPtr data, UNKNOWN len);
+
+ public static string Base16Encode(guchar data, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guchar * purple_base16_decode(char * str, gsize * ret_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_base16_decode(string str, IntPtr ret_len);
+
+ public static guchar Base16Decode(string str, gsize ret_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_base16_encode_chunked(guchar * data, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_base16_encode_chunked(IntPtr data, UNKNOWN len);
+
+ public static string Base16EncodeChunked(guchar data, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_base64_encode(guchar * data, gsize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_base64_encode(IntPtr data, UNKNOWN len);
+
+ public static string Base64Encode(guchar data, gsize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guchar * purple_base64_decode(char * str, gsize * ret_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_base64_decode(string str, IntPtr ret_len);
+
+ public static guchar Base64Decode(string str, gsize ret_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guchar * purple_quotedp_decode(char * str, gsize * ret_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_quotedp_decode(string str, IntPtr ret_len);
+
+ public static guchar QuotedpDecode(string str, gsize ret_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_mime_decode_field(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_mime_decode_field(string str);
+
+ public static string MimeDecodeField(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_utf8_strftime(char * format, struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_strftime(string format, UNKNOWN tm);
+
+ public static string Utf8Strftime(string format, struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_get_tzoff_str(struct tm, gboolean iso)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_get_tzoff_str(UNKNOWN tm, bool iso);
+
+ public static string GetTzoffStr(struct tm, bool iso)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_date_format_short(struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_date_format_short(UNKNOWN tm);
+
+ public static string DateFormatShort(struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_date_format_long(struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_date_format_long(UNKNOWN tm);
+
+ public static string DateFormatLong(struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_date_format_full(struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_date_format_full(UNKNOWN tm);
+
+ public static string DateFormatFull(struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_time_format(struct tm)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_time_format(UNKNOWN tm);
+
+ public static string TimeFormat(struct tm)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_time_build(int year, int month, int day, int hour, int min, int sec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_time_build(int year, int month, int day, int hour, int min, int sec);
+
+ public static time_t TimeBuild(int year, int month, int day, int hour, int min, int sec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * time_t purple_str_to_time(char * timestamp, gboolean utc, struct tm, long * tz_off, char ** rest)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_str_to_time(string timestamp, bool utc, UNKNOWN tm, IntPtr tz_off, IntPtr rest);
+
+ public static time_t StrToTime(string timestamp, bool utc, struct tm, long tz_off, char rest)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_markup_find_tag(char * needle, char * haystack, char ** start, char ** end, GData ** attributes)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_markup_find_tag(string needle, string haystack, IntPtr start, IntPtr end, IntPtr attributes);
+
+ public static bool MarkupFindTag(string needle, string haystack, char start, char end, GData attributes)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_markup_extract_info_field(char * str, int len, PurpleNotifyUserInfo * user_info, char * start_token, int skip, char * end_token, char check_value, char * no_value_token, char * display_name, gboolean is_link, char * link_prefix, PurpleInfoFieldFormatCallback format_cb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_markup_extract_info_field(string str, int len, IntPtr user_info, string start_token, int skip, string end_token, char check_value, string no_value_token, string display_name, bool is_link, string link_prefix, UNKNOWN format_cb);
+
+ public static bool MarkupExtractInfoField(string str, int len, PurpleNotifyUserInfo user_info, string start_token, int skip, string end_token, char check_value, string no_value_token, string display_name, bool is_link, string link_prefix, PurpleInfoFieldFormatCallback format_cb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_markup_html_to_xhtml(char * html, char ** dest_xhtml, char ** dest_plain)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_markup_html_to_xhtml(string html, IntPtr dest_xhtml, IntPtr dest_plain);
+
+ public static void MarkupHtmlToXhtml(string html, char dest_xhtml, char dest_plain)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_markup_strip_html(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_markup_strip_html(string str);
+
+ public static string MarkupStripHtml(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_markup_linkify(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_markup_linkify(string str);
+
+ public static string MarkupLinkify(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_unescape_html(char * html)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_unescape_html(string html);
+
+ public static string UnescapeHtml(string html)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_markup_slice(char * str, guint x, guint y)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_markup_slice(string str, uint x, uint y);
+
+ public static string MarkupSlice(string str, uint x, uint y)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_markup_get_tag_name(char * tag)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_markup_get_tag_name(string tag);
+
+ public static string MarkupGetTagName(string tag)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_markup_is_rtl(char * html)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_markup_is_rtl(string html);
+
+ public static bool MarkupIsRtl(string html)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_home_dir()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_home_dir();
+
+ public static string HomeDir()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_user_dir()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_user_dir();
+
+ public static string UserDir()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_set_user_dir(char * dir)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_set_user_dir(string dir);
+
+ public static void SetUserDir(string dir)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_build_dir(char * path, int mode)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_build_dir(string path, int mode);
+
+ public static int BuildDir(string path, int mode)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_util_write_data_to_file(char * filename, char * data, gssize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_util_write_data_to_file(string filename, string data, UNKNOWN size);
+
+ public static bool WriteDataToFile(string filename, string data, gssize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_util_write_data_to_file_absolute(char * filename_full, char * data, gssize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_util_write_data_to_file_absolute(string filename_full, string data, UNKNOWN size);
+
+ public static bool WriteDataToFileAbsolute(string filename_full, string data, gssize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * purple_util_read_xml_from_file(char * filename, char * description)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_util_read_xml_from_file(string filename, string description);
+
+ public static xmlnode ReadXmlFromFile(string filename, string description)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * FILE * purple_mkstemp(char ** path, gboolean binary)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_mkstemp(IntPtr path, bool binary);
+
+ public static FILE Mkstemp(char path, bool binary)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_util_get_image_checksum(gconstpointer image_data, size_t image_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_util_get_image_checksum(UNKNOWN image_data, UNKNOWN image_len);
+
+ public static string GetImageChecksum(gconstpointer image_data, size_t image_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_util_get_image_filename(gconstpointer image_data, size_t image_len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_util_get_image_filename(UNKNOWN image_data, UNKNOWN image_len);
+
+ public static string GetImageFilename(gconstpointer image_data, size_t image_len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_program_is_valid(char * program)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_program_is_valid(string program);
+
+ public static bool ProgramIsValid(string program)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_running_gnome()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_running_gnome();
+
+ public static bool RunningGnome()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_running_kde()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_running_kde();
+
+ public static bool RunningKde()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_running_osx()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_running_osx();
+
+ public static bool RunningOsx()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_fd_get_ip(int fd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_fd_get_ip(int fd);
+
+ public static string FdGetIp(int fd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_strequal(gchar * left, gchar * right)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_strequal(string left, string right);
+
+ public static bool Strequal(string left, string right)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_normalize(PurpleAccount * account, char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_normalize(IntPtr account, string str);
+
+ public static string Normalize(PurpleAccount account, string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_normalize_nocase(PurpleAccount * account, char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_normalize_nocase(IntPtr account, string str);
+
+ public static string NormalizeNocase(PurpleAccount account, string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_str_has_prefix(char * s, char * p)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_str_has_prefix(string s, string p);
+
+ public static bool StrHasPrefix(string s, string p)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_str_has_suffix(char * s, char * x)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_str_has_suffix(string s, string x);
+
+ public static bool StrHasSuffix(string s, string x)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_strdup_withhtml(gchar * src)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_strdup_withhtml(string src);
+
+ public static string StrdupWithhtml(string src)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_str_add_cr(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_str_add_cr(string str);
+
+ public static string StrAddCr(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_str_strip_char(char * str, char thechar)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_str_strip_char(string str, char thechar);
+
+ public static void StrStripChar(string str, char thechar)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_chrreplace(char * string, char delimiter, char replacement)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_chrreplace(string string, char delimiter, char replacement);
+
+ public static void Chrreplace(string string, char delimiter, char replacement)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_strreplace(char * string, char * delimiter, char * replacement)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_strreplace(string string, string delimiter, string replacement);
+
+ public static string Strreplace(string string, string delimiter, string replacement)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_utf8_ncr_encode(char * in)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_ncr_encode(string in);
+
+ public static string Utf8NcrEncode(string in)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_utf8_ncr_decode(char * in)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_ncr_decode(string in);
+
+ public static string Utf8NcrDecode(string in)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_strcasereplace(char * string, char * delimiter, char * replacement)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_strcasereplace(string string, string delimiter, string replacement);
+
+ public static string Strcasereplace(string string, string delimiter, string replacement)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_strcasestr(char * haystack, char * needle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_strcasestr(string haystack, string needle);
+
+ public static string Strcasestr(string haystack, string needle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_str_size_to_units(size_t size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_str_size_to_units(UNKNOWN size);
+
+ public static string StrSizeToUnits(size_t size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_str_seconds_to_string(guint sec)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_str_seconds_to_string(uint sec);
+
+ public static string StrSecondsToString(uint sec)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_str_binary_to_ascii(unsigned char, guint len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_str_binary_to_ascii(UNKNOWN char, uint len);
+
+ public static string StrBinaryToAscii(unsigned char, uint len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_got_protocol_handler_uri(char * uri)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_got_protocol_handler_uri(string uri);
+
+ public static void GotProtocolHandlerUri(string uri)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_url_parse(char * url, char ** ret_host, int * ret_port, char ** ret_path, char ** ret_user, char ** ret_passwd)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_url_parse(string url, IntPtr ret_host, IntPtr ret_port, IntPtr ret_path, IntPtr ret_user, IntPtr ret_passwd);
+
+ public static bool UrlParse(string url, char ret_host, int ret_port, char ret_path, char ret_user, char ret_passwd)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleUtilFetchUrlData * purple_util_fetch_url_request(gchar * url, gboolean full, gchar * user_agent, gboolean http11, gchar * request, gboolean include_headers, PurpleUtilFetchUrlCallback callback, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_util_fetch_url_request(string url, bool full, string user_agent, bool http11, string request, bool include_headers, UNKNOWN callback, IntPtr data);
+
+ public static PurpleUtilFetchUrlData FetchUrlRequest(string url, bool full, string user_agent, bool http11, string request, bool include_headers, PurpleUtilFetchUrlCallback callback, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleUtilFetchUrlData * purple_util_fetch_url_request_len(gchar * url, gboolean full, gchar * user_agent, gboolean http11, gchar * request, gboolean include_headers, gssize max_len, PurpleUtilFetchUrlCallback callback, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_util_fetch_url_request_len(string url, bool full, string user_agent, bool http11, string request, bool include_headers, UNKNOWN max_len, UNKNOWN callback, IntPtr data);
+
+ public static PurpleUtilFetchUrlData FetchUrlRequestLen(string url, bool full, string user_agent, bool http11, string request, bool include_headers, gssize max_len, PurpleUtilFetchUrlCallback callback, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleUtilFetchUrlData * purple_util_fetch_url_request_len_with_account(PurpleAccount * account, gchar * url, gboolean full, gchar * user_agent, gboolean http11, gchar * request, gboolean include_headers, gssize max_len, PurpleUtilFetchUrlCallback callback, gpointer data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_util_fetch_url_request_len_with_account(IntPtr account, string url, bool full, string user_agent, bool http11, string request, bool include_headers, UNKNOWN max_len, UNKNOWN callback, IntPtr data);
+
+ public static PurpleUtilFetchUrlData FetchUrlRequestLenWithAccount(PurpleAccount account, string url, bool full, string user_agent, bool http11, string request, bool include_headers, gssize max_len, PurpleUtilFetchUrlCallback callback, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_util_fetch_url_cancel(PurpleUtilFetchUrlData * url_data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_util_fetch_url_cancel(IntPtr url_data);
+
+ public static void FetchUrlCancel(PurpleUtilFetchUrlData url_data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_url_decode(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_url_decode(string str);
+
+ public static string UrlDecode(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_url_encode(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_url_encode(string str);
+
+ public static string UrlEncode(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_email_is_valid(char * address)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_email_is_valid(string address);
+
+ public static bool EmailIsValid(string address)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_ip_address_is_valid(char * ip)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_ip_address_is_valid(string ip);
+
+ public static bool IpAddressIsValid(string ip)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_uri_list_extract_uris(gchar * uri_list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_uri_list_extract_uris(string uri_list);
+
+ public static GList UriListExtractUris(string uri_list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * GList * purple_uri_list_extract_filenames(gchar * uri_list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_uri_list_extract_filenames(string uri_list);
+
+ public static GList UriListExtractFilenames(string uri_list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_utf8_try_convert(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_try_convert(string str);
+
+ public static string Utf8TryConvert(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_utf8_salvage(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_salvage(string str);
+
+ public static string Utf8Salvage(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_utf8_strip_unprintables(gchar * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_utf8_strip_unprintables(string str);
+
+ public static string Utf8StripUnprintables(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_gai_strerror(gint errnum)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_gai_strerror(int errnum);
+
+ public static string GaiStrerror(int errnum)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_utf8_strcasecmp(char * a, char * b)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_utf8_strcasecmp(string a, string b);
+
+ public static int Utf8Strcasecmp(string a, string b)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_utf8_has_word(char * haystack, char * needle)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_utf8_has_word(string haystack, string needle);
+
+ public static bool Utf8HasWord(string haystack, string needle)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_print_utf8_to_console(FILE * filestream, char * message)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_print_utf8_to_console(IntPtr filestream, string message);
+
+ public static void PrintUtf8ToConsole(FILE filestream, string message)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_message_meify(char * message, gssize len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_message_meify(string message, UNKNOWN len);
+
+ public static bool MessageMeify(string message, gssize len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_text_strip_mnemonic(char * in)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_text_strip_mnemonic(string in);
+
+ public static string TextStripMnemonic(string in)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_unescape_filename(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_unescape_filename(string str);
+
+ public static string UnescapeFilename(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_escape_filename(char * str)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_escape_filename(string str);
+
+ public static string EscapeFilename(string str)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * _purple_oscar_convert(char * act, char * protocol)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string _purple_oscar_convert(string act, string protocol);
+
+ public static string _purpleOscarConvert(string act, string protocol)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_restore_default_signal_handlers()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_restore_default_signal_handlers();
+
+ public static void RestoreDefaultSignalHandlers()
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gchar * purple_get_host_name()
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_get_host_name();
+
+ public static string GetHostName()
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Value.cs 3d651a60350de489b088a67dc19051ec38b1c7ef
+++ libpurple/wrapper/Value.cs 3d651a60350de489b088a67dc19051ec38b1c7ef
@@ -0,0 +1,483 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Value
+ {
+ /*
+ * PurpleValue * purple_value_new(PurpleType type, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_new(UNKNOWN type, ...);
+
+ public static PurpleValue New(PurpleType type, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleValue * purple_value_new_outgoing(PurpleType type, ...)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_new_outgoing(UNKNOWN type, ...);
+
+ public static PurpleValue NewOutgoing(PurpleType type, ...)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_destroy(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_destroy(IntPtr value);
+
+ public static void Destroy(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleValue * purple_value_dup(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_dup(IntPtr value);
+
+ public static PurpleValue Dup(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleType purple_value_get_type(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern UNKNOWN purple_value_get_type(IntPtr value);
+
+ public static PurpleType GetType(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_value_get_subtype(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_value_get_subtype(IntPtr value);
+
+ public static int GetSubtype(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_value_get_specific_type(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_value_get_specific_type(IntPtr value);
+
+ public static string GetSpecificType(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_value_is_outgoing(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_value_is_outgoing(IntPtr value);
+
+ public static bool IsOutgoing(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_char(PurpleValue * value, char data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_char(IntPtr value, char data);
+
+ public static void SetChar(PurpleValue value, char data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_uchar(PurpleValue * value, unsigned char)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_uchar(IntPtr value, UNKNOWN char);
+
+ public static void SetUchar(PurpleValue value, unsigned char)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_boolean(PurpleValue * value, gboolean data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_boolean(IntPtr value, bool data);
+
+ public static void SetBoolean(PurpleValue value, bool data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_short(PurpleValue * value, short data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_short(IntPtr value, short data);
+
+ public static void SetShort(PurpleValue value, short data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_ushort(PurpleValue * value, unsigned short)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_ushort(IntPtr value, UNKNOWN short);
+
+ public static void SetUshort(PurpleValue value, unsigned short)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_int(PurpleValue * value, int data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_int(IntPtr value, int data);
+
+ public static void SetInt(PurpleValue value, int data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_uint(PurpleValue * value, unsigned int)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_uint(IntPtr value, UNKNOWN int);
+
+ public static void SetUint(PurpleValue value, unsigned int)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_long(PurpleValue * value, long data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_long(IntPtr value, long data);
+
+ public static void SetLong(PurpleValue value, long data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_ulong(PurpleValue * value, unsigned long)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_ulong(IntPtr value, UNKNOWN long);
+
+ public static void SetUlong(PurpleValue value, unsigned long)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_int64(PurpleValue * value, gint64 data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_int64(IntPtr value, long data);
+
+ public static void SetInt64(PurpleValue value, long data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_uint64(PurpleValue * value, guint64 data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_uint64(IntPtr value, ulong data);
+
+ public static void SetUint64(PurpleValue value, ulong data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_string(PurpleValue * value, char * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_string(IntPtr value, string data);
+
+ public static void SetString(PurpleValue value, string data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_object(PurpleValue * value, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_object(IntPtr value, IntPtr data);
+
+ public static void SetObject(PurpleValue value, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_pointer(PurpleValue * value, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_pointer(IntPtr value, IntPtr data);
+
+ public static void SetPointer(PurpleValue value, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_enum(PurpleValue * value, int data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_enum(IntPtr value, int data);
+
+ public static void SetEnum(PurpleValue value, int data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_value_set_boxed(PurpleValue * value, void * data)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_value_set_boxed(IntPtr value, IntPtr data);
+
+ public static void SetBoxed(PurpleValue value, IntPtr data)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char purple_value_get_char(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern char purple_value_get_char(IntPtr value);
+
+ public static char GetChar(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char purple_value_get_uchar(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern char purple_value_get_uchar(IntPtr value);
+
+ public static char GetUchar(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_value_get_boolean(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_value_get_boolean(IntPtr value);
+
+ public static bool GetBoolean(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * short purple_value_get_short(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern short purple_value_get_short(IntPtr value);
+
+ public static short GetShort(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * short purple_value_get_ushort(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern short purple_value_get_ushort(IntPtr value);
+
+ public static short GetUshort(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_value_get_int(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_value_get_int(IntPtr value);
+
+ public static int GetInt(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_value_get_uint(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_value_get_uint(IntPtr value);
+
+ public static int GetUint(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * long purple_value_get_long(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern long purple_value_get_long(IntPtr value);
+
+ public static long GetLong(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * long purple_value_get_ulong(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern long purple_value_get_ulong(IntPtr value);
+
+ public static long GetUlong(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gint64 purple_value_get_int64(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern long purple_value_get_int64(IntPtr value);
+
+ public static long GetInt64(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * guint64 purple_value_get_uint64(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern ulong purple_value_get_uint64(IntPtr value);
+
+ public static ulong GetUint64(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * purple_value_get_string(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_value_get_string(IntPtr value);
+
+ public static string GetString(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_value_get_object(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_get_object(IntPtr value);
+
+ public static IntPtr GetObject(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_value_get_pointer(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_get_pointer(IntPtr value);
+
+ public static IntPtr GetPointer(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * int purple_value_get_enum(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern int purple_value_get_enum(IntPtr value);
+
+ public static int GetEnum(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void * purple_value_get_boxed(PurpleValue * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_value_get_boxed(IntPtr value);
+
+ public static IntPtr GetBoxed(PurpleValue value)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Version.cs a4d8a9939b8d1c70321f3a283d3e3a563da93b6a
+++ libpurple/wrapper/Version.cs a4d8a9939b8d1c70321f3a283d3e3a563da93b6a
@@ -0,0 +1,54 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Version
+ {
+ /*
+ * char * purple_version_check(guint required_major, guint required_minor, guint required_micro)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string purple_version_check(uint required_major, uint required_minor, uint required_micro);
+
+ public static string Check(uint required_major, uint required_minor, uint required_micro)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/Whiteboard.cs 97fab946749d74fd83157bcaced1dfcfda28caa2
+++ libpurple/wrapper/Whiteboard.cs 97fab946749d74fd83157bcaced1dfcfda28caa2
@@ -0,0 +1,230 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Whiteboard
+ {
+ /*
+ * void purple_whiteboard_set_ui_ops(PurpleWhiteboardUiOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_set_ui_ops(IntPtr ops);
+
+ public static void SetUiOps(PurpleWhiteboardUiOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_set_prpl_ops(PurpleWhiteboard * wb, PurpleWhiteboardPrplOps * ops)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_set_prpl_ops(IntPtr wb, IntPtr ops);
+
+ public static void SetPrplOps(PurpleWhiteboard wb, PurpleWhiteboardPrplOps ops)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleWhiteboard * purple_whiteboard_create(PurpleAccount * account, char * who, int state)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_whiteboard_create(IntPtr account, string who, int state);
+
+ public static PurpleWhiteboard Create(PurpleAccount account, string who, int state)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_destroy(PurpleWhiteboard * wb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_destroy(IntPtr wb);
+
+ public static void Destroy(PurpleWhiteboard wb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_start(PurpleWhiteboard * wb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_start(IntPtr wb);
+
+ public static void Start(PurpleWhiteboard wb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * PurpleWhiteboard * purple_whiteboard_get_session(PurpleAccount * account, char * who)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr purple_whiteboard_get_session(IntPtr account, string who);
+
+ public static PurpleWhiteboard GetSession(PurpleAccount account, string who)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_draw_list_destroy(GList * draw_list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_draw_list_destroy(IntPtr draw_list);
+
+ public static void DrawListDestroy(GList draw_list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_whiteboard_get_dimensions(PurpleWhiteboard * wb, int * width, int * height)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_whiteboard_get_dimensions(IntPtr wb, IntPtr width, IntPtr height);
+
+ public static bool GetDimensions(PurpleWhiteboard wb, int width, int height)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_set_dimensions(PurpleWhiteboard * wb, int width, int height)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_set_dimensions(IntPtr wb, int width, int height);
+
+ public static void SetDimensions(PurpleWhiteboard wb, int width, int height)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_draw_point(PurpleWhiteboard * wb, int x, int y, int color, int size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_draw_point(IntPtr wb, int x, int y, int color, int size);
+
+ public static void DrawPoint(PurpleWhiteboard wb, int x, int y, int color, int size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_send_draw_list(PurpleWhiteboard * wb, GList * list)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_send_draw_list(IntPtr wb, IntPtr list);
+
+ public static void SendDrawList(PurpleWhiteboard wb, GList list)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_draw_line(PurpleWhiteboard * wb, int x1, int y1, int x2, int y2, int color, int size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_draw_line(IntPtr wb, int x1, int y1, int x2, int y2, int color, int size);
+
+ public static void DrawLine(PurpleWhiteboard wb, int x1, int y1, int x2, int y2, int color, int size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_clear(PurpleWhiteboard * wb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_clear(IntPtr wb);
+
+ public static void Clear(PurpleWhiteboard wb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_send_clear(PurpleWhiteboard * wb)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_send_clear(IntPtr wb);
+
+ public static void SendClear(PurpleWhiteboard wb)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_send_brush(PurpleWhiteboard * wb, int size, int color)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_send_brush(IntPtr wb, int size, int color);
+
+ public static void SendBrush(PurpleWhiteboard wb, int size, int color)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * gboolean purple_whiteboard_get_brush(PurpleWhiteboard * wb, int * size, int * color)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern bool purple_whiteboard_get_brush(IntPtr wb, IntPtr size, IntPtr color);
+
+ public static bool GetBrush(PurpleWhiteboard wb, int size, int color)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void purple_whiteboard_set_brush(PurpleWhiteboard * wb, int size, int color)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void purple_whiteboard_set_brush(IntPtr wb, int size, int color);
+
+ public static void SetBrush(PurpleWhiteboard wb, int size, int color)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
============================================================
--- libpurple/wrapper/proto_chat_entry.cs 3394e3c6b3253cb6ba62bd6d3bd6510802848ac4
+++ libpurple/wrapper/proto_chat_entry.cs 3394e3c6b3253cb6ba62bd6d3bd6510802848ac4
@@ -0,0 +1,199 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class proto_chat_entry : UnmanagedWrapper<_proto_chat_entry>
+ {
+ public proto_chat_entry()
+ {
+ }
+
+ public proto_chat_entry(IntPtr refernece)
+ {
+ this.Reference = reference;
+ this.Data = (_proto_chat_entry)Marshal.PtrToStructure(this.Reference, typeof(_proto_chat_entry));
+ }
+
+ public const char *label
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public const char *identifier
+ {
+ get
+ {
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ throw new NotImplementedException(); /* Non-native type. */
+ }
+ }
+
+ public bool required
+ {
+ get
+ {
+ return this.Data.required;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.required = value;
+ }
+ }
+
+ public bool is_int
+ {
+ get
+ {
+ return this.Data.is_int;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.is_int = value;
+ }
+ }
+
+ public int min
+ {
+ get
+ {
+ return this.Data.min;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.min = value;
+ }
+ }
+
+ public int max
+ {
+ get
+ {
+ return this.Data.max;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.max = value;
+ }
+ }
+
+ public bool secret
+ {
+ get
+ {
+ return this.Data.secret;
+ }
+ set
+ {
+ if (this.Reference != IntPtr.Zero)
+ this.Reference = IntPtr.Zero;
+
+ this.Data.secret = value;
+ }
+ }
+
+ }
+
+
+ [StructLayout(LayoutKind.Sequential)]
+ class _proto_chat_entry
+ {
+ /*
+ * const char *label
+ */
+ UNKNOWN char *label;
+
+ /*
+ * const char *identifier
+ */
+ UNKNOWN char *identifier;
+
+ /*
+ * gboolean required
+ */
+ bool required;
+
+ /*
+ * gboolean is_int
+ */
+ bool is_int;
+
+ /*
+ * int min
+ */
+ int min;
+
+ /*
+ * int max
+ */
+ int max;
+
+ /*
+ * gboolean secret
+ */
+ bool secret;
+
+ }
+}
+
============================================================
--- libpurple/wrapper/xmlnode.cs d4d9103312ef7dfb6c79d4d9964400c1724f5686
+++ libpurple/wrapper/xmlnode.cs d4d9103312ef7dfb6c79d4d9964400c1724f5686
@@ -0,0 +1,351 @@
+/* purple
+ *
+ * Purple is the legal property of its developers, whose names are too numerous
+ * to list here. Please refer to the COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*
+ * This file was auto-generated from the libpurple header files to provide a
+ * clean interface between .NET/CLR and the unmanaged C library, libpurple.
+ *
+ * This code isn't complete, but completely a work in progress. :)
+ * Three major things left:
+ * - Resolve the remaining UNKNOWN types.
+ * - Handle translation between delegate and function pointers.
+ * - Fill in the translation between public .NET class calls and private DllImport[] calls.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace PurpleWrapper
+{
+ public class Xmlnode
+ {
+ /*
+ * xmlnode * xmlnode_new(char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_new(string name);
+
+ public static xmlnode New(string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_new_child(xmlnode * parent, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_new_child(IntPtr parent, string name);
+
+ public static xmlnode NewChild(xmlnode parent, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_insert_child(xmlnode * parent, xmlnode * child)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_insert_child(IntPtr parent, IntPtr child);
+
+ public static void InsertChild(xmlnode parent, xmlnode child)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_get_child(xmlnode * parent, char * name)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_get_child(IntPtr parent, string name);
+
+ public static xmlnode GetChild(xmlnode parent, string name)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_get_child_with_namespace(xmlnode * parent, char * name, char * xmlns)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_get_child_with_namespace(IntPtr parent, string name, string xmlns);
+
+ public static xmlnode GetChildWithNamespace(xmlnode parent, string name, string xmlns)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_get_next_twin(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_get_next_twin(IntPtr node);
+
+ public static xmlnode GetNextTwin(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_insert_data(xmlnode * node, char * data, gssize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_insert_data(IntPtr node, string data, UNKNOWN size);
+
+ public static void InsertData(xmlnode node, string data, gssize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_data(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_data(IntPtr node);
+
+ public static string GetData(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_data_unescaped(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_data_unescaped(IntPtr node);
+
+ public static string GetDataUnescaped(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_attrib(xmlnode * node, char * attr, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_attrib(IntPtr node, string attr, string value);
+
+ public static void SetAttrib(xmlnode node, string attr, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_attrib_with_prefix(xmlnode * node, char * attr, char * prefix, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_attrib_with_prefix(IntPtr node, string attr, string prefix, string value);
+
+ public static void SetAttribWithPrefix(xmlnode node, string attr, string prefix, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_attrib_with_namespace(xmlnode * node, char * attr, char * xmlns, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_attrib_with_namespace(IntPtr node, string attr, string xmlns, string value);
+
+ public static void SetAttribWithNamespace(xmlnode node, string attr, string xmlns, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_attrib_full(xmlnode * node, char * attr, char * xmlns, char * prefix, char * value)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_attrib_full(IntPtr node, string attr, string xmlns, string prefix, string value);
+
+ public static void SetAttribFull(xmlnode node, string attr, string xmlns, string prefix, string value)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_attrib(xmlnode * node, char * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_attrib(IntPtr node, string attr);
+
+ public static string GetAttrib(xmlnode node, string attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_attrib_with_namespace(xmlnode * node, char * attr, char * xmlns)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_attrib_with_namespace(IntPtr node, string attr, string xmlns);
+
+ public static string GetAttribWithNamespace(xmlnode node, string attr, string xmlns)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_remove_attrib(xmlnode * node, char * attr)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_remove_attrib(IntPtr node, string attr);
+
+ public static void RemoveAttrib(xmlnode node, string attr)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_remove_attrib_with_namespace(xmlnode * node, char * attr, char * xmlns)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_remove_attrib_with_namespace(IntPtr node, string attr, string xmlns);
+
+ public static void RemoveAttribWithNamespace(xmlnode node, string attr, string xmlns)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_namespace(xmlnode * node, char * xmlns)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_namespace(IntPtr node, string xmlns);
+
+ public static void SetNamespace(xmlnode node, string xmlns)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_namespace(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_namespace(IntPtr node);
+
+ public static string GetNamespace(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_set_prefix(xmlnode * node, char * prefix)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_set_prefix(IntPtr node, string prefix);
+
+ public static void SetPrefix(xmlnode node, string prefix)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_get_prefix(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_get_prefix(IntPtr node);
+
+ public static string GetPrefix(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_get_parent(xmlnode * child)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_get_parent(IntPtr child);
+
+ public static xmlnode GetParent(xmlnode child)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_to_str(xmlnode * node, int * len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_to_str(IntPtr node, IntPtr len);
+
+ public static string ToStr(xmlnode node, int len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * char * xmlnode_to_formatted_str(xmlnode * node, int * len)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern string xmlnode_to_formatted_str(IntPtr node, IntPtr len);
+
+ public static string ToFormattedStr(xmlnode node, int len)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_from_str(char * str, gssize size)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_from_str(string str, UNKNOWN size);
+
+ public static xmlnode FromStr(string str, gssize size)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_copy(xmlnode * src)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_copy(IntPtr src);
+
+ public static xmlnode Copy(xmlnode src)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * void xmlnode_free(xmlnode * node)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern void xmlnode_free(IntPtr node);
+
+ public static void Free(xmlnode node)
+ {
+ throw new NotImplementedException();
+ }
+
+ /*
+ * xmlnode * xmlnode_from_file(char * dir, char * filename, char * description, char * process)
+ */
+ [DllImport("libpurple.dll")]
+ private static extern IntPtr xmlnode_from_file(string dir, string filename, string description, string process);
+
+ public static xmlnode FromFile(string dir, string filename, string description, string process)
+ {
+ throw new NotImplementedException();
+ }
+
+ }
+}
+
More information about the Commits
mailing list