diff --git a/src/plugins/backends/snarl/CMakeLists.txt b/src/plugins/backends/snarl/CMakeLists.txt
index 392b5ae..46a5263 100644
--- a/src/plugins/backends/snarl/CMakeLists.txt
+++ b/src/plugins/backends/snarl/CMakeLists.txt
@@ -10,7 +10,7 @@ if(WIN32)
     add_library(snarl MODULE ${SNARL_SRC} )
     target_link_libraries(snarl snorecore ${QT_QTCORE_LIBRARY} )
     if(MINGW)
-        set_target_properties(snarl PROPERTIES COMPILE_FLAGS "-Wno-conversion-null")
+        set_target_properties(snarl PROPERTIES COMPILE_FLAGS "-Wno-conversion-null -Wno-unused")
     endif(MINGW)
 
     install(TARGETS snarl ${SNORE_BACKEND_INSTALL_PATH})
diff --git a/src/plugins/backends/snarl/SnarlInterface.cpp b/src/plugins/backends/snarl/SnarlInterface.cpp
index 37bccfe..c61a6a9 100644
--- a/src/plugins/backends/snarl/SnarlInterface.cpp
+++ b/src/plugins/backends/snarl/SnarlInterface.cpp
@@ -31,6 +31,9 @@
 /// </summary>
 ///----------------------------------------------------------------------------
 /// <VersionHistory>
+///  2011-07-31 : General update to match VB6 SVN rev. 232
+///             : Added AppFlags and MessagePriority enums.
+///  2011-07-12 : MingW64 fixes by Patrick von Reth
 ///  2011-07-07 : Some changes to compile under VS2008
 ///                 - Changed vector iterators to begin/end instead of cbegin/cend
 ///                 - Removed const in PairType
