new generation of fingerprint plugin

git-svn-id: http://svn.miranda-ng.org/main/trunk@2360 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 1102 insertions, 0 deletions

diff --git a/plugins/FingerprintNG/src/fingerprint.cpp b/plugins/FingerprintNG/src/fingerprint.cpp
new file mode 100644
index 0000000000..c191152f60
--- /dev/null
+++ b/plugins/FingerprintNG/src/fingerprint.cpp
@@ -0,0 +1,1102 @@
+/*

+Fingerprint NG (client version) icons module for Miranda NG

+Copyright © 2006-12 ghazan, mataes, HierOS, FYR, Bio, nullbie, faith_healer and all respective contributors.

+

+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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

+*/

+

+//Start of header

+#include "global.h"

+

+static UINT g_LPCodePage;

+static TCHAR g_szSkinLib[MAX_PATH];

+static HANDLE hExtraIcon = NULL;

+static HANDLE hFolderChanged = NULL, hIconFolder = NULL;

+

+static FOUNDINFO* fiList = NULL;

+static int nFICount = 0;

+

+/*

+*	Prepare

+*	prepares upperstring masks and registers them in IcoLib

+*/

+

+static TCHAR* getSectionName(int flag)

+{

+	switch(flag)

+	{

+		#include "finger_groups.h"

+	}

+	return NULL;

+}

+

+void FASTCALL Prepare(KN_FP_MASK* mask, bool bEnable)

+{

+	mask->szMaskUpper = NULL;

+

+	if (mask->hIcolibItem)

+		Skin_RemoveIcon(mask->szIconName);

+	mask->hIcolibItem = NULL;

+

+	if (!mask->szMask || !mask->szIconFileName || !bEnable)

+		return;

+

+	size_t iMaskLen = _tcslen(mask->szMask) + 1;

+	LPTSTR pszNewMask = (LPTSTR)HeapAlloc(hHeap, HEAP_NO_SERIALIZE, iMaskLen * sizeof(TCHAR));

+	_tcscpy_s(pszNewMask, iMaskLen, mask->szMask);

+	_tcsupr_s(pszNewMask, iMaskLen);

+	mask->szMaskUpper = pszNewMask;

+

+	TCHAR destfile[MAX_PATH];

+	if (*mask->szIconFileName == 0)

+		GetModuleFileName(g_hInst, destfile, MAX_PATH);

+	else {

+		mir_sntprintf(destfile, SIZEOF(destfile), _T("%s\\%s.dll"), g_szSkinLib, mask->szIconFileName);

+

+		struct _stat64i32 stFileInfo;

+		if ( _tstat(destfile, &stFileInfo) == -1)

+			return;

+	}

+

+	LPTSTR SectName = getSectionName(mask->iSectionFlag);

+	if (SectName == NULL)

+		return;

+

+	SKINICONDESC sid = { 0 };

+	sid.cbSize = sizeof(sid);

+	sid.flags = SIDF_ALL_TCHAR;

+	sid.ptszSection = SectName;

+	sid.pszName = mask->szIconName;

+	sid.ptszDescription = mask->szClientDescription;

+	sid.ptszDefaultFile = destfile;

+	sid.iDefaultIndex = -mask->iIconIndex;

+	sid.cx = sid.cy = 16;

+	mask->hIcolibItem = Skin_AddIcon(&sid);

+}

+

+/*

+*	Register icons

+*/

+

+void RegisterIcons()

+{

+	// prepare masks

+	int i;

+

+	if (hHeap)

+		HeapDestroy(hHeap);

+	hHeap = HeapCreate(HEAP_NO_SERIALIZE, 0, 0);

+

+	for (i=0; i < DEFAULT_KN_FP_MASK_COUNT; i++)

+		Prepare(&def_kn_fp_mask[i], true);

+

+	bool bEnable = db_get_b(NULL, "Finger", "Overlay1", 1) != 0;

+	for (i=0; i < DEFAULT_KN_FP_OVERLAYS_COUNT; i++)

+		Prepare(&def_kn_fp_overlays_mask[i], bEnable);

+

+	bEnable = db_get_b(NULL, "Finger", "Overlay2", 1) != 0;

+	if ( db_get_b(NULL, "Finger", "ShowVersion", 0)) {

+		for (i = 0; i < DEFAULT_KN_FP_OVERLAYS2_COUNT; i++)

+			Prepare(&def_kn_fp_overlays2_mask[i], bEnable);

+	}

+	else {

+		for (i=0; i < DEFAULT_KN_FP_OVERLAYS2_NO_VER_COUNT; i++)

+			Prepare(&def_kn_fp_overlays2_mask[i], bEnable);

+		for (; i < DEFAULT_KN_FP_OVERLAYS2_COUNT; i++)

+			Prepare(&def_kn_fp_overlays2_mask[i], false);

+	}

+

+	bEnable = db_get_b(NULL, "Finger", "Overlay3", 1) != 0;

+	for (i=0; i < DEFAULT_KN_FP_OVERLAYS3_COUNT; i++)

+		Prepare(&def_kn_fp_overlays3_mask[i], bEnable);

+}

+

+/*

+*	OnModulesLoaded

+*	Hook necessary events here

+*/

+int OnModulesLoaded(WPARAM wParam, LPARAM lParam)

+{

+	g_LPCodePage = CallService(MS_LANGPACK_GETCODEPAGE, 0, 0);

+

+	//Hook necessary events

+	HookEvent(ME_SKIN2_ICONSCHANGED, OnIconsChanged);

+	HookEvent(ME_DB_CONTACT_SETTINGCHANGED, OnContactSettingChanged);

+	HookEvent(ME_OPT_INITIALISE, OnOptInitialise);

+

+	hExtraIcon = ExtraIcon_Register("Client","Fingerprint","client_Miranda_Unknown",

+		OnExtraIconListRebuild,OnExtraImageApply,OnExtraIconClick);

+

+	if (ServiceExists(MS_FOLDERS_REGISTER_PATH)) {

+		hIconFolder = FoldersRegisterCustomPathT("Fingerprint", "Icons", _T(MIRANDA_PATH) _T("\\") DEFAULT_SKIN_FOLDER);

+		FoldersGetCustomPathT(hIconFolder, g_szSkinLib, SIZEOF(g_szSkinLib), _T(""));

+	}

+	else CallService(MS_UTILS_PATHTOABSOLUTET, (WPARAM)DEFAULT_SKIN_FOLDER, (LPARAM)g_szSkinLib);

+

+	RegisterIcons();

+	return 0;

+}