@@ -54,11 +57,11 @@ namespace V42 {
 
 // workaround for mingw-w64 bug
 #ifdef __MINGW64_VERSION_MAJOR
-	extern "C" {
+    extern "C" {
         __declspec(dllimport) errno_t __cdecl strcpy_s(char * _Dst, size_t _SizeInBytes, const char *_Src);
         __declspec(dllimport) errno_t __cdecl wcscpy_s(wchar_t * _Dst, size_t _SizeInBytes, const wchar_t *_Src);
-		__declspec(dllimport) errno_t __cdecl strncat_s(char *_Dst, size_t _DstSizeInChars, const char *_Src, size_t _MaxCount);
-	}
+        __declspec(dllimport) errno_t __cdecl strncat_s(char *_Dst, size_t _DstSizeInChars, const char *_Src, size_t _MaxCount);
+    }
 #endif //__MINGW64_VERSION_MAJOR
 
 
@@ -68,151 +71,155 @@ namespace V42 {
 
 UINT SnarlInterface::AppMsg()
 {
-	return RegisterWindowMessage(SnarlAppMsg);
+    return RegisterWindowMessage(SnarlAppMsg);
 }
 
 UINT SnarlInterface::Broadcast()
 {
-	return RegisterWindowMessage(SnarlGlobalMsg);
+    return RegisterWindowMessage(SnarlGlobalMsg);
 }
 
 LONG32 SnarlInterface::DoRequest(LPCSTR request, UINT replyTimeout)
 {
-	DWORD_PTR nResult = 0;
+    DWORD_PTR nResult = 0;
 
-	HWND hWnd = GetSnarlWindow();
-	if (!IsWindow(hWnd))
-		return -SnarlEnums::ErrorNotRunning;
+    HWND hWnd = GetSnarlWindow();
+    if (!IsWindow(hWnd))
+        return -SnarlEnums::ErrorNotRunning;
 
-	// Create COPYDATASTRUCT
-	COPYDATASTRUCT cds;
-	cds.dwData = 0x534E4C03;           // "SNL",3
-	cds.cbData = (DWORD)strlen(request);      // No knowledge of max string lenght
-	cds.lpData = const_cast<char*>(request);
+    // Create COPYDATASTRUCT
+    COPYDATASTRUCT cds;
+    cds.dwData = 0x534E4C03;           // "SNL",3
+    cds.cbData = (DWORD)strlen(request);      // No knowledge of max string lenght
+    cds.lpData = const_cast<char*>(request);
 
-	// Send message
-	if (SendMessageTimeout(hWnd, WM_COPYDATA, (WPARAM)GetCurrentProcessId(), (LPARAM)&cds, SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG, replyTimeout, &nResult) == 0)
-	{
-		DWORD nError = GetLastError();
-		if (nError == ERROR_TIMEOUT)
-			nResult = -SnarlEnums::ErrorTimedOut;
-		else
-			nResult = -SnarlEnums::ErrorFailed;
-	}
+    // Send message
+    if (SendMessageTimeout(hWnd, WM_COPYDATA, (WPARAM)GetCurrentProcessId(), (LPARAM)&cds, SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG, replyTimeout, &nResult) == 0)
+    {
+        // Handle error
+        DWORD nError = GetLastError();
+        LONG32 errorResult = 0;
+        if (nError == ERROR_TIMEOUT)
+            errorResult = -SnarlEnums::ErrorTimedOut;
+        else
+            errorResult = -SnarlEnums::ErrorFailed;
 
-	return (LONG32)nResult;
+        return errorResult;
+    }
+    else
+        return (LONG32)nResult;
 }
 
 LONG32 SnarlInterface::DoRequest(LPCWSTR request, UINT replyTimeout)
 {
-	LONG32 nResult = 0;
+    LONG32 nResult = 0;
 
-	// Convert to UTF8
-	LPSTR utf8Request = WideToUTF8(request);
-	if (utf8Request == NULL)
-		return -SnarlEnums::ErrorCppInterface;
+    // Convert to UTF8
+    LPSTR utf8Request = WideToUTF8(request);
+    if (utf8Request == NULL)
+        return -SnarlEnums::ErrorCppInterface;
 
-	nResult = DoRequest(utf8Request, replyTimeout);
+    nResult = DoRequest(utf8Request, replyTimeout);
 
-	// Cleanup and return result
-	FreeString(utf8Request);
-	return nResult;
+    // Cleanup and return result
+    FreeString(utf8Request);
+    return nResult;
 }
 
-
 std::basic_string<char>& SnarlInterface::Escape(std::basic_string<char>& str)
 {
-	std::basic_string<char>::size_type strLength = str.length();
-	for (std::basic_string<char>::size_type i = 0; i < strLength; ++i)
-	{
-		if (str.at(i) == '=') {
-			str.insert(++i, "=");
-			++strLength;
-		}
-		else if (str[i] == '&') {
-			str.insert(++i, "&");
-			++strLength;
-		}
-	}
+    std::basic_string<char>::size_type strLength = str.length();
+    for (std::basic_string<char>::size_type i = 0; i < strLength; ++i)
+    {
+        if (str.at(i) == '=') {
+            str.insert(++i, "=");
+            ++strLength;
+        }
+        else if (str[i] == '&') {
+            str.insert(++i, "&");
+            ++strLength;
+        }
+    }
 
-	return str;
+    return str;
 }
 
 std::basic_string<wchar_t>& SnarlInterface::Escape(std::basic_string<wchar_t>& str)
 {
-	std::basic_string<wchar_t>::size_type strLength = str.length();
-	for (std::basic_string<wchar_t>::size_type i = 0; i < strLength; ++i)
-	{
-		if (str.at(i) == L'=') {
-			str.insert(++i, L"=");
-			++strLength;
-		}
-		else if (str[i] == L'&') {
-			str.insert(++i, L"&");
-			++strLength;
-		}
-	}
+    std::basic_string<wchar_t>::size_type strLength = str.length();
+    for (std::basic_string<wchar_t>::size_type i = 0; i < strLength; ++i)
+    {
+        if (str.at(i) == L'=') {
+            str.insert(++i, L"=");
+            ++strLength;
+        }
+        else if (str[i] == L'&') {
+            str.insert(++i, L"&");
+            ++strLength;
+        }
+    }
 
-	return str;
+    return str;
 }
 
 LPCTSTR SnarlInterface::GetAppPath()
 {
-	HWND hWnd = GetSnarlWindow();
-	if (hWnd)
-	{
-		HWND hWndPath = FindWindowEx(hWnd, NULL, _T("static"), NULL);
-		if (hWndPath)
-		{
-			TCHAR strTmp[MAX_PATH] = {0};
-			int nReturn = GetWindowText(hWndPath, strTmp, MAX_PATH-1);
-			if (nReturn > 0) {
-				TCHAR* strReturn = AllocateString(nReturn + 1);
-				_tcsncpy(strReturn, strTmp, nReturn + 1);
-				strReturn[nReturn] = 0;
-				return strReturn;
-			}
-		}
-	}
+    HWND hWnd = GetSnarlWindow();
+    if (hWnd)
+    {
+        HWND hWndPath = FindWindowEx(hWnd, NULL, _T("static"), NULL);
+        if (hWndPath)
+        {
+            TCHAR strTmp[MAX_PATH] = {0};
+            int nReturn = GetWindowText(hWndPath, strTmp, MAX_PATH-1);
+            if (nReturn > 0) {
+                TCHAR* strReturn = AllocateString(nReturn + 1);
+                _tcsncpy(strReturn, strTmp, nReturn + 1);
+                strReturn[nReturn] = 0;
+                return strReturn;
+            }
+        }
+    }
 
-	return NULL;
+    return NULL;
 }
 
 LPCTSTR SnarlInterface::GetIconsPath()
 {
-	TCHAR* szIconPath = NULL;
-	LPCTSTR szPath = GetAppPath();
-	if (!szPath)
-		return NULL;
+    TCHAR* szIconPath = NULL;
+    LPCTSTR szPath = GetAppPath();
+    if (!szPath)
+        return NULL;
 
-	size_t nLen = 0;
-	if (nLen = _tcsnlen(szPath, MAX_PATH))
-	{
-		nLen += 10 + 1; // etc\\icons\\ + NULL
-		szIconPath = AllocateString(nLen);
+    size_t nLen = 0;
+    nLen = _tcsnlen(szPath, MAX_PATH);
+    if (nLen > 0)
+    {
+        nLen += 10 + 1; // etc\\icons\\ + NULL
+        szIconPath = AllocateString(nLen);
 
-		_tcsncpy(szIconPath, szPath, nLen);
-		_tcsncat(szIconPath, _T("etc\\icons\\"), nLen);
-	}
-	
-	FreeString(szPath);
+        _tcsncpy(szIconPath, szPath, nLen);
+        _tcsncat(szIconPath, _T("etc\\icons\\"), nLen);
+    }
 
-	return szIconPath;
+    FreeString(szPath);
+
+    return szIconPath;
 }
 
 HWND SnarlInterface::GetSnarlWindow()
 {
-	return FindWindow(SnarlWindowClass, SnarlWindowTitle);;
+    return FindWindow(SnarlWindowClass, SnarlWindowTitle);;
 }
 
 LONG32 SnarlInterface::GetVersion()
 {
-	return DoRequest(Requests::VersionA());
+    return DoRequest(Requests::VersionA());
 }
 
 BOOL SnarlInterface::IsSnarlRunning()
 {
-	return IsWindow(GetSnarlWindow());
+    return IsWindow(GetSnarlWindow());
 }
 
 
@@ -221,480 +228,479 @@ BOOL SnarlInterface::IsSnarlRunning()
 // --------------------------------------------------------------------------------------------
 
 SnarlInterface::SnarlInterface()
-	: appToken(0), lastMsgToken(0), szPasswordA(NULL), szPasswordW(NULL)
+    : appToken(0), lastMsgToken(0), szPasswordA(NULL), szPasswordW(NULL)
 {
 }
 
 SnarlInterface::~SnarlInterface()
 {
-	delete [] szPasswordA;
-	delete [] szPasswordW;
+    delete [] szPasswordA;
+    delete [] szPasswordW;
 }
 
 //---------------------------------------------------------------------------------------------
 
 LONG32 SnarlInterface::AddAction(LONG32 msgToken, LPCSTR label, LPCSTR cmd)
 {
-	// addaction?[token=<notification token>|app-sig=<signature>&uid=<uid>][&password=<password>]&label=<label>&cmd=<command>
+    // addaction?[token=<notification token>|app-sig=<signature>&uid=<uid>][&password=<password>]&label=<label>&cmd=<command>
 
-	SnarlParameterList<char> spl(4);
-	spl.Add("token", msgToken);
-	spl.Add("password", szPasswordA);
-	
-	spl.Add("label", label);
-	spl.Add("cmd", cmd);
+    SnarlParameterList<char> spl(4);
+    spl.Add("token", msgToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::AddActionA(), spl);
+    spl.Add("label", label);
+    spl.Add("cmd", cmd);
+
+    return DoRequest(Requests::AddActionA(), spl);
 }
 
 LONG32 SnarlInterface::AddAction(LONG32 msgToken, LPCWSTR label, LPCWSTR cmd)
 {
-	SnarlParameterList<wchar_t> spl(4);
-	spl.Add(L"token", msgToken);
-	spl.Add(L"password", szPasswordW);
-	
-	spl.Add(L"label", label);
-	spl.Add(L"cmd", cmd);
+    SnarlParameterList<wchar_t> spl(4);
+    spl.Add(L"token", msgToken);
+    spl.Add(L"password", szPasswordW);
 
-	return DoRequest(Requests::AddActionW(), spl);
+    spl.Add(L"label", label);
+    spl.Add(L"cmd", cmd);
+
+    return DoRequest(Requests::AddActionW(), spl);
 }
 
 
 LONG32 SnarlInterface::AddClass(LPCSTR classId, LPCSTR name, LPCSTR title, LPCSTR text, LPCSTR icon, LPCSTR sound, LONG32 duration, LPCSTR callback, bool enabled)
 {
-	// addclass?[app-sig=<signature>|token=<application token>][&password=<password>]&id=<class identifier>&name=<class name>[&enabled=<0|1>][&callback=<callback>]
+    // addclass?[app-sig=<signature>|token=<application token>][&password=<password>]&id=<class identifier>&name=<class name>[&enabled=<0|1>][&callback=<callback>]
     //          [&title=<title>][&text=<text>][&icon=<icon>][&sound=<sound>][&duration=<duration>]
 
-	SnarlParameterList<char> spl(11);
-	spl.Add("token", appToken);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(11);
+    spl.Add("token", appToken);
+    spl.Add("password", szPasswordA);
 
-	spl.Add("id", classId);
-	spl.Add("name", name);
-	spl.Add("enabled", enabled);
-	spl.Add("callback", callback);
-	spl.Add("title", title);
-	spl.Add("text", text);
-	spl.Add("icon", icon);
-	spl.Add("sound", sound);
-	if (duration != -1) spl.Add("duration", duration);
+    spl.Add("id", classId);
+    spl.Add("name", name);
+    spl.Add("enabled", enabled);
+    spl.Add("callback", callback);
+    spl.Add("title", title);
+    spl.Add("text", text);
+    spl.Add("icon", icon);
+    spl.Add("sound", sound);
+    if (duration != -1) spl.Add("duration", duration);
 
-	return DoRequest(Requests::AddClassA(), spl);
+    return DoRequest(Requests::AddClassA(), spl);
 }
 
 LONG32 SnarlInterface::AddClass(LPCWSTR classId, LPCWSTR name, LPCWSTR title, LPCWSTR text, LPCWSTR icon, LPCWSTR sound, LONG32 duration, LPCWSTR callback, bool enabled)
 {
-	SnarlParameterList<wchar_t> spl(11);
-	spl.Add(L"token", appToken);
-	spl.Add(L"password", szPasswordW);
-	
-	spl.Add(L"id", classId);
-	spl.Add(L"name", name);
-	spl.Add(L"enabled", enabled);
-	spl.Add(L"callback", callback);
-	spl.Add(L"title", title);
-	spl.Add(L"text", text);
-	spl.Add(L"icon", icon);
-	spl.Add(L"sound", sound);
-	if (duration != -1)	spl.Add(L"duration", duration);
+    SnarlParameterList<wchar_t> spl(11);
+    spl.Add(L"token", appToken);
+    spl.Add(L"password", szPasswordW);
 
-	return DoRequest(Requests::AddClassW(), spl);
+    spl.Add(L"id", classId);
+    spl.Add(L"name", name);
+    spl.Add(L"enabled", enabled);
+    spl.Add(L"callback", callback);
+    spl.Add(L"title", title);
+    spl.Add(L"text", text);
+    spl.Add(L"icon", icon);
+    spl.Add(L"sound", sound);
+    if (duration != -1)	spl.Add(L"duration", duration);
+
+    return DoRequest(Requests::AddClassW(), spl);
 }
 
 
 LONG32 SnarlInterface::ClearActions(LONG32 msgToken)
 {
-	// clearactions?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
+    // clearactions?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
 
-	SnarlParameterList<char> spl(2);
-	spl.Add("token", msgToken);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(2);
+    spl.Add("token", msgToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::ClearActionsA(), spl);
+    return DoRequest(Requests::ClearActionsA(), spl);
 }
 
 
 LONG32 SnarlInterface::ClearClasses()
 {
-	// clearclasses?[token=app-sig=<signature>|token=<application token>][&password=<password>]
+    // clearclasses?[token=app-sig=<signature>|token=<application token>][&password=<password>]
 
-	SnarlParameterList<char> spl(2);
-	spl.Add("token", appToken);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(2);
+    spl.Add("token", appToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::ClearClassesA(), spl);
+    return DoRequest(Requests::ClearClassesA(), spl);
 }
 
 
 LONG32 SnarlInterface::GetLastMsgToken() const
 {
-	return lastMsgToken;
+    return lastMsgToken;
 }
 
 
 LONG32 SnarlInterface::Hide(LONG32 msgToken)
 {
-	// hide?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
+    // hide?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
 
-	SnarlParameterList<char> spl(2);
-	spl.Add("token", msgToken);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(2);
+    spl.Add("token", msgToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::HideA(), spl);
+    return DoRequest(Requests::HideA(), spl);
 }
 
 
 LONG32 SnarlInterface::IsVisible(LONG32 msgToken)
 {
-	// isvisible?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
+    // isvisible?[token=<notification token>|app-sig=<app-sig>&uid=<uid>][&password=<password>]
 
-	SnarlParameterList<char> spl(2);
-	spl.Add("token", msgToken);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(2);
+    spl.Add("token", msgToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::IsVisibleA(), spl);
+    return DoRequest(Requests::IsVisibleA(), spl);
 }
 
 
-LONG32 SnarlInterface::Notify(LPCSTR classId, LPCSTR title, LPCSTR text, LONG32 timeout, LPCSTR iconPath, LPCSTR iconBase64, LONG32 priority, LPCSTR ack, LPCSTR callback, LPCSTR value)
+LONG32 SnarlInterface::Notify(LPCSTR classId, LPCSTR title, LPCSTR text, LONG32 timeout, LPCSTR iconPath, LPCSTR iconBase64, SnarlEnums::MessagePriority priority, LPCSTR uid, LPCSTR callback, LPCSTR value)
 {
-	// notify?[app-sig=<signature>|token=<application token>][&password=<password>][&id=<class identifier>]
-	//        [&title=<title>][&text=<text>][&timeout=<timeout>][&icon=<icon path>][&icon-base64=<MIME data>][&callback=<default callback>]
-	//        [&priority=<priority>][&uid=<notification uid>][&value=<value>]
+    // notify?[app-sig=<signature>|token=<application token>][&password=<password>][&id=<class identifier>]
+    //        [&title=<title>][&text=<text>][&timeout=<timeout>][&icon=<icon path>][&icon-base64=<MIME data>][&callback=<default callback>]
+    //        [&priority=<priority>][&uid=<notification uid>][&value=<value>]
 
-	//  LPCSTR iconData
+    SnarlParameterList<char> spl(12);
+    spl.Add("token", appToken);
+    spl.Add("password", szPasswordA);
 
-	SnarlParameterList<char> spl(12);
-	spl.Add("token", appToken);
-	spl.Add("password", szPasswordA);
-	
-	spl.Add("id", classId);
-	spl.Add("title", title);
-	spl.Add("text", text);
-	spl.Add("icon", iconPath);
-	spl.Add("icon-base64", iconBase64);
-	spl.Add("ack", ack);
-	spl.Add("callback", callback);
-	spl.Add("value", value);
-	if (timeout != -1)  spl.Add("timeout", timeout);
-	if (priority != -2) spl.Add("priority", priority); // -1 is a legal priority
+    spl.Add("id", classId);
+    spl.Add("title", title);
+    spl.Add("text", text);
+    spl.Add("icon", iconPath);
+    spl.Add("icon-base64", iconBase64);
+    spl.Add("uid", uid);
+    spl.Add("callback", callback);
+    spl.Add("value", value);
+    if (timeout != -1)  spl.Add("timeout", timeout);
+    if (priority != SnarlEnums::PriorityUndefined) spl.Add("priority", priority); // -1 is a legal priority
 
-	LONG32 request = DoRequest(Requests::NotifyA(), spl);
-	lastMsgToken = (request > 0) ? request : 0;
+    LONG32 request = DoRequest(Requests::NotifyA(), spl);
+    lastMsgToken = (request > 0) ? request : 0;
 
-	return request;
+    return request;
 }
 
-LONG32 SnarlInterface::Notify(LPCWSTR classId, LPCWSTR title, LPCWSTR text, LONG32 timeout, LPCWSTR iconPath, LPCWSTR iconBase64, LONG32 priority, LPCWSTR ack, LPCWSTR callback, LPCWSTR value)
+LONG32 SnarlInterface::Notify(LPCWSTR classId, LPCWSTR title, LPCWSTR text, LONG32 timeout, LPCWSTR iconPath, LPCWSTR iconBase64, SnarlEnums::MessagePriority priority, LPCWSTR uid, LPCWSTR callback, LPCWSTR value)
 {
-	SnarlParameterList<wchar_t> spl(12);
-	spl.Add(L"token", appToken);
-	spl.Add(L"password", szPasswordW);
+    SnarlParameterList<wchar_t> spl(12);
+    spl.Add(L"token", appToken);
+    spl.Add(L"password", szPasswordW);
 
-	spl.Add(L"id", classId);
-	spl.Add(L"title", title);
-	spl.Add(L"text", text);
-	spl.Add(L"icon", iconPath);
-	spl.Add(L"icon-base64", iconBase64);
-	spl.Add(L"ack", ack);
-	spl.Add(L"callback", callback);
-	spl.Add(L"value", value);
-	if (timeout != -1)  spl.Add(L"timeout", timeout);
-	if (priority != -2) spl.Add(L"priority", priority); // -1 is a legal priority	
+    spl.Add(L"id", classId);
+    spl.Add(L"title", title);
+    spl.Add(L"text", text);
+    spl.Add(L"icon", iconPath);
+    spl.Add(L"icon-base64", iconBase64);
+    spl.Add(L"uid", uid);
+    spl.Add(L"callback", callback);
+    spl.Add(L"value", value);
+    if (timeout != -1)  spl.Add(L"timeout", timeout);
+    if (priority != SnarlEnums::PriorityUndefined) spl.Add(L"priority", priority); // -1 is a legal priority
 
-	LONG32 request = DoRequest(Requests::NotifyW(), spl);
-	lastMsgToken = (request > 0) ? request : 0;
+    LONG32 request = DoRequest(Requests::NotifyW(), spl);
+    lastMsgToken = (request > 0) ? request : 0;
 
-	return request;
+    return request;
 }
 
 
-LONG32 SnarlInterface::Register(LPCSTR signature, LPCSTR title, LPCSTR icon, LPCSTR password, HWND hWndReplyTo, LONG32 msgReply)
+LONG32 SnarlInterface::Register(LPCSTR signature, LPCSTR title, LPCSTR icon, LPCSTR password, HWND hWndReplyTo, LONG32 msgReply, SnarlEnums::AppFlags flags)
 {
-	// register?app-sig=<signature>&title=<title>[&icon=<icon>][&password=<password>][&reply-to=<reply window>][&reply=<reply message>]
+    // register?app-sig=<signature>&title=<title>[&icon=<icon>][&password=<password>][&reply-to=<reply window>][&reply=<reply message>]
 
-	SnarlParameterList<char> spl(6);
-	spl.Add("app-sig", signature);
-	spl.Add("title", title);
-	spl.Add("icon", icon);
-	spl.Add("password", password);
-	spl.Add("reply-to", hWndReplyTo);
-	spl.Add("reply", msgReply);
+    SnarlParameterList<char> spl(6);
+    spl.Add("app-sig", signature);
+    spl.Add("title", title);
+    spl.Add("icon", icon);
+    spl.Add("password", password);
+    spl.Add("reply-to", hWndReplyTo);
+    spl.Add("reply", msgReply);
+    spl.Add("flags", flags);
 
-	// If password was given, save and use in all other functions requiring password
-	if (password != NULL && strlen(password) > 0)
-		SetPassword(password);
+    // If password was given, save and use in all other functions requiring password
+    if (password != NULL && strlen(password) > 0)
+        SetPassword(password);
 
-	LONG32 request = DoRequest(Requests::RegisterA(), spl);
-	if (request > 0)
-		appToken = request;
+    LONG32 request = DoRequest(Requests::RegisterA(), spl);
+    if (request > 0)
+        appToken = request;
 
-	return request;
+    return request;
 }
 
-LONG32 SnarlInterface::Register(LPCWSTR signature, LPCWSTR name, LPCWSTR icon, LPCWSTR password, HWND hWndReplyTo, LONG32 msgReply)
+LONG32 SnarlInterface::Register(LPCWSTR signature, LPCWSTR name, LPCWSTR icon, LPCWSTR password, HWND hWndReplyTo, LONG32 msgReply, SnarlEnums::AppFlags flags)
 {
-	SnarlParameterList<wchar_t> spl(7);
-	spl.Add(L"app-sig", signature);
-	spl.Add(L"title", name);
-	spl.Add(L"icon", icon);
-	spl.Add(L"password", password);
-	spl.Add(L"reply-to", hWndReplyTo);
-	spl.Add(L"reply", msgReply);
+    SnarlParameterList<wchar_t> spl(7);
+    spl.Add(L"app-sig", signature);
+    spl.Add(L"title", name);
+    spl.Add(L"icon", icon);
+    spl.Add(L"password", password);
+    spl.Add(L"reply-to", hWndReplyTo);
+    spl.Add(L"reply", msgReply);
+    spl.Add(L"flags", flags);
 
-	// If password was given, save and use in all other functions requiring password
-	if (password != NULL && wcslen(password) > 0)
-		SetPassword(password);
+    // If password was given, save and use in all other functions requiring password
+    if (password != NULL && wcslen(password) > 0)
+        SetPassword(password);
 
-	LONG32 request = DoRequest(Requests::RegisterW(), spl);
-	if (request > 0)
-		appToken = request;
+    LONG32 request = DoRequest(Requests::RegisterW(), spl);
+    if (request > 0)
+        appToken = request;
 
-	return request;
+    return request;
 }
 
 
 LONG32 SnarlInterface::RemoveClass(LPCSTR classId)
 {
-	// remclass?[app-sig=<signature>|token=<application token>][&password=<password>][&id=<class identifier>|&all=<0|1>]
+    // remclass?[app-sig=<signature>|token=<application token>][&password=<password>][&id=<class identifier>|&all=<0|1>]
 
-	SnarlParameterList<char> spl(3);
-	spl.Add("token", appToken);
-	spl.Add("password", szPasswordA);
-	
-	spl.Add("id", classId);
-	// instead of all, use ClearClasses
+    SnarlParameterList<char> spl(3);
+    spl.Add("token", appToken);
+    spl.Add("password", szPasswordA);
 
-	return DoRequest(Requests::RemoveClassA(), spl);
+    spl.Add("id", classId);
+    // instead of all, use ClearClasses
+
+    return DoRequest(Requests::RemoveClassA(), spl);
 }
 
 LONG32 SnarlInterface::RemoveClass(LPCWSTR classId)
 {
-	SnarlParameterList<wchar_t> spl(3);
-	spl.Add(L"token", appToken);
-	spl.Add(L"password", szPasswordW);
-	
-	spl.Add(L"id", classId);
+    SnarlParameterList<wchar_t> spl(3);
+    spl.Add(L"token", appToken);
+    spl.Add(L"password", szPasswordW);
 
-	return DoRequest(Requests::RemoveClassW(), spl);
+    spl.Add(L"id", classId);
+
+    return DoRequest(Requests::RemoveClassW(), spl);
 }
 
 
 LONG32 SnarlInterface::Unregister(LPCSTR signature)
 {
-	// unregister?[app-sig=<signature>|token=<application token>][&password=<password>]
+    // unregister?[app-sig=<signature>|token=<application token>][&password=<password>]
 
-	SnarlParameterList<char> spl(2);
-	spl.Add("app-sig", signature);
-	spl.Add("password", szPasswordA);
+    SnarlParameterList<char> spl(2);
+    spl.Add("app-sig", signature);
+    spl.Add("password", szPasswordA);
 
-	appToken = 0;
-	lastMsgToken = 0;
-	ClearPassword();
+    appToken = 0;
+    lastMsgToken = 0;
+    ClearPassword();
 
-	return DoRequest(Requests::UnregisterA(), spl);
+    return DoRequest(Requests::UnregisterA(), spl);
 }
 
 LONG32 SnarlInterface::Unregister(LPCWSTR signature)
 {
-	SnarlParameterList<wchar_t> spl(2);
-	spl.Add(L"app-sig", signature);
-	spl.Add(L"password", szPasswordW);
+    SnarlParameterList<wchar_t> spl(2);
+    spl.Add(L"app-sig", signature);
+    spl.Add(L"password", szPasswordW);
 
-	appToken = 0;
-	lastMsgToken = 0;
-	ClearPassword();
+    appToken = 0;
+    lastMsgToken = 0;
+    ClearPassword();
 
-	return DoRequest(Requests::UnregisterW(), spl);
+    return DoRequest(Requests::UnregisterW(), spl);
 }
 
-LONG32 SnarlInterface::Update(LONG32 msgToken, LPCSTR classId, LPCSTR title, LPCSTR text, LONG32 timeout, LPCSTR iconPath, LPCSTR iconBase64, LONG32 priority, LPCSTR ack, LPCSTR callback, LPCSTR value)
+LONG32 SnarlInterface::Update(LONG32 msgToken, LPCSTR classId, LPCSTR title, LPCSTR text, LONG32 timeout, LPCSTR iconPath, LPCSTR iconBase64, SnarlEnums::MessagePriority priority, LPCSTR callback, LPCSTR value)
 {
-	// Made from best guess - no documentation available yet
-	SnarlParameterList<char> spl(12);
-	spl.Add("token", msgToken);
-	spl.Add("password", szPasswordA);
+    // Made from best guess - no documentation available yet
+    SnarlParameterList<char> spl(11);
+    spl.Add("token", msgToken);
+    spl.Add("password", szPasswordA);
 
-	spl.Add("id", classId);
-	spl.Add("title", title);
-	spl.Add("text", text);
-	spl.Add("icon", iconPath);
-	spl.Add("icon-base64", iconBase64);
-	spl.Add("ack", ack);
-	spl.Add("callback", callback);
-	spl.Add("value", value);
-	if (timeout != -1)  spl.Add("timeout", timeout);
-	if (priority != -2) spl.Add("priority", priority); // -1 is a legal priority
+    spl.Add("id", classId);
+    spl.Add("title", title);
+    spl.Add("text", text);
+    spl.Add("icon", iconPath);
+    spl.Add("icon-base64", iconBase64);
+    spl.Add("callback", callback);
+    spl.Add("value", value);
+    if (timeout != -1)  spl.Add("timeout", timeout);
+    if (priority != SnarlEnums::PriorityUndefined) spl.Add("priority", priority); // -1 is a legal priority
 
-	return DoRequest(Requests::UpdateA(), spl);
+    return DoRequest(Requests::UpdateA(), spl);
 }
 
-LONG32 SnarlInterface::Update(LONG32 msgToken, LPCWSTR classId, LPCWSTR title, LPCWSTR text, LONG32 timeout, LPCWSTR iconPath, LPCWSTR iconBase64, LONG32 priority, LPCWSTR ack, LPCWSTR callback, LPCWSTR value)
+LONG32 SnarlInterface::Update(LONG32 msgToken, LPCWSTR classId, LPCWSTR title, LPCWSTR text, LONG32 timeout, LPCWSTR iconPath, LPCWSTR iconBase64, SnarlEnums::MessagePriority priority, LPCWSTR callback, LPCWSTR value)
 {
-	// Made from best guess - no documentation available yet
-	SnarlParameterList<wchar_t> spl(12);
-	spl.Add(L"token", msgToken);
-	spl.Add(L"password", szPasswordW);
+    // Made from best guess - no documentation available yet
+    SnarlParameterList<wchar_t> spl(11);
+    spl.Add(L"token", msgToken);
+    spl.Add(L"password", szPasswordW);
 
-	spl.Add(L"id", classId);
-	spl.Add(L"title", title);
-	spl.Add(L"text", text);
-	spl.Add(L"icon", iconPath);
-	spl.Add(L"icon-base64", iconBase64);
-	spl.Add(L"ack", ack);
-	spl.Add(L"callback", callback);
-	spl.Add(L"value", value);
-	if (timeout != -1)  spl.Add(L"timeout", timeout);
-	if (priority != -2) spl.Add(L"priority", priority); // -1 is a legal priority	
+    spl.Add(L"id", classId);
+    spl.Add(L"title", title);
+    spl.Add(L"text", text);
+    spl.Add(L"icon", iconPath);
+    spl.Add(L"icon-base64", iconBase64);
+    spl.Add(L"callback", callback);
+    spl.Add(L"value", value);
+    if (timeout != -1)  spl.Add(L"timeout", timeout);
+    if (priority != SnarlEnums::PriorityUndefined) spl.Add(L"priority", priority); // -1 is a legal priority
 
-	return DoRequest(Requests::UpdateW(), spl);
+    return DoRequest(Requests::UpdateW(), spl);
 }
 
 /*
 // Update app should not be used at this time, according to wiki
 LONG32 SnarlInterface::UpdateApp(LPCSTR title, LPCSTR icon)
 {
-	SnarlParameterList<char> spl(3);
-	spl.Add("token", appToken);
-	spl.Add("title", title);
-	spl.Add("icon", icon);
+    SnarlParameterList<char> spl(3);
+    spl.Add("token", appToken);
+    spl.Add("title", title);
+    spl.Add("icon", icon);
 
-	return DoRequest(Requests::UpdateAppA(), spl);
+    return DoRequest(Requests::UpdateAppA(), spl);
 }
 
 LONG32 SnarlInterface::UpdateApp(LPCWSTR title, LPCWSTR icon)
 {
-	SnarlParameterList<wchar_t> spl(2);
-	spl.Add(L"token", appToken);
-	spl.Add(L"title", title);
-	spl.Add(L"icon", icon);
+    SnarlParameterList<wchar_t> spl(2);
+    spl.Add(L"token", appToken);
+    spl.Add(L"title", title);
+    spl.Add(L"icon", icon);
 
-	return DoRequest(Requests::UpdateAppW(), spl);
+    return DoRequest(Requests::UpdateAppW(), spl);
 }*/
 
 
 //-----------------------------------------------------------------------------
-// Private functions 
+// Private functions
 //-----------------------------------------------------------------------------
 
 LONG32 SnarlInterface::DoRequest(LPCSTR request, SnarlParameterList<char>& spl, UINT replyTimeout)
 {
-	// <action>[?<data>=<value>[&<data>=<value>]]
-	const std::vector<SnarlParameterList<char>::PairType>&list = spl.GetList();
+    // <action>[?<data>=<value>[&<data>=<value>]]
+    const std::vector<SnarlParameterList<char>::PairType>&list = spl.GetList();
 
-	if (list.size() > 0)
-	{
-		std::string requestStr = request;
-		requestStr.append("?");
+    if (list.size() > 0)
+    {
+        std::string requestStr = request;
+        requestStr.append("?");
 
-		std::vector<SnarlParameterList<char>::PairType>::const_iterator listEnd = list.end(); // cend();
-		for (std::vector<SnarlParameterList<char>::PairType>::const_iterator iter = list.begin(); // cbegin();
-			iter != listEnd; ++iter)
-		{
-			SnarlParameterList<char>::PairType pair = *iter;
+        std::vector<SnarlParameterList<char>::PairType>::const_iterator listEnd = list.end(); // cend();
+        for (std::vector<SnarlParameterList<char>::PairType>::const_iterator iter = list.begin(); // cbegin();
+            iter != listEnd; ++iter)
+        {
+            SnarlParameterList<char>::PairType pair = *iter;
 
-			if (iter->second.length() > 0)
-			{
-				std::basic_string<char>& value = const_cast<std::basic_string<char>&>(iter->second);
-				requestStr.append(iter->first).append("=").append(Escape(value));
-				requestStr.append("&");
-			}
-		}
-		// Delete last &
-		requestStr.erase(requestStr.size() - 1);
+            if (iter->second.length() > 0)
+            {
+                std::basic_string<char>& value = const_cast<std::basic_string<char>&>(iter->second);
+                requestStr.append(iter->first).append("=").append(Escape(value));
+                requestStr.append("&");
+            }
+        }
+        // Delete last &
+        requestStr.erase(requestStr.size() - 1);
 
-		return DoRequest(requestStr.c_str(), replyTimeout);
-	}
-	else
-		return DoRequest(request, replyTimeout);
+        return DoRequest(requestStr.c_str(), replyTimeout);
+    }
+    else
+        return DoRequest(request, replyTimeout);
 }
 
 LONG32 SnarlInterface::DoRequest(LPCWSTR request, SnarlParameterList<wchar_t>& spl, UINT replyTimeout)
 {
-	// <action>[?<data>=<value>[&<data>=<value>]]
-	const std::vector<SnarlParameterList<wchar_t>::PairType>&list = spl.GetList();
+    // <action>[?<data>=<value>[&<data>=<value>]]
+    const std::vector<SnarlParameterList<wchar_t>::PairType>&list = spl.GetList();
 
-	if (list.size() > 0)
-	{
-		std::basic_string<wchar_t> requestStr = request;
-		requestStr.append(L"?");
+    if (list.size() > 0)
+    {
+        std::basic_string<wchar_t> requestStr = request;
+        requestStr.append(L"?");
 
-		std::vector<SnarlParameterList<wchar_t>::PairType>::const_iterator listEnd = list.end(); // cend();
-		for (std::vector<SnarlParameterList<wchar_t>::PairType>::const_iterator iter = list.begin(); // cbegin();
-			iter != listEnd; ++iter)
-		{
-			if (iter->second.length() > 0)
-			{
-				std::basic_string<wchar_t>& value = const_cast<std::basic_string<wchar_t>&>(iter->second);
-				requestStr.append(iter->first).append(L"=").append(Escape(value));
-				requestStr.append(L"&");
-			}
-		}
-		// Delete last &
-		requestStr.erase(requestStr.size() - 1);
+        std::vector<SnarlParameterList<wchar_t>::PairType>::const_iterator listEnd = list.end(); // cend();
+        for (std::vector<SnarlParameterList<wchar_t>::PairType>::const_iterator iter = list.begin(); // cbegin();
+            iter != listEnd; ++iter)
+        {
+            if (iter->second.length() > 0)
+            {
+                std::basic_string<wchar_t>& value = const_cast<std::basic_string<wchar_t>&>(iter->second);
+                requestStr.append(iter->first).append(L"=").append(Escape(value));
+                requestStr.append(L"&");
+            }
+        }
+        // Delete last &
+        requestStr.erase(requestStr.size() - 1);
 
-		return DoRequest(requestStr.c_str(), replyTimeout);
-	}
-	else
-		return DoRequest(request, replyTimeout);
+        return DoRequest(requestStr.c_str(), replyTimeout);
+    }
+    else
+        return DoRequest(request, replyTimeout);
 }
 
 // Remember to delete [] returned string
 LPSTR SnarlInterface::WideToUTF8(LPCWSTR szWideStr)
 {
-	if (szWideStr == NULL)
-		return NULL;
+    if (szWideStr == NULL)
+        return NULL;
 
-	int nSize = WideCharToMultiByte(CP_UTF8, 0, szWideStr, -1, NULL,0, NULL, NULL);
-	LPSTR szUTF8 = new char[nSize];
-	WideCharToMultiByte(CP_UTF8, 0, szWideStr, -1, szUTF8, nSize, NULL, NULL);
-	
-	return szUTF8;
+    int nSize = WideCharToMultiByte(CP_UTF8, 0, szWideStr, -1, NULL, 0, NULL, NULL);
+    LPSTR szUTF8 = new char[nSize];
+    WideCharToMultiByte(CP_UTF8, 0, szWideStr, -1, szUTF8, nSize, NULL, NULL);
+
+    return szUTF8;
 }
 
 void SnarlInterface::SetPassword(LPCSTR password)
 {
-	ClearPassword();
+    ClearPassword();
 
-	if (password != NULL)
-	{
-		int bufSize = (int)strlen(password) + 1;
-		szPasswordA = new char[bufSize];
-		szPasswordW = new wchar_t[bufSize];
+    if (password != NULL)
+    {
+        int bufSize = (int)strlen(password) + 1;
+        szPasswordA = new char[bufSize];
+        szPasswordW = new wchar_t[bufSize];
 
-		// Copy ansi string
-		strcpy_s(szPasswordA, bufSize, password);
+        // Copy ansi string
+        strcpy_s(szPasswordA, bufSize, password);
 
-		// Copy wide string
-		MultiByteToWideChar(CP_ACP, 0, password, bufSize, szPasswordW, bufSize);
-	}
+        // Copy wide string
+        MultiByteToWideChar(CP_ACP, 0, password, bufSize, szPasswordW, bufSize);
+    }
 }
 
 void SnarlInterface::SetPassword(LPCWSTR password)
 {
-	ClearPassword();
+    ClearPassword();
 
-	if (password != NULL)
-	{
-		size_t bufSize = wcslen(password) + 1;
-		szPasswordW = new wchar_t[bufSize];
+    if (password != NULL)
+    {
+        size_t bufSize = wcslen(password) + 1;
+        szPasswordW = new wchar_t[bufSize];
 
-		// Copy wide string
-		wcscpy_s(szPasswordW, bufSize, password);
+        // Copy wide string
+        wcscpy_s(szPasswordW, bufSize, password);
 
-		// Copy ansi string
-		szPasswordA = WideToUTF8(password);
-	}
+        // Copy ansi string
+        szPasswordA = WideToUTF8(password);
+    }
 }
 
 void SnarlInterface::ClearPassword()
 {
-	// Safe to delete NULL
-	delete [] szPasswordA;
-	delete [] szPasswordW;
-	szPasswordA = NULL;
-	szPasswordW = NULL;
+    // Safe to delete NULL
+    delete [] szPasswordA;
+    delete [] szPasswordW;
+    szPasswordA = NULL;
+    szPasswordW = NULL;
 }
 
 
 }} // namespace Snarl::V42