+

+/*	ApplyFingerprintImage

+*	 1)Try to find appropriate mask

+*	 2)Register icon in extraimage list if not yet registered (EMPTY_EXTRA_ICON)

+*	 3)Set ExtraImage for contact

+*/

+

+int FASTCALL ApplyFingerprintImage(HANDLE hContact, LPTSTR szMirVer)

+{

+	if (hContact == NULL)

+		return 0;

+

+	HANDLE hImage = INVALID_HANDLE_VALUE;

+	if (szMirVer)

+		hImage = GetIconIndexFromFI(szMirVer);

+

+	ExtraIcon_SetIcon(hExtraIcon,hContact,hImage);

+	return 0;

+}

+

+int OnExtraIconClick(WPARAM wParam, LPARAM lParam, LPARAM)

+{

+	CallService(MS_USERINFO_SHOWDIALOG, wParam, NULL);

+	return 0;

+}

+

+/*

+*	OnExtraIconListRebuild

+*	Set all registered indexes in array to EMPTY_EXTRA_ICON (unregistered icon)

+*/

+int OnExtraIconListRebuild(WPARAM wParam, LPARAM lParam)

+{

+	ClearFI();

+	return 0;

+}

+

+/*

+*	OnIconsChanged

+*/

+int OnIconsChanged(WPARAM wParam, LPARAM lParam)

+{

+	ClearFI();

+	return 0;

+}

+

+/*

+*	 OnExtraImageApply

+*	 Try to get MirVer value from db for contact and if success calls ApplyFingerprintImage

+*/

+

+int OnExtraImageApply(WPARAM wParam, LPARAM lParam)

+{

+	HANDLE hContact = (HANDLE)wParam;

+	if (hContact == NULL)

+		return 0;

+

+	char *szProto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO,wParam,0);

+	if (szProto != NULL) {

+		DBVARIANT dbvMirVer = { 0 };

+

+		if (!DBGetContactSettingTString(hContact, szProto, "MirVer", &dbvMirVer)) {

+			ApplyFingerprintImage(hContact, dbvMirVer.ptszVal);

+			DBFreeVariant(&dbvMirVer);

+		}

+		else ApplyFingerprintImage(hContact, NULL);

+	}

+	else ApplyFingerprintImage(hContact, NULL);

+	return 0;

+}

+

+/*

+*	 OnContactSettingChanged

+*	 if contact settings changed apply new image or remove it

+*/

+int OnContactSettingChanged(WPARAM wParam, LPARAM lParam)

+{

+	if ((HANDLE)wParam == NULL)

+		return 0;

+

+	DBCONTACTWRITESETTING* cws = (DBCONTACTWRITESETTING*)lParam;

+	if (cws && cws->szSetting && !strcmp(cws->szSetting, "MirVer")) {

+		if (cws->value.type == DBVT_UTF8) {

+			LPWSTR wszVal = NULL;

+			int iValLen = MultiByteToWideChar(CP_UTF8, 0, cws->value.pszVal, -1, NULL, 0);

+			if (iValLen > 0) {

+				wszVal = (LPWSTR)mir_alloc(iValLen * sizeof(WCHAR));

+				MultiByteToWideChar(CP_UTF8, 0, cws->value.pszVal, -1, wszVal, iValLen);

+			}

+			ApplyFingerprintImage((HANDLE)wParam, wszVal);

+			mir_free(wszVal);

+		}

+		else if (cws->value.type == DBVT_ASCIIZ) {

+			LPWSTR wszVal = NULL;

+			int iValLen = MultiByteToWideChar(g_LPCodePage, 0, cws->value.pszVal, -1, NULL, 0);

+			if (iValLen > 0) {

+				wszVal = (LPWSTR)mir_alloc(iValLen * sizeof(WCHAR));

+				MultiByteToWideChar(g_LPCodePage, 0, cws->value.pszVal, -1, wszVal, iValLen);

+			}

+			ApplyFingerprintImage((HANDLE)wParam, wszVal);

+			mir_free(wszVal);

+		}

+		else if (cws->value.type == DBVT_WCHAR) {

+			ApplyFingerprintImage((HANDLE)wParam, cws->value.pwszVal);

+		}

+		else ApplyFingerprintImage((HANDLE)wParam, NULL);

+	}

+	return 0;

+}

+

+/*

+*	WildCompareA

+*	Compare 'name' string with 'mask' strings.

+*	Masks can contain '*' or '?' wild symbols

+*	Asterics '*' symbol covers 'empty' symbol too e.g WildCompare("Tst","T*st*"), returns TRUE

+*	In order to handle situation 'at least one any sybol' use "?*" combination:

+*	e.g WildCompare("Tst","T?*st*"), returns FALSE, but both WildCompare("Test","T?*st*") and

+*	WildCompare("Teeest","T?*st*") return TRUE.

+*

+*	Function is case sensitive! so convert input or modify func to use _qtoupper()

+*

+*	Mask can contain several submasks. In this case each submask (including first)

+*	should start from '|' e.g: "|first*submask|second*mask".

+*

+*	Dec 25, 2006 by FYR:

+*	Added Exception to masks: the mask "|^mask3|mask2|mask1" means:

+*	if NOT according to mask 3 AND (mask1 OR mask2)

+*	EXCEPTION should be BEFORE main mask:

+*		IF Exception match - the comparing stops as FALSE

+*		IF Exception does not match - comparing continue

+*		IF Mask match - comparing stops as TRUE

+*		IF Mask does not not match comparing continue

+*/