+
diff --git a/src/plugins/backends/snarl/SnarlInterface.h b/src/plugins/backends/snarl/SnarlInterface.h
index e4a23e0..ea206db 100644
--- a/src/plugins/backends/snarl/SnarlInterface.h
+++ b/src/plugins/backends/snarl/SnarlInterface.h
@@ -2,7 +2,7 @@
 #define SNARL_INTERFACE_V42_H
 
 #if defined(__MINGW32__) && !defined(MINGW_HAS_SECURE_API)
-	#define MINGW_HAS_SECURE_API
+    #define MINGW_HAS_SECURE_API
 #endif
 
 #include <tchar.h>
@@ -13,358 +13,396 @@
 
 
 #ifndef SMTO_NOTIMEOUTIFNOTHUNG
-	#define SMTO_NOTIMEOUTIFNOTHUNG 8
+    #define SMTO_NOTIMEOUTIFNOTHUNG 8
 #endif
 
+
 namespace Snarl {
-	namespace V42 {
+    namespace V42 {
 
-	static const LPCTSTR SnarlWindowClass = _T("w>Snarl");
-	static const LPCTSTR SnarlWindowTitle = _T("Snarl");
+    static LPCTSTR SnarlWindowClass = _T("w>Snarl");
+    static LPCTSTR SnarlWindowTitle = _T("Snarl");
 
-	static const LPCTSTR SnarlGlobalMsg = _T("SnarlGlobalEvent");
-	static const LPCTSTR SnarlAppMsg = _T("SnarlAppMessage");
+    static LPCTSTR SnarlGlobalMsg = _T("SnarlGlobalEvent");
+    static LPCTSTR SnarlAppMsg    = _T("SnarlAppMessage");
 
-	static const DWORD WM_SNARLTEST = WM_USER + 237;
+    static const DWORD WM_SNARLTEST = WM_USER + 237;
 
-	// Enums put in own namespace, because ANSI C++ doesn't decorate enums with tagname :(
-	namespace SnarlEnums {
-
-		/// <summary>
-		/// Global event identifiers.
-		/// Identifiers marked with a '*' are sent by Snarl in two ways:
-		///   1. As a broadcast message (uMsg = 'SNARL_GLOBAL_MSG')
-		///   2. To the window registered in snRegisterConfig() or snRegisterConfig2()
-		///      (uMsg = reply message specified at the time of registering)
-		/// In both cases these values appear in wParam.
-		///   
-		/// Identifiers not marked are not broadcast; they are simply sent to the application's registered window.
-		/// </summary>
-		enum GlobalEvent
-		{
-			SnarlLaunched = 1,      // Snarl has just started running*
-			SnarlQuit = 2,          // Snarl is about to stop running*
-			SnarlStopped = 3,       // sent when stopped by user
-			SnarlStarted = 4,       // sent when started by user
-
-			// R2.4 Beta3
-			SnarlUserAway,          // away mode was enabled
-			SnarlUserBack,          // away mode was disabled
-		};
-
-		enum SnarlStatus
-		{
-			Success = 0,
-
-			// Win32 callbacks (renamed under V42)
-			CallbackRightClick = 32,           // Deprecated as of V42, ex. SNARL_NOTIFICATION_CLICKED/SNARL_NOTIFICATION_CANCELLED
-			CallbackTimedOut,
-			CallbackInvoked,               // left clicked and no default callback assigned
-			CallbackMenuSelected,          // HIWORD(wParam) contains 1-based menu item index
-			CallbackMiddleClick,                // Deprecated as of V42
-			CallbackClosed,
+    /// <summary>Application requests - these values appear in wParam.<para>Application should launch its settings UI</para></summary>
+    static const WPARAM AppDoPrefs = 1;
+    /// <summary>Application requests - these values appear in wParam.<para>Application should show its About... dialog</para></summary>
+    static const WPARAM AppDoAbout = 2;
 
 
-			// critical errors
-			ErrorFailed = 101,             // miscellaneous failure
-			ErrorUnknownCommand,           // specified command not recognised
-			ErrorTimedOut,                 // Snarl took too long to respond
-			//104 gen critical #4
-			//105 gen critical #5
-			ErrorBadSocket = 106,          // invalid socket (or some other socket-related error)
-			ErrorBadPacket = 107,          // badly formed request
-			//108 net critical #3
-			ErrorArgMissing = 109,         // required argument missing
-			ErrorSystem,                   // internal system error
-			//120 libsnarl critical block
-			ErrorAccessDenied = 121,       // libsnarl only
+    // Enums put in own namespace, because ANSI C++ doesn't decorate enums with tagname :(
+    namespace SnarlEnums {
 
-			// warnings
-			ErrorNotRunning = 201,         // Snarl handling window not found
-			ErrorNotRegistered,
-			ErrorAlreadyRegistered,        // not used yet; sn41RegisterApp() returns existing token
-			ErrorClassAlreadyExists,       // not used yet
-			ErrorClassBlocked,
-			ErrorClassNotFound,
-			ErrorNotificationNotFound,
-			ErrorFlooding,                 // notification generated by same class within quantum
-			ErrorDoNotDisturb,             // DnD mode is in effect was not logged as missed
-			ErrorCouldNotDisplay,          // not enough space on-screen to display notification
-			ErrorAuthFailure,              // password mismatch
+        /// <summary>
+        /// Global event identifiers - sent as Windows broadcast messages.
+        /// These values appear in wParam of the message.
+        /// </summary>
+        enum GlobalEvent
+        {
+            SnarlLaunched = 1,      // Snarl has just started running
+            SnarlQuit = 2,          // Snarl is about to stop running
+            SnarlGlobalStopped = 3, // Sent when stopped by user - Also sent to registered window
+            SnarlGlobalStarted = 4, // Sent when started by user - Also sent to registered window
+        };
 
-			// informational
-			WasMerged = 251,               // notification was merged, returned token is the one we merged with
+        enum SnarlStatus
+        {
+            Success = 0,
 
-			// callbacks
-			NotifyGone = 301,              // reserved for future use
+            // Snarl-Stopped/Started/UserAway/UserBack is defined in the GlobalEvent struct in VB6 code,
+            // but are sent directly to a registered window, so in C# they are defined here instead.
+            // Implemented as of Snarl R2.4 Beta3
+            SnarlStopped = 3,              // Sent when stopped by user - Also sent as broadcast message
+            SnarlStarted,                  // Sent when started by user - Also sent as broadcast message
+            SnarlUserAway,                 // Away mode was enabled
+            SnarlUserBack,                 // Away mode was disabled
 
-			// The following are currently specific to SNP 2.0 and are effectively the
-			// Win32 SNARL_CALLBACK_nnn constants with 270 added to them
+            // Win32 callbacks (renamed under V42)
+            CallbackRightClick = 32,       // Deprecated as of V42, ex. SNARL_NOTIFICATION_CLICKED/SNARL_NOTIFICATION_CANCELLED
+            CallbackTimedOut,
+            CallbackInvoked,               // left clicked and no default callback assigned
+            CallbackMenuSelected,          // HIWORD(wParam) contains 1-based menu item index
+            CallbackMiddleClick,           // Deprecated as of V42
+            CallbackClosed,
 
-			// SNARL_NOTIFY_CLICK = 302    // indicates notification was right-clicked (deprecated as of V42)
-			NotifyExpired = 303,
-			NotifyInvoked = 304,           // note this was "ACK" in a previous life
-			NotifyMenu,                    // indicates an item was selected from user-defined menu (deprecated as of V42)
-			// SNARL_NOTIFY_EX_CLICK       // user clicked the middle mouse button (deprecated as of V42)
-			// SNARL_NOTIFY_CLOSED         // user clicked the notification's close gadget
+            // critical errors
+            ErrorFailed = 101,             // miscellaneous failure
+            ErrorUnknownCommand,           // specified command not recognised
+            ErrorTimedOut,                 // Snarl took too long to respond
+            //104 gen critical #4
+            //105 gen critical #5
+            ErrorBadSocket = 106,          // invalid socket (or some other socket-related error)
+            ErrorBadPacket = 107,          // badly formed request
+            ErrorInvalidArg = 108,         // arg supplied was invalid (Added in v42.56)
+            ErrorArgMissing = 109,         // required argument missing
+            ErrorSystem,                   // internal system error
+            //120 libsnarl critical block
+            ErrorAccessDenied = 121,       // libsnarl only
+            //130 SNP/3.0-specific
+            ErrorUnsupportedVersion = 131, // requested SNP version is not supported
+            ErrorNoActionsProvided,        // empty request
+            ErrorUnsupportedEncryption,    // requested encryption type is not supported
+            ErrorUnsupportedHashing,       // requested message hashing type is not supported
 
-			// the following is generic to SNP and the Win32 API
-			NotifyAction = 308,             // user picked an action from the list, the data value will indicate which one
+            // warnings
+            ErrorNotRunning = 201,         // Snarl handling window not found
+            ErrorNotRegistered,
+            ErrorAlreadyRegistered,        // not used yet; sn41RegisterApp() returns existing token
+            ErrorClassAlreadyExists,       // not used yet
+            ErrorClassBlocked,
+            ErrorClassNotFound,
+            ErrorNotificationNotFound,
+            ErrorFlooding,                 // notification generated by same class within quantum
+            ErrorDoNotDisturb,             // DnD mode is in effect was not logged as missed
+            ErrorCouldNotDisplay,          // not enough space on-screen to display notification
+            ErrorAuthFailure,              // password mismatch
+            // Release 2.4.2
+            ErrorDiscarded,                // discarded for some reason, e.g. foreground app match
+            ErrorNotSubscribed,            // subscriber not found
+
+            // informational
+            // code 250 reserved for future use
+            WasMerged = 251,               // notification was merged, returned token is the one we merged with
+
+            // callbacks
+            // code 300 reserved for future use
+            NotifyGone = 301,              // reserved for future use
+
+            // The following are currently specific to SNP 2.0 and are effectively the
+            // Win32 SNARL_CALLBACK_nnn constants with 270 added to them
+
+            // SNARL_NOTIFY_CLICK = 302    // indicates notification was right-clicked (deprecated as of V42)
+            NotifyExpired = 303,
+            NotifyInvoked = 304,           // note this was "ACK" in a previous life
+            NotifyMenu,                    // indicates an item was selected from user-defined menu (deprecated as of V42)
+            // SNARL_NOTIFY_EX_CLICK       // user clicked the middle mouse button (deprecated as of V42)
+            NotifyClosed = 307,            // // user clicked the notification's close gadget (GNTP only)
+
+            // the following is generic to SNP and the Win32 API
+            NotifyAction = 308,             // user picked an action from the list, the data value will indicate which one
 
 
-			// C++ interface custom errors- not part of official API!
-			ErrorCppInterface = 1001
-		};
+            // C++ interface custom errors- not part of official API!
+            ErrorCppInterface = 1001
+        };
 
-	} // namespace SnarlEnums
+        /// <summary>
+        /// The priority of messages.
+        /// See <cref>http://sourceforge.net/apps/mediawiki/snarlwin/index.php?title=Generic_API#notify</cref>
+        /// </summary>
+        enum MessagePriority
+        {
+            PriorityUndefined = -2,
+            PriorityLow = -1,
+            PriorityNormal = 0,
+            PriorityHigh = 1
+        };
 
-	// ----------------------------------------------------------------------------------------
-	/// SnarlParameterList class definition - Helper class, not meant for broad use
-	// ----------------------------------------------------------------------------------------
-	template<class T>
-	class SnarlParameterList
-	{
-	public:
-		typedef std::pair<std::basic_string<T>, std::basic_string<T> > PairType;
+        /// <summary>
+        /// Application flags - features this app supports.
+        /// </summary>
+        enum AppFlags
+        {
+            AppFlagNone = 0,
+            AppHasPrefs = 1,
+            AppHasAbout = 2,
+            AppIsWindowless = 0x8000
+        };
 
-		SnarlParameterList()
-		{
-		}
-		
-		explicit SnarlParameterList(int initialCapacity)
-		{
-			list.reserve(initialCapacity);
-		}
+    } // namespace SnarlEnums
 
-		void Add(const T* _key, const T* _value)
-		{
-			if (_value != NULL)
-				list.push_back(PairType(std::basic_string<T>(_key), std::basic_string<T>(_value))); // 
-		}
+    // ----------------------------------------------------------------------------------------
+    /// SnarlParameterList class definition - Helper class, not meant for broad use
+    // ----------------------------------------------------------------------------------------
+    template<class T>
+    class SnarlParameterList
+    {
+    public:
+        typedef std::pair<std::basic_string<T>, std::basic_string<T> > PairType;
 
-		void Add(const T* _key, LONG32 _value)
-		{
-			std::basic_stringstream<T> valStr;
-			valStr << _value;
-			list.push_back(PairType(std::basic_string<T>(_key), valStr.str()));
-		}
-		
-		void Add(const T* _key, void* _value)
-		{
-			if (_value != NULL)
-			{
-				std::basic_stringstream<T> valStr;
-				valStr << (INT_PTR)_value; // Uckly hack, to get stringstream to print void* as decimal not hex
+        SnarlParameterList()
+        {
+        }
 
-				list.push_back(PairType(std::basic_string<T>(_key), valStr.str()));
-			}
-		}
-		
-		const std::vector<PairType>& GetList() const
-		{
-			return list;
-		}
+        explicit SnarlParameterList(int initialCapacity)
+        {
+            list.reserve(initialCapacity);
+        }
 
-	private:
-		std::vector<PairType> list;
-	};
+        void Add(const T* _key, const T* _value)
+        {
+            if (_value != NULL)
+                list.push_back(PairType(std::basic_string<T>(_key), std::basic_string<T>(_value))); //
+        }
 
-	// ----------------------------------------------------------------------------------------
-	// SnarlInterface class definition
-	// ----------------------------------------------------------------------------------------
-	class SnarlInterface
-	{
-	public:
-		/// <summary>Requests strings known by Snarl</summary>
-		class Requests
-		{
-		public:
-			static LPCSTR  AddActionA()    { return  "addaction"; }
-			static LPCWSTR AddActionW()    { return L"addaction"; }
-			static LPCSTR  AddClassA()     { return  "addclass"; }
-			static LPCWSTR AddClassW()     { return L"addclass"; }
-			static LPCSTR  ClearActionsA() { return  "clearactions"; }
-			static LPCWSTR ClearActionsW() { return L"clearactions"; }
-			static LPCSTR  ClearClassesA() { return  "clearclasses"; }
-			static LPCWSTR ClearClassesW() { return L"clearclasses"; }
-			static LPCSTR  HelloA()        { return  "hello"; }
-			static LPCWSTR HelloW()        { return L"hello"; }
-			static LPCSTR  HideA()         { return  "hide"; }
-			static LPCWSTR HideW()         { return L"hide"; }
-			static LPCSTR  IsVisibleA()    { return  "isvisible"; }
-			static LPCWSTR IsVisibleW()    { return L"isvisible"; }
-			static LPCSTR  NotifyA()       { return  "notify"; }
-			static LPCWSTR NotifyW()       { return L"notify"; }
-			static LPCSTR  RegisterA()     { return  "reg"; } // register
-			static LPCWSTR RegisterW()     { return L"reg"; }
-			static LPCSTR  RemoveClassA()  { return  "remclass"; }
-			static LPCWSTR RemoveClassW()  { return L"remclass"; }
-			static LPCSTR  UnregisterA()   { return  "unregister"; }
-			static LPCWSTR UnregisterW()   { return L"unregister"; }
-			static LPCSTR  UpdateAppA()    { return  "updateapp"; }
-			static LPCWSTR UpdateAppW()    { return L"updateapp"; }
-			static LPCSTR  UpdateA()       { return  "update"; }
-			static LPCWSTR UpdateW()       { return L"update"; }
-			static LPCSTR  VersionA()      { return  "version"; }
-			static LPCWSTR VersionW()      { return L"version"; }
-		};
+        void Add(const T* _key, LONG32 _value)
+        {
+            std::basic_stringstream<T> valStr;
+            valStr << _value;
+            list.push_back(PairType(std::basic_string<T>(_key), valStr.str()));
+        }
 
-		SnarlInterface();
-		virtual ~SnarlInterface();
+        void Add(const T* _key, void* _value)
+        {
+            if (_value != NULL)
+            {
+                std::basic_stringstream<T> valStr;
+                valStr << (INT_PTR)_value; // Uckly hack, to get stringstream to print void* as decimal not hex
 
-		// ------------------------------------------------------------------------------------
-		// Static functions
-		// ------------------------------------------------------------------------------------
+                list.push_back(PairType(std::basic_string<T>(_key), valStr.str()));
+            }
+        }
 
-		// Use FreeString, when SnarlInterface returns a null terminated string pointer
-		static LPTSTR AllocateString(size_t n) { return new TCHAR[n]; }
-		static void FreeString(LPSTR str)      { delete [] str; str = NULL; }
-		static void FreeString(LPCSTR str)     { delete [] str; }
-		static void FreeString(LPWSTR str)     { delete [] str; str = NULL; }
-		static void FreeString(LPCWSTR str)    { delete [] str; }
+        const std::vector<PairType>& GetList() const
+        {
+            return list;
+        }
 
-		/// <summary>Send message to Snarl.</summary>
-		/// <param name='request'>The request string. If using unicode version, the string will be UTF8 encoded before sending.</param>
-		/// <param name='replyTimeout'>Time to wait before timeout - Default = 1000</param>
-		/// <returns>
-		///   Return zero or positive on Success.
-		///   Negative on failure. (Get error code by abs(return_value))
-		///   <see>http://sourceforge.net/apps/mediawiki/snarlwin/index.php?title=Windows_API#Return_Value</see>
-		/// </returns>
-		static LONG32 DoRequest(LPCSTR request, UINT replyTimeout = 1000);
-		static LONG32 DoRequest(LPCWSTR request, UINT replyTimeout = 1000);
+    private:
+        std::vector<PairType> list;
+    };
 
-		/// <summary>Escapes a string, so it can be passed to Snarl.</summary>
-		/// <remarks>
-		///   Should only be used, if you are using DoRequest() and not the helper functions.
-		///   Remember to Escape each key/value pair individually.
-		/// </remarks>
-		static std::basic_string<char>& Escape(std::basic_string<char>& str);
-		static std::basic_string<wchar_t>& Escape(std::basic_string<wchar_t>& str);
+    // ----------------------------------------------------------------------------------------
+    // SnarlInterface class definition
+    // ----------------------------------------------------------------------------------------
+    class SnarlInterface
+    {
+    public:
+        /// <summary>Requests strings known by Snarl</summary>
+        class Requests
+        {
+        public:
+            static LPCSTR  AddActionA()    { return  "addaction"; }
+            static LPCWSTR AddActionW()    { return L"addaction"; }
+            static LPCSTR  AddClassA()     { return  "addclass"; }
+            static LPCWSTR AddClassW()     { return L"addclass"; }
+            static LPCSTR  ClearActionsA() { return  "clearactions"; }
+            static LPCWSTR ClearActionsW() { return L"clearactions"; }
+            static LPCSTR  ClearClassesA() { return  "clearclasses"; }
+            static LPCWSTR ClearClassesW() { return L"clearclasses"; }
+            static LPCSTR  HelloA()        { return  "hello"; }
+            static LPCWSTR HelloW()        { return L"hello"; }
+            static LPCSTR  HideA()         { return  "hide"; }
+            static LPCWSTR HideW()         { return L"hide"; }
+            static LPCSTR  IsVisibleA()    { return  "isvisible"; }
+            static LPCWSTR IsVisibleW()    { return L"isvisible"; }
+            static LPCSTR  NotifyA()       { return  "notify"; }
+            static LPCWSTR NotifyW()       { return L"notify"; }
+            static LPCSTR  RegisterA()     { return  "reg"; } // register
+            static LPCWSTR RegisterW()     { return L"reg"; }
+            static LPCSTR  RemoveClassA()  { return  "remclass"; }
+            static LPCWSTR RemoveClassW()  { return L"remclass"; }
+            static LPCSTR  UnregisterA()   { return  "unregister"; }
+            static LPCWSTR UnregisterW()   { return L"unregister"; }
+            static LPCSTR  UpdateAppA()    { return  "updateapp"; }
+            static LPCWSTR UpdateAppW()    { return L"updateapp"; }
+            static LPCSTR  UpdateA()       { return  "update"; }
+            static LPCWSTR UpdateW()       { return L"update"; }
+            static LPCSTR  VersionA()      { return  "version"; }
+            static LPCWSTR VersionW()      { return L"version"; }
+        };
 
-		/// <summary>Returns the global Snarl Application message  (V39)</summary>
-		/// <returns>Returns Snarl application registered message.</returns>
-		static UINT AppMsg();
+        SnarlInterface();
+        virtual ~SnarlInterface();
 
-		/// <summary>
-		///     Returns the value of Snarl's global registered message.
-		///     Notes:
-		///       Snarl registers SNARL_GLOBAL_MSG during startup which it then uses to communicate
-		///       with all running applications through a Windows broadcast message. This function can
-		///       only fail if for some reason the Windows RegisterWindowMessage() function fails
-		///       - given this, this function *cannnot* be used to test for the presence of Snarl.
-		/// </summary>
-		/// <returns>A 16-bit value (translated to 32-bit) which is the registered Windows message for Snarl.</returns>
-		static UINT Broadcast();
+        // ------------------------------------------------------------------------------------
+        // Static functions
+        // ------------------------------------------------------------------------------------
 
-		/// <summary>
-		///     Get the path to where Snarl is installed.
-		///     ** Remember to call <see cref="FreeString(LPSTR)" /> on the returned string !!!
-		/// </summary>
-		/// <returns>Returns the path to where Snarl is installed.</returns>
-		/// <remarks>This is a V39 API method.</remarks>
-		static LPCTSTR GetAppPath();
+        // Use FreeString, when SnarlInterface returns a null terminated string pointer
+        static LPTSTR AllocateString(size_t n) { return new TCHAR[n]; }
+        static void FreeString(LPSTR str)      { delete [] str; str = NULL; }
+        static void FreeString(LPCSTR str)     { delete [] str; }
+        static void FreeString(LPWSTR str)     { delete [] str; str = NULL; }
+        static void FreeString(LPCWSTR str)    { delete [] str; }
 
-		/// <summary>
-		///     Get the path to where the default Snarl icons are located.
-		///     <para>** Remember to call <see cref="FreeString(LPSTR)" /> on the returned string !!!</para>
-		/// </summary>
-		/// <returns>Returns the path to where the default Snarl icons are located.</returns>
-		/// <remarks>This is a V39 API method.</remarks>
-		static LPCTSTR GetIconsPath();
+        /// <summary>Send message to Snarl.</summary>
+        /// <param name='request'>The request string. If using unicode version, the string will be UTF8 encoded before sending.</param>
+        /// <param name='replyTimeout'>Time to wait before timeout - Default = 1000</param>
+        /// <returns>
+        ///   Return zero or positive on Success.
+        ///   Negative on failure. (Get error code by abs(return_value))
+        ///   <see>http://sourceforge.net/apps/mediawiki/snarlwin/index.php?title=Windows_API#Return_Value</see>
+        /// </returns>
+        static LONG32 DoRequest(LPCSTR request, UINT replyTimeout = 1000);
+        static LONG32 DoRequest(LPCWSTR request, UINT replyTimeout = 1000);
 
-		/// <summary>Returns a handle to the Snarl Dispatcher window  (V37)</summary>
-		/// <returns>Returns handle to Snarl Dispatcher window, or zero if it's not found.</returns>
-		/// <remarks>This is now the preferred way to test if Snarl is actually running.</remarks>
-		static HWND GetSnarlWindow();
+        /// <summary>Escapes a string, so it can be passed to Snarl.</summary>
+        /// <remarks>
+        ///   Should only be used, if you are using DoRequest() and not the helper functions.
+        ///   Remember to Escape each key/value pair individually.
+        /// </remarks>
+        static std::basic_string<char>& Escape(std::basic_string<char>& str);
+        static std::basic_string<wchar_t>& Escape(std::basic_string<wchar_t>& str);
 
-		/// <summary>Get Snarl version, if it is running.</summary>
-		/// <returns>Returns a number indicating Snarl version.</returns>
-		static LONG32 GetVersion();
+        /// <summary>Returns the global Snarl Application message  (V39)</summary>
+        /// <returns>Returns Snarl application registered message.</returns>
+        static UINT AppMsg();
 
-		/// <summary>Check whether Snarl is running</summary>
-		/// <returns>Returns true if Snarl system was found running.</returns>
-		static BOOL IsSnarlRunning();
+        /// <summary>
+        ///     Returns the value of Snarl's global registered message.
+        ///     Notes:
+        ///       Snarl registers SNARL_GLOBAL_MSG during startup which it then uses to communicate
+        ///       with all running applications through a Windows broadcast message. This function can
+        ///       only fail if for some reason the Windows RegisterWindowMessage() function fails
+        ///       - given this, this function *cannnot* be used to test for the presence of Snarl.
+        /// </summary>
+        /// <returns>A 16-bit value (translated to 32-bit) which is the registered Windows message for Snarl.</returns>
+        static UINT Broadcast();
 
-		
-		// ------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Get the path to where Snarl is installed.
+        ///     ** Remember to call <see cref="FreeString(LPSTR)" /> on the returned string !!!
+        /// </summary>
+        /// <returns>Returns the path to where Snarl is installed.</returns>
+        /// <remarks>This is a V39 API method.</remarks>
+        static LPCTSTR GetAppPath();
+
+        /// <summary>
+        ///     Get the path to where the default Snarl icons are located.
+        ///     <para>** Remember to call <see cref="FreeString(LPSTR)" /> on the returned string !!!</para>
+        /// </summary>
+        /// <returns>Returns the path to where the default Snarl icons are located.</returns>
+        /// <remarks>This is a V39 API method.</remarks>
+        static LPCTSTR GetIconsPath();
+
+        /// <summary>Returns a handle to the Snarl Dispatcher window  (V37)</summary>
+        /// <returns>Returns handle to Snarl Dispatcher window, or zero if it's not found.</returns>
+        /// <remarks>This is now the preferred way to test if Snarl is actually running.</remarks>
+        static HWND GetSnarlWindow();
+
+        /// <summary>Get Snarl version, if it is running.</summary>
+        /// <returns>Returns a number indicating Snarl version.</returns>
+        static LONG32 GetVersion();
+
+        /// <summary>Check whether Snarl is running</summary>
+        /// <returns>Returns true if Snarl system was found running.</returns>
+        static BOOL IsSnarlRunning();
 
 
-		/// <summary>Adds an action to an existing (on-screen or in the missed list) notification.</summary>
-		LONG32 AddAction(LONG32 msgToken, LPCSTR  label, LPCSTR  cmd);
-		LONG32 AddAction(LONG32 msgToken, LPCWSTR label, LPCWSTR cmd);
-		
-		/// <summary>Add a notification class to Snarl.</summary>
-		LONG32 AddClass(LPCSTR classId, LPCSTR name, LPCSTR title = NULL, LPCSTR text = NULL, LPCSTR icon = NULL, LPCSTR sound = NULL, LONG32 duration = NULL, LPCSTR callback = NULL, bool enabled = true);
-		LONG32 AddClass(LPCWSTR classId, LPCWSTR name, LPCWSTR title = NULL, LPCWSTR text = NULL, LPCWSTR icon = NULL, LPCWSTR sound = NULL, LONG32 duration = -1, LPCWSTR callback = NULL, bool enabled = true);
-
-		/// <summary>Remove all notification classes in one call.</summary>
-		LONG32 ClearActions(LONG32 msgToken);
-
-		/// <summary>Remove all notification classes in one call.</summary>
-		LONG32 ClearClasses();
-
-		/// <summary>GetLastMsgToken() returns token of the last message sent to Snarl.</summary>
-		/// <returns>Returns message token of last message.</returns>
-		/// <remarks>This function is not in the official API!</remarks>
-		LONG32 GetLastMsgToken() const;
-
-		/// <summary>Hide a Snarl notification.</summary>
-		LONG32 Hide(LONG32 msgToken);
-
-		/// <summary>Test if a Snarl notification is visible.</summary>
-		LONG32 IsVisible(LONG32 msgToken);
-
-		/// <summary>Show a Snarl notification.</summary>
-		/// <returns>Returns the notification token or negative on failure.</returns>
-		/// <remarks>You can use <see cref="GetLastMsgToken()" /> to get the last token.</remarks>
-		LONG32 Notify(LPCSTR classId = NULL, LPCSTR title = NULL, LPCSTR text = NULL, LONG32 timeout = -1, LPCSTR iconPath = NULL, LPCSTR iconBase64 = NULL, LONG32 priority = -2, LPCSTR ack = NULL, LPCSTR callback = NULL, LPCSTR value = NULL);
-		LONG32 Notify(LPCWSTR classId = NULL, LPCWSTR title = NULL, LPCWSTR text = NULL, LONG32 timeout = -1, LPCWSTR iconPath = NULL, LPCWSTR iconBase64 = NULL, LONG32 priority = -2, LPCWSTR ack = NULL, LPCWSTR callback = NULL, LPCWSTR value = NULL);
-
-		/// <summary>Register application with Snarl.</summary>
-		/// <returns>The application token or negative on failure.</returns>
-		/// <remarks>The application token is saved in SnarlInterface member variable, so just use return value to check for error.</remarks>
-		LONG32 Register(LPCSTR  signature, LPCSTR  title, LPCSTR  icon = NULL, LPCSTR  password = NULL, HWND hWndReplyTo = NULL, LONG32 msgReply = 0);
-		LONG32 Register(LPCWSTR signature, LPCWSTR title, LPCWSTR icon = NULL, LPCWSTR password = NULL, HWND hWndReplyTo = NULL, LONG32 msgReply = 0);
-
-		/// <summary>Remove a notification class added with AddClass().</summary>
-		LONG32 RemoveClass(LPCSTR classId);
-		LONG32 RemoveClass(LPCWSTR classId);
-		
-		/// <summary>Update the text or other parameters of a visible Snarl notification.</summary>
-		LONG32 Update(LONG32 msgToken, LPCSTR classId = NULL, LPCSTR title = NULL, LPCSTR text = NULL, LONG32 timeout = -1, LPCSTR iconPath = NULL, LPCSTR iconBase64 = NULL, LONG32 priority = -2, LPCSTR ack = NULL, LPCSTR callback = NULL, LPCSTR value = NULL);
-		LONG32 Update(LONG32 msgToken, LPCWSTR classId = NULL, LPCWSTR title = NULL, LPCWSTR text = NULL, LONG32 timeout = -1, LPCWSTR iconPath = NULL, LPCWSTR iconBase64 = NULL, LONG32 priority = -2, LPCWSTR ack = NULL, LPCWSTR callback = NULL, LPCWSTR value = NULL);
-
-		/// <summary>Unregister application with Snarl when application is closing.</summary>
-		LONG32 Unregister(LPCSTR signature);
-		LONG32 Unregister(LPCWSTR signature);
-
-		/// <summary>Update information provided when calling RegisterApp.</summary>
-		/*LONG32 UpdateApp(LPCSTR title = NULL, LPCSTR icon = NULL);
-		LONG32 UpdateApp(LPCWSTR title = NULL, LPCWSTR icon = NULL);*/
+        // ------------------------------------------------------------------------------------
 
 
-	private:
+        /// <summary>Adds an action to an existing (on-screen or in the missed list) notification.</summary>
+        LONG32 AddAction(LONG32 msgToken, LPCSTR  label, LPCSTR  cmd);
+        LONG32 AddAction(LONG32 msgToken, LPCWSTR label, LPCWSTR cmd);
 
-		/// <summary>Convert a unicode string to UTF8</summary>
-		/// <returns>Returns pointer to the new string - Remember to delete [] returned string !</returns>
-		/// <remarks>Remember to call FreeString on returned string !!!</remarks>
-		static LPSTR  WideToUTF8(LPCWSTR szWideStr);
+        /// <summary>Add a notification class to Snarl.</summary>
+        LONG32 AddClass(LPCSTR classId, LPCSTR name, LPCSTR title = NULL, LPCSTR text = NULL, LPCSTR icon = NULL, LPCSTR sound = NULL, LONG32 duration = NULL, LPCSTR callback = NULL, bool enabled = true);
+        LONG32 AddClass(LPCWSTR classId, LPCWSTR name, LPCWSTR title = NULL, LPCWSTR text = NULL, LPCWSTR icon = NULL, LPCWSTR sound = NULL, LONG32 duration = -1, LPCWSTR callback = NULL, bool enabled = true);
 
-		static LONG32 DoRequest(LPCSTR request, SnarlParameterList<char>& spl, UINT replyTimeout = 1000);
-		static LONG32 DoRequest(LPCWSTR request, SnarlParameterList<wchar_t>& spl, UINT replyTimeout = 1000);
+        /// <summary>Remove all notification classes in one call.</summary>
+        LONG32 ClearActions(LONG32 msgToken);
 
-		void SetPassword(LPCSTR password);
-		void SetPassword(LPCWSTR password);
-		void ClearPassword();
+        /// <summary>Remove all notification classes in one call.</summary>
+        LONG32 ClearClasses();
 
-		LONG32 appToken;
-		LONG32 lastMsgToken;
-		LPSTR szPasswordA;
-		LPWSTR szPasswordW;
-	}; // class SnarlInterface
+        /// <summary>GetLastMsgToken() returns token of the last message sent to Snarl.</summary>
+        /// <returns>Returns message token of last message.</returns>
+        /// <remarks>This function is not in the official API!</remarks>
+        LONG32 GetLastMsgToken() const;
 
-	} // namespace V42
+        /// <summary>Hide a Snarl notification.</summary>
+        LONG32 Hide(LONG32 msgToken);
+
+        /// <summary>Test if a Snarl notification is visible. If the message is visible the function returns SnarlEnums::Success.</summary>
+        LONG32 IsVisible(LONG32 msgToken);
+
+        /// <summary>Show a Snarl notification.</summary>
+        /// <returns>Returns the notification token or negative on failure.</returns>
+        /// <remarks>You can use <see cref="GetLastMsgToken()" /> to get the last token.</remarks>
+        LONG32 Notify(LPCSTR classId = NULL, LPCSTR title = NULL, LPCSTR text = NULL, LONG32 timeout = -1, LPCSTR iconPath = NULL, LPCSTR iconBase64 = NULL, SnarlEnums::MessagePriority priority = SnarlEnums::PriorityUndefined, LPCSTR uid = NULL, LPCSTR callback = NULL, LPCSTR value = NULL);
+        LONG32 Notify(LPCWSTR classId = NULL, LPCWSTR title = NULL, LPCWSTR text = NULL, LONG32 timeout = -1, LPCWSTR iconPath = NULL, LPCWSTR iconBase64 = NULL,  SnarlEnums::MessagePriority priority = SnarlEnums::PriorityUndefined, LPCWSTR uid = NULL, LPCWSTR callback = NULL, LPCWSTR value = NULL);
+
+        /// <summary>Register application with Snarl.</summary>
+        /// <returns>The application token or negative on failure.</returns>
+        /// <remarks>The application token is saved in SnarlInterface member variable, so just use return value to check for error.</remarks>
+        LONG32 Register(LPCSTR  signature, LPCSTR  title, LPCSTR  icon = NULL, LPCSTR  password = NULL, HWND hWndReplyTo = NULL, LONG32 msgReply = 0, SnarlEnums::AppFlags flags = SnarlEnums::AppFlagNone);
+        LONG32 Register(LPCWSTR signature, LPCWSTR title, LPCWSTR icon = NULL, LPCWSTR password = NULL, HWND hWndReplyTo = NULL, LONG32 msgReply = 0, SnarlEnums::AppFlags flags = SnarlEnums::AppFlagNone);
+
+        /// <summary>Remove a notification class added with AddClass().</summary>
+        LONG32 RemoveClass(LPCSTR classId);
+        LONG32 RemoveClass(LPCWSTR classId);
+
+        /// <summary>Update the text or other parameters of a visible Snarl notification.</summary>
+        LONG32 Update(LONG32 msgToken, LPCSTR classId = NULL, LPCSTR title = NULL, LPCSTR text = NULL, LONG32 timeout = -1, LPCSTR iconPath = NULL, LPCSTR iconBase64 = NULL, SnarlEnums::MessagePriority priority = SnarlEnums::PriorityUndefined, LPCSTR callback = NULL, LPCSTR value = NULL);
+        LONG32 Update(LONG32 msgToken, LPCWSTR classId = NULL, LPCWSTR title = NULL, LPCWSTR text = NULL, LONG32 timeout = -1, LPCWSTR iconPath = NULL, LPCWSTR iconBase64 = NULL, SnarlEnums::MessagePriority priority = SnarlEnums::PriorityUndefined, LPCWSTR callback = NULL, LPCWSTR value = NULL);
+
+        /// <summary>Unregister application with Snarl when application is closing.</summary>
+        LONG32 Unregister(LPCSTR signature);
+        LONG32 Unregister(LPCWSTR signature);
+
+        /// <summary>Update information provided when calling RegisterApp.</summary>
+        /*LONG32 UpdateApp(LPCSTR title = NULL, LPCSTR icon = NULL);
+        LONG32 UpdateApp(LPCWSTR title = NULL, LPCWSTR icon = NULL);*/
+
+
+    private:
+
+        /// <summary>Convert a unicode string to UTF8</summary>
+        /// <returns>Returns pointer to the new string - Remember to delete [] returned string !</returns>
+        /// <remarks>Remember to call FreeString on returned string !!!</remarks>
+        static LPSTR  WideToUTF8(LPCWSTR szWideStr);
+
+        static LONG32 DoRequest(LPCSTR request, SnarlParameterList<char>& spl, UINT replyTimeout = 1000);
+        static LONG32 DoRequest(LPCWSTR request, SnarlParameterList<wchar_t>& spl, UINT replyTimeout = 1000);
+
+        void SetPassword(LPCSTR password);
+        void SetPassword(LPCWSTR password);
+        void ClearPassword();
+
+        LONG32 appToken;
+        LONG32 lastMsgToken;
+        LPSTR szPasswordA;
+        LPWSTR szPasswordW;
+    }; // class SnarlInterface
+
+    } // namespace V42
 } // namespace Snarl
 
 #endif // SNARL_INTERFACE_V42_H