+BOOL FASTCALL WildCompareA(LPSTR szName, LPSTR szMask)

+{

+	if (*szMask != '|')

+		return WildCompareProcA(szName, szMask);

+

+	size_t s = 1, e = 1;

+	LPSTR szTemp = (LPSTR)_alloca(strlen(szMask) * sizeof(CHAR) + sizeof(CHAR));

+	BOOL bExcept;

+

+	while(szMask[e] != '\0') {

+		s = e;

+		while(szMask[e] != '\0' && szMask[e] != '|') e++;

+

+		// exception mask

+		bExcept = (*(szMask + s) == '^');

+		if (bExcept) s++;

+

+		memcpy(szTemp, szMask + s, (e - s) * sizeof(CHAR));

+		szTemp[e - s] = '\0';

+

+		if (WildCompareProcA(szName, szTemp))

+			return !bExcept;

+

+		if (szMask[e] != '\0')

+			e++;

+		else

+			return FALSE;

+	}

+	return FALSE;

+}

+

+/*

+*	WildCompareW

+*	Compare 'name' string with 'mask' strings.

+*	Masks can contain '*' or '?' wild symbols

+*	Asterics '*' symbol covers 'empty' symbol too e.g WildCompare("Tst","T*st*"), returns TRUE

+*	In order to handle situation 'at least one any sybol' use "?*" combination:

+*	e.g WildCompare("Tst","T?*st*"), returns FALSE, but both WildCompare("Test","T?*st*") and

+*	WildCompare("Teeest","T?*st*") return TRUE.

+*

+*	Function is case sensitive! so convert input or modify func to use _qtoupper()

+*

+*	Mask can contain several submasks. In this case each submask (including first)

+*	should start from '|' e.g: "|first*submask|second*mask".

+*

+*	Dec 25, 2006 by FYR:

+*	Added Exception to masks: the mask "|^mask3|mask2|mask1" means:

+*	if NOT according to mask 3 AND (mask1 OR mask2)

+*	EXCEPTION should be BEFORE main mask:

+*		IF Exception match - the comparing stops as FALSE

+*		IF Exception does not match - comparing continue

+*		IF Mask match - comparing stops as TRUE

+*		IF Mask does not not match comparing continue

+*/

+BOOL FASTCALL WildCompareW(LPWSTR wszName, LPWSTR wszMask)

+{

+	if (wszMask == NULL)

+		return NULL;

+

+	if (*wszMask != L'|')

+		return WildCompareProcW(wszName, wszMask);

+

+	size_t s = 1, e = 1;

+	LPWSTR wszTemp = (LPWSTR)_alloca(wcslen(wszMask) * sizeof(WCHAR) + sizeof(WCHAR));

+	BOOL bExcept;

+

+	while(wszMask[e] != L'\0')

+	{

+		s = e;

+		while(wszMask[e] != L'\0' && wszMask[e] != L'|') e++;

+

+		// exception mask

+		bExcept = (*(wszMask + s) == L'^');

+		if (bExcept) s++;

+

+		memcpy(wszTemp, wszMask + s, (e - s) * sizeof(WCHAR));

+		wszTemp[e - s] = L'\0';

+

+		if (WildCompareProcW(wszName, wszTemp))

+			return !bExcept;

+

+		if (wszMask[e] != L'\0')

+			e++;

+		else

+			return FALSE;

+	}

+	return FALSE;

+}

+

+BOOL __inline WildCompareProcA(LPSTR szName, LPSTR szMask)

+{

+	LPSTR szLast = NULL;

+	for (;; szMask++, szName++)

+	{

+		if (*szMask != '?' && *szMask != *szName) break;

+		if (*szName == '\0') return ((BOOL)!*szMask);

+	}

+	if (*szMask != '*') return FALSE;

+	for (;; szMask++, szName++)

+	{

+		while(*szMask == '*')

+		{

+			szLast = szMask++;

+			if (*szMask == '\0') return ((BOOL)!*szMask);	/* true */

+		}

+		if (*szName == '\0') return ((BOOL)!*szMask);		/* *mask == EOS */

+		if (*szMask != '?' && *szMask != *szName && szLast != NULL)

+		{

+			szName -= (size_t)(szMask - szLast) - 1;

+			szMask = szLast;

+		}

+	}

+}

+

+BOOL __inline WildCompareProcW(LPWSTR wszName, LPWSTR wszMask)

+{

+	LPWSTR wszLast = NULL;

+	for (;; wszMask++, wszName++)

+	{

+		if (*wszMask != L'?' && *wszMask != *wszName) break;

+		if (*wszName == L'\0') return ((BOOL)!*wszMask);

+	}

+	if (*wszMask != L'*') return FALSE;

+	for (;; wszMask++, wszName++)

+	{

+		while(*wszMask == L'*')

+		{

+			wszLast = wszMask++;

+			if (*wszMask == L'\0') return ((BOOL)!*wszMask);	/* true */

+		}

+		if (*wszName == L'\0') return ((BOOL)!*wszMask);		/* *mask == EOS */

+		if (*wszMask != L'?' && *wszMask != *wszName && wszLast != NULL)

+		{

+			wszName -= (size_t)(wszMask - wszLast) - 1;

+			wszMask = wszLast;

+		}

+	}

+}

+

+static void MatchMasks(TCHAR* szMirVer, short *base, short *overlay,short *overlay2,short *overlay3)

+{

+	short i = 0, j = -1, k = -1, n = -1;

+

+	for (i=0; i < DEFAULT_KN_FP_MASK_COUNT; i++) {

+		KN_FP_MASK& p = def_kn_fp_mask[i];

+		if (p.hIcolibItem == NULL)

+			continue;

+

+		if ( !WildCompareW(szMirVer, p.szMaskUpper))

+			continue;

+

+		if (p.szIconFileName != _T("")) {

+			TCHAR destfile[MAX_PATH];

+			mir_sntprintf(destfile, SIZEOF(destfile), _T("%s\\%s.dll"), g_szSkinLib, p.szIconFileName);

+			struct _stat64i32 stFileInfo;

+

+			if (_tstat(destfile, &stFileInfo) == -1)

+				i = NOTFOUND_MASK_NUMBER;

+		}

+		break;

+	}

+

+	if (!def_kn_fp_mask[i].fNotUseOverlay && i < DEFAULT_KN_FP_MASK_COUNT) {

+		for (j = 0; j < DEFAULT_KN_FP_OVERLAYS_COUNT; j++) {

+			KN_FP_MASK& p = def_kn_fp_overlays_mask[j];

+			if (p.hIcolibItem == NULL)

+				continue;

+

+			if ( !WildCompare(szMirVer, p.szMaskUpper))

+				continue;

+

+			if (p.szIconFileName != _T("ClientIcons_packs"))

+				break;

+

+			TCHAR destfile[MAX_PATH];

+			mir_sntprintf(destfile, SIZEOF(destfile), _T("%s\\%s.dll"), g_szSkinLib, p.szIconFileName);

+

+			struct _stat64i32 stFileInfo;

+			if ( _tstat(destfile, &stFileInfo) != -1)

+				break;

+		}

+

+		for (k = 0; k < DEFAULT_KN_FP_OVERLAYS2_COUNT; k++) {

+			KN_FP_MASK& p = def_kn_fp_overlays2_mask[k];

+			if (p.hIcolibItem == NULL)

+				continue;

+

+			if ( WildCompareW(szMirVer, p.szMaskUpper))

+				break;

+		}

+

+		for (n = 0; n < DEFAULT_KN_FP_OVERLAYS3_COUNT; n++) {

+			KN_FP_MASK& p = def_kn_fp_overlays3_mask[n];

+			if (p.hIcolibItem == NULL)

+				continue;

+

+			if ( WildCompareW(szMirVer, p.szMaskUpper))

+				break;

+		}

+	}

+

+	*base = (i < DEFAULT_KN_FP_MASK_COUNT) ? i : -1;

+	*overlay = (j < DEFAULT_KN_FP_OVERLAYS_COUNT) ? j : -1;

+	*overlay2 = (k < DEFAULT_KN_FP_OVERLAYS2_COUNT) ? k : -1;

+	*overlay3 = (n < DEFAULT_KN_FP_OVERLAYS3_COUNT) ? n : -1;

+}

+

+/*	GetIconsIndexesA

+*	Retrieves Icons indexes by Mirver

+*/

+

+void FASTCALL GetIconsIndexesA(LPSTR szMirVer, short *base, short *overlay,short *overlay2,short *overlay3)

+{

+	if (strcmp(szMirVer, "?") == 0) {

+		*base = UNKNOWN_MASK_NUMBER;

+		*overlay = -1;

+		*overlay2 = -1;

+		*overlay3 = -1;

+		return;

+	}

+

+	LPTSTR tszMirVerUp = mir_a2t(szMirVer);

+	_tcsupr(tszMirVerUp);

+	MatchMasks(tszMirVerUp, base, overlay, overlay2, overlay3);

+	mir_free(tszMirVerUp);

+}

+

+/*	GetIconsIndexesW

+*	Retrieves Icons indexes by Mirver

+*/

+

+void FASTCALL GetIconsIndexesW(LPWSTR wszMirVer, short *base, short *overlay,short *overlay2,short *overlay3)

+{

+	if (wcscmp(wszMirVer, L"?") == 0)

+	{

+		*base = UNKNOWN_MASK_NUMBER;

+		*overlay = -1;

+		*overlay2 = -1;

+		*overlay3 = -1;

+		return;

+	}

+

+	LPWSTR wszMirVerUp = NEWWSTR_ALLOCA(wszMirVer);

+	_wcsupr(wszMirVerUp);

+	MatchMasks(wszMirVerUp, base, overlay, overlay2, overlay3);

+}

+

+/*

+* CreateIconFromIndexes

+* returns hIcon of joined icon by given indexes

+*/

+

+HICON FASTCALL CreateIconFromIndexes(short base, short overlay, short overlay2, short overlay3)

+{

+	HICON hIcon = NULL;	// returned HICON

+	HICON hTmp = NULL;

+	HICON icMain = NULL;

+	HICON icOverlay = NULL;

+	HICON icOverlay2 = NULL;

+	HICON icOverlay3 = NULL;

+

+	KN_FP_MASK* mainMask = &(def_kn_fp_mask[base]);

+	icMain = Skin_GetIconByHandle(mainMask->hIcolibItem);

+

+	if (icMain) {

+		KN_FP_MASK* overlayMask = (overlay != -1) ? &(def_kn_fp_overlays_mask[overlay]) : NULL;

+		KN_FP_MASK* overlay2Mask = (overlay2 != -1) ? &(def_kn_fp_overlays2_mask[overlay2]) : NULL;

+		KN_FP_MASK* overlay3Mask = (overlay3 != -1) ? &(def_kn_fp_overlays3_mask[overlay3]) : NULL;

+		icOverlay = (overlayMask == NULL) ? NULL : Skin_GetIconByHandle(overlayMask->hIcolibItem);

+		icOverlay2 = (overlay2Mask == NULL) ? NULL : Skin_GetIconByHandle(overlay2Mask->hIcolibItem);

+		icOverlay3 = (overlay3Mask == NULL) ? NULL : Skin_GetIconByHandle(overlay3Mask->hIcolibItem);

+

+		hIcon = icMain;

+

+		if (overlayMask) {

+			hIcon = CreateJoinedIcon(hIcon, icOverlay);

+			hTmp = hIcon;

+		}

+

+		if (overlay2Mask) {

+			hIcon = CreateJoinedIcon(hIcon, icOverlay2);

+			if (hTmp) DestroyIcon(hTmp);

+			hTmp = hIcon;

+		}

+

+		if (overlay3Mask) {

+			hIcon = CreateJoinedIcon(hIcon, icOverlay3);

+			if (hTmp) DestroyIcon(hTmp);

+		}

+	}

+

+	if (hIcon == icMain)

+		hIcon = CopyIcon(icMain);

+

+	Skin_ReleaseIcon(icMain);

+	Skin_ReleaseIcon(icOverlay);

+	Skin_ReleaseIcon(icOverlay2);

+	Skin_ReleaseIcon(icOverlay3);

+	return hIcon;

+}