+
diff --git a/src/plugins/backends/snarl/snarl.cpp b/src/plugins/backends/snarl/snarl.cpp
index 92dc4f3..f73e440 100644
--- a/src/plugins/backends/snarl/snarl.cpp
+++ b/src/plugins/backends/snarl/snarl.cpp
@@ -175,6 +175,20 @@ void SnarlBackend::slotNotify(Notification notification){
         snarlInterface = m_defautSnarlinetrface;
     }
 
+    Snarl::V42::SnarlEnums::MessagePriority priority = Snarl::V42::SnarlEnums::PriorityUndefined;
+    switch(notification.priority())
+    {
+    case NotificationEnums::Prioritys::LOW:
+        priority = Snarl::V42::SnarlEnums::PriorityLow;
+        break;
+    case NotificationEnums::Prioritys::NORMAL:
+        priority = Snarl::V42::SnarlEnums::PriorityNormal;
+        break;
+    case NotificationEnums::Prioritys::HIGH:
+        priority = Snarl::V42::SnarlEnums::PriorityHigh;
+        break;
+    }
+
     if(!m_idMap.contains(notification.id())){
         ULONG32 id = snarlInterface->Notify(notification.alert().toUtf8().constData(),
                                             Notification::toPlainText(notification.title()).toUtf8().constData(),
@@ -182,7 +196,7 @@ void SnarlBackend::slotNotify(Notification notification){
                                             notification.timeout(),
                                             notification.icon().isLocalFile()?notification.icon().localUrl().toUtf8().constData():0,
                                             !notification.icon().isLocalFile()?notification.icon().imageData().toBase64().constData():0,
-                                            notification.priority());
+                                            priority);
 
         foreach(const Notification::Action *a, notification.actions()){
             snarlInterface->AddAction(id,a->name.toUtf8().constData(),QString("@").append(QString::number(a->id)).toUtf8().constData());
@@ -198,7 +212,7 @@ void SnarlBackend::slotNotify(Notification notification){
                 notification.timeout(),
                 notification.icon().isLocalFile()?notification.icon().localUrl().toUtf8().constData():0,
                 !notification.icon().isLocalFile()?notification.icon().imageData().toBase64().constData():0,
-                notification.priority());
+                priority);
     }
     startTimeout(notification.id(),notification.timeout());
 }