+

+/*

+*	ServiceGetClientIconA

+*	MS_FP_GETCLIENTICON service implementation.

+*	wParam - char * MirVer value to get client for.

+*	lParam - int noCopy - if wParam is equal to "1"	will return icon handler without copiing icon.

+*	ICON IS ALWAYS COPIED!!!

+*/

+

+INT_PTR ServiceGetClientIconA(WPARAM wParam, LPARAM lParam)

+{

+	LPSTR szMirVer = (LPSTR)wParam;			// MirVer value to get client for.

+	if (szMirVer == NULL)

+		return 0;

+

+	HICON hIcon = NULL;			// returned HICON

+	int NoCopy = (int)lParam;	// noCopy

+	short base, overlay, overlay2, overlay3;

+

+	GetIconsIndexesA(szMirVer, &base, &overlay, &overlay2, &overlay3);

+	if (base != -1)

+		hIcon = CreateIconFromIndexes(base, overlay, overlay2, overlay3);

+	return (INT_PTR)hIcon;

+}

+

+/*

+ *	 ServiceSameClientA

+ *	 MS_FP_SAMECLIENTS service implementation.

+ *	 wParam - char * first MirVer value

+ *	 lParam - char * second MirVer value

+ *	 return pointer to char string - client desription (do not destroy) if clients are same

+ */

+

+INT_PTR ServiceSameClientsA(WPARAM wParam, LPARAM lParam)

+{

+	LPSTR szMirVerFirst = (LPSTR)wParam;	// MirVer value to get client for.

+	LPSTR szMirVerSecond = (LPSTR)lParam;	// MirVer value to get client for.

+	int firstIndex, secondIndex;

+	BOOL Result = FALSE;

+

+	firstIndex = secondIndex = 0;

+	if (!szMirVerFirst || !szMirVerSecond)

+		return (INT_PTR)NULL;	//one of its is not null

+

+	{

+		LPTSTR tszMirVerFirstUp, tszMirVerSecondUp;

+		int iMirVerFirstUpLen, iMirVerSecondUpLen;

+

+		iMirVerFirstUpLen = MultiByteToWideChar(g_LPCodePage, 0, szMirVerFirst, -1, NULL, 0);

+		iMirVerSecondUpLen = MultiByteToWideChar(g_LPCodePage, 0, szMirVerSecond, -1, NULL, 0);

+

+		tszMirVerFirstUp = (LPTSTR)mir_alloc(iMirVerFirstUpLen * sizeof(TCHAR));

+		tszMirVerSecondUp = (LPTSTR)mir_alloc(iMirVerSecondUpLen * sizeof(TCHAR));

+

+		MultiByteToWideChar(g_LPCodePage, 0, szMirVerFirst, -1, tszMirVerFirstUp, iMirVerFirstUpLen);

+		MultiByteToWideChar(g_LPCodePage, 0, szMirVerSecond, -1, tszMirVerSecondUp, iMirVerSecondUpLen);

+

+		_tcsupr_s(tszMirVerFirstUp, iMirVerFirstUpLen);

+		_tcsupr_s(tszMirVerSecondUp, iMirVerSecondUpLen);

+

+		if (_tcscmp(tszMirVerFirstUp, _T("?")) == 0)

+			firstIndex = UNKNOWN_MASK_NUMBER;

+		else

+			while(firstIndex < DEFAULT_KN_FP_MASK_COUNT) {

+				if (WildCompare(tszMirVerFirstUp, def_kn_fp_mask[firstIndex].szMaskUpper))

+					break;

+				firstIndex++;

+			}

+

+		if (_tcscmp(tszMirVerSecondUp, _T("?")) == 0)

+			secondIndex = UNKNOWN_MASK_NUMBER;

+		else

+			while(secondIndex < DEFAULT_KN_FP_MASK_COUNT) {

+				if (WildCompare(tszMirVerSecondUp, def_kn_fp_mask[secondIndex].szMaskUpper))

+					break;

+	 			secondIndex++;

+			}

+

+		mir_free(tszMirVerFirstUp);

+		mir_free(tszMirVerSecondUp);

+

+		if (firstIndex == secondIndex && firstIndex < DEFAULT_KN_FP_MASK_COUNT)

+		{

+			int iClientDescriptionLen = WideCharToMultiByte(g_LPCodePage, 0, def_kn_fp_mask[firstIndex].szClientDescription, -1, NULL, 0, NULL, NULL);

+			if (iClientDescriptionLen > 0)

+				g_szClientDescription = (LPSTR)mir_realloc(g_szClientDescription, iClientDescriptionLen * sizeof(CHAR));

+			else

+				return (INT_PTR)NULL;

+

+			WideCharToMultiByte(g_LPCodePage, 0, def_kn_fp_mask[firstIndex].szClientDescription, -1, g_szClientDescription, iClientDescriptionLen, NULL, NULL);

+			return (INT_PTR)g_szClientDescription;

+

+		}

+	}

+	return (INT_PTR)NULL;

+}

+

+/*

+*	ServiceGetClientIconW

+*	MS_FP_GETCLIENTICONW service implementation.

+*	wParam - LPWSTR MirVer value to get client for.

+*	lParam - int noCopy - if wParam is equal to "1"	will return icon handler without copiing icon.

+*	ICON IS ALWAYS COPIED!!!

+*/

+

+INT_PTR ServiceGetClientIconW(WPARAM wParam, LPARAM lParam)

+{

+	LPWSTR wszMirVer = (LPWSTR)wParam;			// MirVer value to get client for.

+	if (wszMirVer == NULL)

+		return 0;

+

+	short base, overlay, overlay2, overlay3;

+	GetIconsIndexesW(wszMirVer, &base, &overlay, &overlay2, &overlay3);

+

+	HICON hIcon = NULL;			// returned HICON

+	if (base != -1)

+		hIcon = CreateIconFromIndexes(base, overlay, overlay2, overlay3);

+

+	return (INT_PTR)hIcon;

+}

+

+/*

+ *	 ServiceSameClientW

+ *	 MS_FP_SAMECLIENTSW service implementation.

+ *	 wParam - LPWSTR first MirVer value

+ *	 lParam - LPWSTR second MirVer value

+ *	 return pointer to char string - client desription (do not destroy) if clients are same

+ */

+INT_PTR ServiceSameClientsW(WPARAM wParam, LPARAM lParam)

+{

+	LPWSTR wszMirVerFirst = (LPWSTR)wParam;	// MirVer value to get client for.

+	LPWSTR wszMirVerSecond = (LPWSTR)lParam;	// MirVer value to get client for.

+	int firstIndex, secondIndex;

+	BOOL Result = FALSE;

+

+	firstIndex = secondIndex = 0;

+	if (!wszMirVerFirst || !wszMirVerSecond) return (INT_PTR)NULL;	//one of its is not null

+

+	{

+		LPWSTR wszMirVerFirstUp, wszMirVerSecondUp;

+		size_t iMirVerFirstUpLen, iMirVerSecondUpLen;

+

+		iMirVerFirstUpLen = wcslen(wszMirVerFirst) + 1;

+		iMirVerSecondUpLen = wcslen(wszMirVerSecond) + 1;

+

+		wszMirVerFirstUp = (LPWSTR)mir_alloc(iMirVerFirstUpLen * sizeof(WCHAR));

+		wszMirVerSecondUp = (LPWSTR)mir_alloc(iMirVerSecondUpLen * sizeof(WCHAR));

+

+		wcscpy_s(wszMirVerFirstUp, iMirVerFirstUpLen, wszMirVerFirst);

+		wcscpy_s(wszMirVerSecondUp, iMirVerSecondUpLen, wszMirVerSecond);

+

+		_wcsupr_s(wszMirVerFirstUp, iMirVerFirstUpLen);

+		_wcsupr_s(wszMirVerSecondUp, iMirVerSecondUpLen);

+

+		if (wcscmp(wszMirVerFirstUp, L"?") == 0)

+			firstIndex = UNKNOWN_MASK_NUMBER;

+		else

+			while(firstIndex < DEFAULT_KN_FP_MASK_COUNT) {

+				if (WildCompareW(wszMirVerFirstUp, def_kn_fp_mask[firstIndex].szMaskUpper))

+					break;

+				firstIndex++;

+			}

+

+		if (wcscmp(wszMirVerSecondUp, L"?") == 0)

+			secondIndex = UNKNOWN_MASK_NUMBER;

+		else

+			while(secondIndex < DEFAULT_KN_FP_MASK_COUNT) {

+				if (WildCompareW(wszMirVerSecondUp, def_kn_fp_mask[secondIndex].szMaskUpper))

+					break;

+	 			secondIndex++;

+			}

+

+		mir_free(wszMirVerFirstUp);

+		mir_free(wszMirVerSecondUp);

+

+		if (firstIndex == secondIndex && firstIndex < DEFAULT_KN_FP_MASK_COUNT)

+		{

+			return (INT_PTR)def_kn_fp_mask[firstIndex].szClientDescription;

+		}

+	}

+	return (INT_PTR)NULL;

+}

+

+/******************************************************************************

+ *	Futher routines is for creating joined 'overlay' icons.

+ ******************************************************************************/

+

+ /*

+ *	CreateBitmap32 - Create DIB 32 bitmap with sizes cx*cy

+ */

+

+HBITMAP __inline CreateBitmap32(int cx, int cy)

+{

+	return CreateBitmap32Point(cx, cy, NULL);

+}

+

+ /*

+ *	CreateBitmap32 - Create DIB 32 bitmap with sizes cx*cy and put reference

+ *				to new bitmap pixel image memory area to void ** bits

+ */

+HBITMAP FASTCALL CreateBitmap32Point(int cx, int cy, LPVOID* bits)

+{

+	BITMAPINFO bmpi = { 0 };

+	LPVOID ptPixels = NULL;

+	HBITMAP DirectBitmap;

+

+	if (cx < 0 || cy < 0) return NULL;

+

+	bmpi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

+	bmpi.bmiHeader.biWidth = cx;

+	bmpi.bmiHeader.biHeight = cy;

+	bmpi.bmiHeader.biPlanes = 1;

+//	bmpi.bmiHeader.biCompression = BI_RGB;

+	bmpi.bmiHeader.biBitCount = 32;

+

+	DirectBitmap = CreateDIBSection(NULL,

+					&bmpi,

+					DIB_RGB_COLORS,

+					&ptPixels,

+					NULL, 0);

+ 	GdiFlush();

+	if (ptPixels) memset(ptPixels, 0, cx * cy * 4);

+	if (bits != NULL) *bits = ptPixels;

+

+	return DirectBitmap;

+}

+

+/*

+*	 checkHasAlfa - checks if image has at least one BYTE in alpha channel

+*				 that is not a 0. (is image real 32 bit or just 24 bit)

+*/

+BOOL FASTCALL checkHasAlfa(LPBYTE from, int width, int height)

+{

+	LPDWORD pt = (LPDWORD)from;

+	LPDWORD lim = pt + width * height;

+	while(pt < lim)

+	{

+		if (*pt & 0xFF000000)

+			return TRUE;

+		pt++;

+	}

+

+	return FALSE;

+}

+

+/*

+*	 checkMaskUsed - checks if mask image has at least one that is not a 0.

+*	 Not sure is it required or not

+*/

+BOOL FASTCALL checkMaskUsed(LPBYTE from)

+{

+	int i;

+	for (i=0; i < 16 * 16 / 8; i++)

+	{

+		if (from[i] != 0) return TRUE;

+	}

+	return FALSE;

+}

+

+/*

+*	 GetMaskBit - return value of apropriate mask bit in line at x position

+*/

+BOOL __inline GetMaskBit(LPBYTE line, int x)

+{

+	return ((*(line + (x >> 3))) & (0x01 << (7 - (x & 0x07)))) != 0;

+}

+

+/*

+*	blend	- alpha blend ARGB values of 2 pixels. X1 - underlaying,

+*	 X2 - overlaying points.

+*/

+DWORD FASTCALL blend(DWORD X1,DWORD X2)

+{

+	RGBA* q1 = (RGBA*)&X1;

+	RGBA* q2 = (RGBA*)&X2;

+	BYTE a_1 = ~q1->a;

+	BYTE a_2 = ~q2->a;

+	WORD am = q1->a * a_2;

+

+	WORD ar = q1->a + ((a_1 * q2->a) / 255);

+	// if a2 more than 0 than result should be more

+	// or equal (if a1==0) to a2, else in combination

+	// with mask we can get here black points

+

+	ar = (q2->a > ar) ? q2->a : ar;

+

+	if (ar == 0) return 0;

+

+	{

+		WORD arm = ar * 255;

+		WORD rr = ((q1->r * am + q2->r * q2->a * 255)) / arm;

+		WORD gr = ((q1->g * am + q2->g * q2->a * 255)) / arm;

+		WORD br = ((q1->b * am + q2->b * q2->a * 255)) / arm;

+		return (ar << 24) | (rr << 16) | (gr << 8) | br;

+	}

+}

+

+/*

+*	CreateJoinedIcon	- creates new icon by drawing hTop over hBottom.

+*/

+HICON FASTCALL CreateJoinedIcon(HICON hBottom, HICON hTop)

+{

+	BOOL drawn = FALSE;

+	HDC tempDC, tempDC2, tempDC3;

+	HICON res = NULL;

+	HBITMAP oImage,nImage;

+	HBITMAP nMask, hbm, obmp, obmp2;

+	LPBYTE ptPixels = NULL;

+	ICONINFO iNew = { 0 };

+	BYTE p[32] = { 0 };

+

+	tempDC = CreateCompatibleDC(NULL);

+	nImage = CreateBitmap32Point(16, 16, (LPVOID*)&ptPixels);

+	oImage = (HBITMAP)SelectObject(tempDC, nImage);

+

+//	if (ptPixels) memset(ptPixels, 0, 16 * 16 * 4);

+

+	if (IsWinVerXPPlus())

+	{

+		ICONINFO iciBottom = { 0 };

+		ICONINFO iciTop = { 0 };

+

+		BITMAP bmp_top = { 0 };

+		BITMAP bmp_top_mask = { 0 };

+

+		BITMAP bmp_bottom = { 0 };

+		BITMAP bmp_bottom_mask = { 0 };

+

+		GetIconInfo(hBottom, &iciBottom);

+		GetObject(iciBottom.hbmColor, sizeof(BITMAP), &bmp_bottom);

+		GetObject(iciBottom.hbmMask, sizeof(BITMAP), &bmp_bottom_mask);

+

+		GetIconInfo(hTop, &iciTop);

+		GetObject(iciTop.hbmColor, sizeof(BITMAP), &bmp_top);

+		GetObject(iciTop.hbmMask, sizeof(BITMAP), &bmp_top_mask);

+

+		if (bmp_bottom.bmBitsPixel == 32 && bmp_top.bmBitsPixel == 32)

+		{

+			LPBYTE BottomBuffer, TopBuffer, BottomMaskBuffer, TopMaskBuffer;

+			LPBYTE bb, tb, bmb, tmb;

+			LPBYTE db = ptPixels;

+			int vstep_d = 16 * 4;

+			int vstep_b = bmp_bottom.bmWidthBytes;

+			int vstep_t = bmp_top.bmWidthBytes;

+			int vstep_bm = bmp_bottom_mask.bmWidthBytes;

+			int vstep_tm = bmp_top_mask.bmWidthBytes;

+

+			if (bmp_bottom.bmBits)

+				bb = BottomBuffer = (LPBYTE)bmp_bottom.bmBits;

+			else

+			{

+				BottomBuffer = (LPBYTE)_alloca(bmp_bottom.bmHeight * bmp_bottom.bmWidthBytes);

+				GetBitmapBits(iciBottom.hbmColor, bmp_bottom.bmHeight * bmp_bottom.bmWidthBytes, BottomBuffer);

+				bb = BottomBuffer + vstep_b * (bmp_bottom.bmHeight - 1);

+				vstep_b = -vstep_b;

+			}

+			if (bmp_top.bmBits)

+				tb = TopBuffer = (LPBYTE)bmp_top.bmBits;

+			else

+			{

+				TopBuffer = (LPBYTE)_alloca(bmp_top.bmHeight * bmp_top.bmWidthBytes);

+				GetBitmapBits(iciTop.hbmColor, bmp_top.bmHeight * bmp_top.bmWidthBytes, TopBuffer);

+				tb = TopBuffer + vstep_t * (bmp_top.bmHeight - 1);

+				vstep_t = -vstep_t;

+			}

+			if (bmp_bottom_mask.bmBits)

+				bmb = BottomMaskBuffer = (LPBYTE)bmp_bottom_mask.bmBits;

+			else

+			{

+				BottomMaskBuffer = (LPBYTE)_alloca(bmp_bottom_mask.bmHeight * bmp_bottom_mask.bmWidthBytes);

+				GetBitmapBits(iciBottom.hbmMask, bmp_bottom_mask.bmHeight * bmp_bottom_mask.bmWidthBytes, BottomMaskBuffer);

+				bmb = BottomMaskBuffer + vstep_bm * (bmp_bottom_mask.bmHeight - 1);

+				vstep_bm = -vstep_bm;

+			}

+			if (bmp_top_mask.bmBits)

+				tmb = TopMaskBuffer = (LPBYTE)bmp_top_mask.bmBits;

+			else

+			{

+				TopMaskBuffer = (LPBYTE)_alloca(bmp_top_mask.bmHeight * bmp_top_mask.bmWidthBytes);

+				GetBitmapBits(iciTop.hbmMask, bmp_top_mask.bmHeight * bmp_top_mask.bmWidthBytes, TopMaskBuffer);

+				tmb = TopMaskBuffer + vstep_tm * (bmp_top_mask.bmHeight - 1);

+				vstep_tm = -vstep_tm;

+			}

+			{

+				int x; int y;

+				BOOL topHasAlpha = checkHasAlfa(TopBuffer, bmp_top.bmWidth, bmp_top.bmHeight);

+				BOOL bottomHasAlpha = checkHasAlfa(BottomBuffer, bmp_bottom.bmWidth, bmp_bottom.bmHeight);

+				BOOL topMaskUsed = !topHasAlpha && checkMaskUsed(TopMaskBuffer);

+				BOOL bottomMaskUsed = !bottomHasAlpha && checkMaskUsed(BottomMaskBuffer);

+

+				for(y = 0; y < 16; y++)

+				{

+					for(x = 0; x < 16; x++)

+					{

+						DWORD bottom_d = ((LPDWORD)bb)[x];

+						DWORD top_d = ((LPDWORD)tb)[x];

+

+						if (topMaskUsed)

+						{

+							if (GetMaskBit(tmb, x))

+								top_d &= 0x00FFFFFF;

+							else

+								top_d |= 0xFF000000;

+						}

+						else if (!topHasAlpha)

+							top_d |= 0xFF000000;

+

+						if (bottomMaskUsed)

+						{

+							if (GetMaskBit(bmb, x))

+								bottom_d &= 0x00FFFFFF;

+							else

+								bottom_d |= 0xFF000000;

+						}

+						else if (!bottomHasAlpha)

+							bottom_d |= 0xFF000000;

+

+						((LPDWORD)db)[x] = blend(bottom_d, top_d);

+					}

+					bb += vstep_b;

+					tb += vstep_t;

+					bmb += vstep_bm;

+					tmb += vstep_tm;

+					db += vstep_d;

+				}

+			}

+

+			drawn = TRUE;

+		}

+

+		DeleteObject(iciBottom.hbmColor);

+		DeleteObject(iciTop.hbmColor);

+		DeleteObject(iciBottom.hbmMask);

+		DeleteObject(iciTop.hbmMask);

+	}

+

+	if (!drawn) {

+		DrawIconEx(tempDC, 0, 0, hBottom, 16, 16, 0, NULL, DI_NORMAL);

+		DrawIconEx(tempDC, 0, 0, hTop, 16, 16, 0, NULL, DI_NORMAL);

+	}

+

+	nMask = CreateBitmap(16, 16, 1, 1, p);

+	tempDC2 = CreateCompatibleDC(NULL);

+	tempDC3 = CreateCompatibleDC(NULL);

+	hbm = CreateCompatibleBitmap(tempDC3, 16, 16);

+	obmp = (HBITMAP)SelectObject(tempDC2, nMask);

+	obmp2 = (HBITMAP)SelectObject(tempDC3, hbm);

+	DrawIconEx(tempDC2, 0, 0, hBottom, 16, 16, 0, NULL, DI_MASK);

+	DrawIconEx(tempDC3, 0, 0, hTop, 16, 16, 0, NULL, DI_MASK);

+	BitBlt(tempDC2, 0, 0, 16, 16, tempDC3, 0, 0, SRCAND);

+

+	GdiFlush();

+

+	SelectObject(tempDC2, obmp);

+	DeleteDC(tempDC2);

+

+	SelectObject(tempDC3, obmp2);

+	DeleteDC(tempDC3);

+

+	SelectObject(tempDC, oImage);

+	DeleteDC(tempDC);

+

+	DeleteObject(hbm);

+

+	iNew.fIcon = TRUE;

+	iNew.hbmColor = nImage;

+	iNew.hbmMask = nMask;

+	res = CreateIconIndirect(&iNew);

+

+	DeleteObject(nImage);

+	DeleteObject(nMask);

+

+	return res;

+}

+

+HANDLE FASTCALL GetIconIndexFromFI(LPTSTR szMirVer)

+{

+	short base, overlay, overlay2, overlay3;

+	GetIconsIndexes(szMirVer, &base, &overlay, &overlay2, &overlay3);

+	if (base == -1 || nFICount == 0xFFFF)

+		return INVALID_HANDLE_VALUE;

+

+	// MAX: 1024 + 256 + 128 + 128

+	DWORD val = (base << 22) | ((overlay & 0xFF) << 14) | ((overlay2 & 0x7F) << 7) | (overlay3 & 0x7F);

+

+	int i;

+	HANDLE hFoundImage = INVALID_HANDLE_VALUE;

+	for (i=0; i < nFICount; i++) {

+		if (fiList[i].dwArray == val) {

+			hFoundImage = fiList[i].hRegisteredImage;

+			break;

+		}

+	}

+

+	if (hFoundImage == INVALID_HANDLE_VALUE && i == nFICount) { //not found - then add

+		HICON hIcon = CreateIconFromIndexes(base, overlay, overlay2, overlay3);

+

+		fiList = (FOUNDINFO*)mir_realloc(fiList, sizeof(FOUNDINFO) * (nFICount + 1));

+		fiList[nFICount].dwArray = val;

+

+		if (hIcon != NULL) {

+			hFoundImage = (HANDLE)CallService(MS_CLIST_EXTRA_ADD_ICON, (WPARAM)hIcon, 0);

+			fiList[nFICount].hRegisteredImage = hFoundImage;

+			DestroyIcon(hIcon);

+		}

+		else fiList[nFICount].hRegisteredImage = INVALID_HANDLE_VALUE;

+

+		nFICount++;

+	}

+

+	return hFoundImage;

+}

+

+VOID ClearFI()

+{

+	if (fiList != NULL)

+		mir_free(fiList);

+	fiList = NULL;

+	nFICount = 0;

+}