Clist_mw & Clist_modern renamed

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

1 files changed, 793 insertions, 0 deletions

diff --git a/plugins/Clist_modern/modern_skinselector.cpp b/plugins/Clist_modern/modern_skinselector.cpp
new file mode 100644
index 0000000000..2540790d53
--- /dev/null
+++ b/plugins/Clist_modern/modern_skinselector.cpp
@@ -0,0 +1,793 @@
+/*

+

+Miranda IM: the free IM client for Microsoft* Windows*

+

+Copyright 2000-2008 Miranda ICQ/IM project,

+all portions of this codebase are copyrighted to the people

+listed in contributors.txt.

+

+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.

+*/

+

+///// structures and services to manage modern skin objects (mask mechanism)

+

+//#include "windows.h"

+#include "hdr/modern_commonheaders.h"

+#include "hdr/modern_skinselector.h"

+#include "hdr/modern_skinengine.h"

+#include "m_api/m_skin_eng.h"

+#include "m_api/m_skinbutton.h"

+#include "hdr/modern_commonprototypes.h"

+LISTMODERNMASK * MainModernMaskList=NULL;

+

+

+/// IMPLEMENTATIONS

+char * ModernMaskToString(MODERNMASK * mm, char * buf, UINT bufsize)

+{

+	int i=0;

+	for (i=0; i<(int)mm->dwParamCnt;i++)

+	{

+		if (mm->pl_Params[i].bMaskParamFlag)

+		{

+			if (i>0) _snprintf(buf,bufsize,"%s%%",buf);

+			if (mm->pl_Params[i].bMaskParamFlag &MPF_DIFF)

+				_snprintf(buf,bufsize,"%s=%s",mm->pl_Params[i].szName,mm->pl_Params[i].szValue);

+			else

+				_snprintf(buf,bufsize,"%s^%s",mm->pl_Params[i].szName,mm->pl_Params[i].szValue);

+		}

+		else break;

+	}

+	return buf;

+}

+int SkinSelector_DeleteMask(MODERNMASK * mm)

+{

+	int i;

+	if (!mm->pl_Params) return 0;

+	for (i=0;i<(int)mm->dwParamCnt;i++)

+	{

+		if (mm->pl_Params[i].szName) free(mm->pl_Params[i].szName);

+		if (mm->pl_Params[i].szValue) free(mm->pl_Params[i].szValue);

+	}

+	free(mm->pl_Params);

+	return 1;

+}

+

+#define _qtoupper(_c) (((_c)>='a' && (_c)<='z')?((_c)-('a'+'A')):(_c))

+BOOL wildcmpi(TCHAR* name, TCHAR* mask)

+{

+	TCHAR* last='\0';

+	for (;; mask++, name++)

+	{

+		if (*mask != '?' && _qtoupper(*mask) != _qtoupper(*name)) break;

+		if (*name == '\0') return ((BOOL)!*mask);

+	}

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

+	for (;; mask++, name++)

+	{

+		while(*mask == '*')

+		{

+			last = mask++;

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

+		}

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

+		if (*mask != '?' && _qtoupper(*mask)  != _qtoupper(*name) ) name -= (size_t)(mask - last) - 1, mask = last;

+	}

+}

+

+BOOL wildcmpi(char * name, char * mask)

+{

+	char * last='\0';

+	for (;; mask++, name++)

+	{

+		if (*mask != '?' && _qtoupper(*mask) != _qtoupper(*name)) break;

+		if (*name == '\0') return ((BOOL)!*mask);

+	}

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

+	for (;; mask++, name++)

+	{

+		while(*mask == '*')

+		{

+			last = mask++;

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

+		}

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

+		if (*mask != '?' && _qtoupper(*mask)  != _qtoupper(*name) ) name -= (size_t)(mask - last) - 1, mask = last;

+	}

+}

+

+BOOL __inline wildcmp(const char * name, const char * mask, BYTE option)

+{

+	const char * last='\0';

+	for (;; mask++, name++)

+	{

+		if (*mask != '?' && *mask != *name) break;

+		if (*name == '\0') return ((BOOL)!*mask);

+	}

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

+	for (;; mask++, name++)

+	{

+		while(*mask == '*')

+		{

+			last = mask++;

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

+		}

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

+		if (*mask != '?' && *mask != *name) name -= (size_t)(mask - last) - 1, mask = last;

+	}

+}

+

+BOOL MatchMask(char * name, char * mask)

+{

+	if (!mask || !name) return mask==name;

+	if (*mask!='|') return wildcmpi(name,mask);

+	{

+		int s=1,e=1;

+		char * temp;

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

+		{

+			s=e;

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

+			temp=(char*)malloc(e-s+1);

+			memcpy(temp,mask+s,e-s);

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

+			if (wildcmpi(name,temp))

+			{

+				free(temp);

+				return TRUE;

+			}

+			free(temp);

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

+			else return FALSE;

+		}

+		return FALSE;

+	}

+	return FALSE;

+}

+#if __GNUC__

+#define NOINLINEASM

+#endif

+

+DWORD mod_CalcHash(const char *szStr)

+{

+#if defined _M_IX86 && !defined _NUMEGA_BC_FINALCHECK && !defined NOINLINEASM

+    __asm {		   //this breaks if szStr is empty

+        xor  edx,edx

+            xor  eax,eax

+            mov  esi,szStr

+            mov  al,[esi]

+            xor  cl,cl

+lph_top:	 //only 4 of 9 instructions in here don't use AL, so optimal pipe use is impossible

+            xor  edx,eax

+                inc  esi

+                xor  eax,eax

+                and  cl,31

+                mov  al,[esi]

+                add  cl,5

+                    test al,al

+                    rol  eax,cl		 //rol is u-pipe only, but pairable

+                    //rol doesn't touch z-flag

+                    jnz  lph_top  //5 clock tick loop. not bad.

+

+                    xor  eax,edx

+    }

+#else

+    DWORD hash=0;

+    int i;

+    int shift=0;

+    for(i=0;szStr[i];i++) {

+        hash^=szStr[i]<<shift;

+        if(shift>24) hash^=(szStr[i]>>(32-shift))&0x7F;

+        shift=(shift+5)&0x1F;

+    }

+    return hash;

+#endif

+}

+

+/*

+DWORD mod_CalcHash(const char * a)

+{

+    DWORD Val=0;

+    BYTE N;

+    DWORD k=mir_strlen(a);

+    if (k<23) N=(BYTE)k; else N=23;

+    while (N>0)

+    {

+        Val=Val<<1;

+        Val^=((DWORD)*a++)-31;

+        N--;

+    }

+    return Val;

+}

+*/

+int AddModernMaskToList(MODERNMASK * mm,  LISTMODERNMASK * mmTemplateList)

+{

+	if (!mmTemplateList || !mm) return -1;

+	mmTemplateList->pl_Masks=(MODERNMASK *)mir_realloc(mmTemplateList->pl_Masks,sizeof(MODERNMASK)*(mmTemplateList->dwMaskCnt+1));

+	memmove(&(mmTemplateList->pl_Masks[mmTemplateList->dwMaskCnt]),mm,sizeof(MODERNMASK));

+	mmTemplateList->dwMaskCnt++;

+	return mmTemplateList->dwMaskCnt-1;

+}

+

+int ClearMaskList(LISTMODERNMASK * mmTemplateList)

+{

+	int i;

+	if (!mmTemplateList) return -1;

+	if (!mmTemplateList->pl_Masks) return -1;

+	for(i=0; i<(int)mmTemplateList->dwMaskCnt; i++)

+		SkinSelector_DeleteMask(&(mmTemplateList->pl_Masks[i]));

+	mir_free_and_nill(mmTemplateList->pl_Masks);

+	mmTemplateList->pl_Masks=NULL;

+	mmTemplateList->dwMaskCnt=0;

+	return 0;

+}

+int DeleteMaskByItID(DWORD mID,LISTMODERNMASK * mmTemplateList)

+{

+	if (!mmTemplateList) return -1;

+	if (mID<0|| mID>=mmTemplateList->dwMaskCnt) return -1;

+	if (mmTemplateList->dwMaskCnt==1)

+	{

+		SkinSelector_DeleteMask(&(mmTemplateList->pl_Masks[0]));

+		mir_free_and_nill(mmTemplateList->pl_Masks);

+		mmTemplateList->pl_Masks=NULL;

+		mmTemplateList->dwMaskCnt;

+	}

+	else

+	{

+		MODERNMASK * newAlocation;

+		DWORD i;

+		SkinSelector_DeleteMask(&(mmTemplateList->pl_Masks[mID]));

+		newAlocation=(MODERNMASK *)mir_alloc(sizeof(MODERNMASK)*mmTemplateList->dwMaskCnt-1);

+		memmove(newAlocation,mmTemplateList->pl_Masks,sizeof(MODERNMASK)*(mID+1));

+		for (i=mID; i<mmTemplateList->dwMaskCnt-1; i++)

+		{

+			newAlocation[i]=mmTemplateList->pl_Masks[i+1];

+			newAlocation[i].dwMaskId=i;

+		}

+		mir_free_and_nill(mmTemplateList->pl_Masks);

+		mmTemplateList->pl_Masks=newAlocation;

+		mmTemplateList->dwMaskCnt--;

+	}

+	return mmTemplateList->dwMaskCnt;

+}

+

+

+int ExchangeMasksByID(DWORD mID1, DWORD mID2, LISTMODERNMASK * mmTemplateList)

+{

+	if (!mmTemplateList) return 0;

+	if (mID1<0|| mID1>=mmTemplateList->dwMaskCnt) return 0;

+	if (mID2<0|| mID2>=mmTemplateList->dwMaskCnt) return 0;

+	if (mID1==mID2) return 0;

+	{

+		MODERNMASK mm;

+		mm=mmTemplateList->pl_Masks[mID1];

+		mmTemplateList->pl_Masks[mID1]=mmTemplateList->pl_Masks[mID2];

+		mmTemplateList->pl_Masks[mID2]=mm;

+	}

+	return 1;

+}

+int SortMaskList(LISTMODERNMASK * mmList)

+{

+	DWORD pos=1;

+	if (mmList->dwMaskCnt<2) return 0;

+	do {

+		if(mmList->pl_Masks[pos].dwMaskId<mmList->pl_Masks[pos-1].dwMaskId)

+		{

+			ExchangeMasksByID(pos, pos-1, mmList);

+			pos--;

+			if (pos<1)

+				pos=1;

+		}

+		else

+			pos++;

+	} while(pos<mmList->dwMaskCnt);

+

+	return 1;

+}

+

+enum 

+{ 

+	EXCEPTION_EQUAL, 

+	EXCEPTION_NOT_EQUAL = 1, 

+	EXCEPTION_WILD = 2,

+};

+static BOOL _GetParamValue( char * szText, unsigned int& start, unsigned int length, char* &param, unsigned int& paramlen, char* &value, unsigned int& valuelen, int& except )

+{

+	char * curChar = szText + start;

+	char * lastChar = szText + length;	

+

+	enum { STATE_PARAM, STATE_VALUE };

+	int state = STATE_PARAM;

+	if ( start >= length ) return FALSE;

+

+	paramlen = 0;

+	valuelen = 0;

+	value = NULL;

+	param = NULL;

+

+	except = EXCEPTION_EQUAL;

+	param = curChar;

+

+

+	BOOL exitLoop=false;

+	while ( !exitLoop )

+	{

+		switch ( *curChar )

+		{

+

+		case '^':

+			if ( state == STATE_VALUE ) break;

+			except |= EXCEPTION_NOT_EQUAL;

+			exitLoop = TRUE;

+			//fall trough

+		case '=': 

+			if ( state == STATE_VALUE ) break;

+			//search value end

+			paramlen = curChar - param;

+			exitLoop = TRUE;

+			break;

+

+		case ',':

+		default: 

+			if ( *curChar!=',' && curChar < lastChar ) break;

+			if ( state == STATE_PARAM )

+			{

+				// no parameter name only value

+				value = param;

+				param = NULL;

+				paramlen = 0;

+				state = STATE_VALUE; 

+			}

+			exitLoop = TRUE;

+			break;

+		case '*': case '?':

+			if (state == STATE_PARAM ) break;

+			except|=EXCEPTION_WILD;

+			break;

+		}

+		if ( exitLoop)

+		{

+			if (state == STATE_PARAM )

+			{

+				paramlen = curChar - param;

+				state = STATE_VALUE;

+				curChar++; //skip Sign

+				value = curChar;

+				exitLoop = FALSE;

+			}

+			else if ( state == STATE_VALUE )

+			{

+				valuelen = curChar - value;

+			}

+		}

+		else

+		{

+			curChar++;

+		}

+	}

+

+

+	start = curChar - szText + 1;

+	// skip spaces

+	if ( value && valuelen )

+	{

+		while ( *value == ' ' || *value == '\t' ) 

+		{ 

+			value++; 

+			valuelen--; 

+		}

+		while ( *( value + valuelen - 1) == ' ' || *( value + valuelen -1 ) == '\t' ) 

+			valuelen--;

+	}

+

+	if ( param && paramlen )

+	{

+		while (*param == ' ' || *param == '\t' ) 

+		{

+			param++; 

+			paramlen--; 

+		}

+		while (*(param+paramlen-1) == ' ' || *(param+paramlen-1) == '\t' ) 

+			paramlen--;

+	}

+

+	return ( value || param );

+}

+

+int ParseToModernMask(MODERNMASK * mm, char * szText)

+{

+	if (!mm || !szText) return -1;

+

+	unsigned int textLen=mir_strlen(szText);

+	BYTE curParam=0;

+

+	MASKPARAM param={0};

+

+	unsigned int startPos=0;

+	char * pszParam;

+	char * pszValue;

+	unsigned int paramlen;

+	unsigned int valuelen;

+	int except;

+

+	while ( _GetParamValue( szText, startPos, textLen, pszParam, paramlen, pszValue, valuelen, except) )

+	{        

+		if ( except & EXCEPTION_NOT_EQUAL ) 

+			param.bMaskParamFlag = MPF_NOT_EQUAL;

+		else

+			param.bMaskParamFlag = MPF_EQUAL;

+

+		//Get param name

+		if ( pszParam && paramlen )

+		{

+			param.szName=strdupn( pszParam, paramlen);

+			param.dwId=mod_CalcHash( param.szName );

+		}

+		else //ParamName='Module'

+		{

+			param.szName=_strdup( "Module");

+			param.dwId=mod_CalcHash( param.szName );                    

+		}

+

+

+		param.szValue= strdupn( pszValue, valuelen );

+

+		if ( !(except & EXCEPTION_WILD) )

+		{

+			param.dwValueHash = mod_CalcHash( param.szValue );

+			param.bMaskParamFlag |= MPF_HASHED;

+		}

+		if (curParam>=mm->dwParamCnt)

+		{

+			mm->pl_Params=(MASKPARAM*)realloc(mm->pl_Params,(mm->dwParamCnt+1)*sizeof(MASKPARAM));

+			mm->dwParamCnt++;

+		}

+		memmove(&(mm->pl_Params[curParam]),&param,sizeof(MASKPARAM));

+		curParam++;

+		memset(&param,0,sizeof(MASKPARAM));

+	}

+	return 0;

+};

+

+BOOL CompareModernMask(MODERNMASK * mmValue,MODERNMASK * mmTemplate)

+{

+	//TODO

+	BOOL res=TRUE;

+	BOOL exit=FALSE;

+	BYTE pVal=0, pTemp=0;

+	while (pTemp<mmTemplate->dwParamCnt && pVal<mmValue->dwParamCnt && !exit)

+	{

+		// find pTemp parameter in mValue

+		DWORD vh, ph;

+		BOOL finded=0;

+		MASKPARAM p=mmTemplate->pl_Params[pTemp];

+		ph=p.dwId;

+		vh=p.dwValueHash;

+		pVal=0;

+		if ( p.bMaskParamFlag& MPF_HASHED )  //compare by hash

+			while (pVal<mmValue->dwParamCnt && mmValue->pl_Params[pVal].bMaskParamFlag !=0)

+			{

+				if (mmValue->pl_Params[pVal].dwId==ph)

+				{

+					if (mmValue->pl_Params[pVal].dwValueHash==vh){finded=1; break;}

+					else {finded=0; break;}

+				}

+				pVal++;

+			}

+		else

+			while (mmValue->pl_Params[pVal].bMaskParamFlag!=0)

+			{

+				if (mmValue->pl_Params[pVal].dwId==ph)

+				{

+					if (wildcmp(mmValue->pl_Params[pVal].szValue,p.szValue,0)){finded=1; break;}

+					else {finded=0; break;}

+				}

+				pVal++;

+			}

+			if (!((finded && !(p.bMaskParamFlag&MPF_DIFF)) || (!finded && (p.bMaskParamFlag&MPF_DIFF))))

+			{res=FALSE; break;}

+			pTemp++;

+	}

+	return res;

+};

+

+BOOL CompareStrWithModernMask(char * szValue,MODERNMASK * mmTemplate)

+{

+	MODERNMASK mmValue={0};

+	int res;

+	if (!ParseToModernMask(&mmValue, szValue))

+	{

+		res=CompareModernMask(&mmValue,mmTemplate);

+		SkinSelector_DeleteMask(&mmValue);

+		return res;

+	}

+	else return 0;

+};

+

+//AddingMask

+int AddStrModernMaskToList(DWORD maskID, char * szStr, char * objectName,  LISTMODERNMASK * mmTemplateList, void * pObjectList)

+{

+	if (!szStr || !mmTemplateList) return -1;

+

+	MODERNMASK mm={0};

+	if (ParseToModernMask(&mm,szStr)) return -1;

+

+	mm.bObjectFound=FALSE;

+	mm.szObjectName=mir_strdup(objectName);

+	//mm.pObject=(void*) ske_FindObjectByName(objectName, OT_ANY, (SKINOBJECTSLIST*) pObjectList);

+	mm.dwMaskId=maskID;

+	return AddModernMaskToList(&mm,mmTemplateList);

+}

+

+//Searching

+MODERNMASK *  FindMaskByStr(char * szValue,LISTMODERNMASK * mmTemplateList)

+{

+	//TODO

+	return NULL;

+}

+

+SKINOBJECTDESCRIPTOR *  skin_FindObjectByMask (MODERNMASK * mm,LISTMODERNMASK * mmTemplateList)

+{

+	SKINOBJECTDESCRIPTOR * res=NULL;

+	DWORD i=0;

+	while (i<mmTemplateList->dwMaskCnt)

+	{

+		if (CompareModernMask(mm,&(mmTemplateList->pl_Masks[i])))

+		{

+			res=(SKINOBJECTDESCRIPTOR*) mmTemplateList->pl_Masks[i].pObject;

+			return res;

+		}

+		i++;

+	}

+	return res;

+}

+

+SKINOBJECTDESCRIPTOR *  skin_FindObjectByRequest(char * szValue,LISTMODERNMASK * mmTemplateList)

+{

+	MODERNMASK mm={0};

+	SKINOBJECTDESCRIPTOR * res=NULL;

+	if (!mmTemplateList)

+		if (g_SkinObjectList.pMaskList)

+			mmTemplateList=g_SkinObjectList.pMaskList;

+		else 

+			return NULL;

+	

+	if (!mmTemplateList) return NULL;

+	ParseToModernMask(&mm,szValue);

+	res=skin_FindObjectByMask(&mm,mmTemplateList);

+	SkinSelector_DeleteMask(&mm);

+	return res;

+}

+

+TCHAR * GetParamNT(char * string, TCHAR * buf, int buflen, BYTE paramN, char Delim, BOOL SkipSpaces)

+{

+	char *ansibuf=(char*)mir_alloc(buflen/sizeof(TCHAR));

+	GetParamN(string, ansibuf, buflen/sizeof(TCHAR), paramN, Delim, SkipSpaces);

+	MultiByteToWideChar(CP_UTF8,0,ansibuf,-1,buf,buflen);

+	mir_free_and_nill(ansibuf);

+	return buf;

+}

+

+char * GetParamN(char * string, char * buf, int buflen, BYTE paramN, char Delim, BOOL SkipSpaces)

+{

+	int i=0;

+	DWORD start=0;

+	DWORD end=0;

+	DWORD CurentCount=0;

+	DWORD len;

+	while (i<mir_strlen(string))

+	{

+		if (string[i]==Delim)

+		{

+			if (CurentCount==paramN) break;

+			start=i+1;

+			CurentCount++;

+		}

+		i++;

+	}

+	if (CurentCount==paramN)

+	{

+		if (SkipSpaces)

+		{ //remove spaces

+			while (string[start]==' ' && (int)start<mir_strlen(string))

+				start++;

+			while (i>1 && string[i-1]==' ' && i>(int)start)

+				i--;

+		}

+		len=((int)(i-start)<buflen)?i-start:buflen;

+		strncpy(buf,string+start,len);

+		buf[len]='\0';

+	}

+	else buf[0]='\0';

+	return buf;

+}

+

+//Parse DB string and add buttons

+int RegisterButtonByParce(char * ObjectName, char * Params)

+{

+	char buf [255];

+	int res;

+	GetParamN(Params,buf, SIZEOF(buf),0,',',0);

+	// if (boolstrcmpi("Push",buf)

+	{   //Push type

+		char buf2[20]={0};

+		char pServiceName[255]={0};

+		char pStatusServiceName[255]={0};

+		int Left, Top,Right,Bottom;

+		int MinWidth, MinHeight;

+		char TL[9]={0};

+		TCHAR Hint[250]={0};

+		char Section[250]={0};

+		char Type[250]={0};

+

+		DWORD alingnto;

+		int a=((int)mir_bool_strcmpi(buf,"Switch"))*2;

+

+		GetParamN(Params,pServiceName, SIZEOF(pServiceName),1,',',0);

+		// if (a) GetParamN(Params,pStatusServiceName, sizeof(pStatusServiceName),a+1,',',0);

+		Left=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+2,',',0));

+		Top=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+3,',',0));

+		Right=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+4,',',0));

+		Bottom=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+5,',',0));

+		GetParamN(Params,TL, SIZEOF(TL),a+6,',',0);

+

+		MinWidth=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+7,',',0));

+		MinHeight=atoi(GetParamN(Params,buf2, SIZEOF(buf2),a+8,',',0));

+		GetParamNT(Params,Hint, SIZEOF(Hint),a+9,',',0);

+		if (a)

+		{

+			GetParamN(Params,Section, SIZEOF(Section),2,',',0);

+			GetParamN(Params,Type, SIZEOF(Type),3,',',0);

+		}

+		alingnto=  ( (TL[0]=='R') ? SBF_ALIGN_TL_RIGHT   : 0 )

+			+( (TL[0]=='C') ? SBF_ALIGN_TL_HCENTER : 0 )

+			+( (TL[1]=='B') ? SBF_ALIGN_TL_BOTTOM  : 0 )

+			+( (TL[1]=='C') ? SBF_ALIGN_TL_VCENTER : 0 )

+			+( (TL[2]=='R') ? SBF_ALIGN_BR_RIGHT   : 0 )

+			+( (TL[2]=='C') ? SBF_ALIGN_BR_HCENTER : 0 )

+			+( (TL[3]=='B') ? SBF_ALIGN_BR_BOTTOM  : 0 )

+			+( (TL[3]=='C') ? SBF_ALIGN_BR_VCENTER : 0 )

+			+( (TL[4]=='I') ? SBF_CALL_ON_PRESS    : 0 );

+		if (a) res=ModernSkinButton_AddButton(pcli->hwndContactList,ObjectName+1,pServiceName,pStatusServiceName,"\0",Left,Top,Right,Bottom,alingnto,TranslateTS(Hint),Section,Type,MinWidth,MinHeight);

+		else res=ModernSkinButton_AddButton(pcli->hwndContactList,ObjectName+1,pServiceName,pStatusServiceName,"\0",Left,Top,Right,Bottom,alingnto,TranslateTS(Hint),NULL,NULL,MinWidth,MinHeight);

+	}

+	return res;

+}

+

+//Parse DB string and add object

+// Params is:

+// Glyph,None

+// Glyph,Solid,<ColorR>,<ColorG>,<ColorB>,<Alpha>

+// Glyph,Image,Filename,(TileBoth|TileVert|TileHor|StretchBoth),<MarginLeft>,<MarginTop>,<MarginRight>,<MarginBottom>,<Alpha>

+int RegisterObjectByParce(char * ObjectName, char * Params)

+{

+	if (!ObjectName || !Params) return 0;

+	{

+		int res=0;

+		SKINOBJECTDESCRIPTOR obj={0};

+		char buf[250];

+		obj.szObjectID=mir_strdup(ObjectName);

+		GetParamN(Params,buf, SIZEOF(buf),0,',',0);

+		if (mir_bool_strcmpi(buf,"Glyph"))

+			obj.bType=OT_GLYPHOBJECT;

+		else if (mir_bool_strcmpi(buf,"Font"))

+			obj.bType=OT_FONTOBJECT;

+

+		switch (obj.bType)

+		{

+		case OT_GLYPHOBJECT:

+			{

+				GLYPHOBJECT gl={0};

+				GetParamN(Params,buf, SIZEOF(buf),1,',',0);

+				if (mir_bool_strcmpi(buf,"Solid"))

+				{

+					//Solid

+					int r,g,b;

+					gl.Style=ST_BRUSH;

+					r=atoi(GetParamN(Params,buf, SIZEOF(buf),2,',',0));

+					g=atoi(GetParamN(Params,buf, SIZEOF(buf),3,',',0));

+					b=atoi(GetParamN(Params,buf, SIZEOF(buf),4,',',0));

+					gl.dwAlpha=atoi(GetParamN(Params,buf, SIZEOF(buf),5,',',0));

+					gl.dwColor=RGB(r,g,b);

+				}

+				else if (mir_bool_strcmpi(buf,"Image"))

+				{

+					//Image

+					gl.Style=ST_IMAGE;

+					gl.szFileName=mir_strdup(GetParamN(Params,buf, SIZEOF(buf),2,',',0));

+					gl.dwLeft=atoi(GetParamN(Params,buf, SIZEOF(buf),4,',',0));

+					gl.dwTop=atoi(GetParamN(Params,buf, SIZEOF(buf),5,',',0));

+					gl.dwRight=atoi(GetParamN(Params,buf, SIZEOF(buf),6,',',0));

+					gl.dwBottom=atoi(GetParamN(Params,buf, SIZEOF(buf),7,',',0));

+					gl.dwAlpha =atoi(GetParamN(Params,buf, SIZEOF(buf),8,',',0));

+					GetParamN(Params,buf, SIZEOF(buf),3,',',0);

+					if (mir_bool_strcmpi(buf,"TileBoth")) gl.FitMode=FM_TILE_BOTH;

+					else if (mir_bool_strcmpi(buf,"TileVert")) gl.FitMode=FM_TILE_VERT;

+					else if (mir_bool_strcmpi(buf,"TileHorz")) gl.FitMode=FM_TILE_HORZ;

+					else gl.FitMode=0;

+				}

+				else if (mir_bool_strcmpi(buf,"Fragment"))

+				{

+					//Image

+					gl.Style=ST_FRAGMENT;

+					gl.szFileName=mir_strdup(GetParamN(Params,buf, SIZEOF(buf),2,',',0));

+

+					gl.clipArea.x=atoi(GetParamN(Params,buf, SIZEOF(buf),3,',',0));

+					gl.clipArea.y=atoi(GetParamN(Params,buf, SIZEOF(buf),4,',',0));

+					gl.szclipArea.cx=atoi(GetParamN(Params,buf, SIZEOF(buf),5,',',0));

+					gl.szclipArea.cy=atoi(GetParamN(Params,buf, SIZEOF(buf),6,',',0));

+

+					gl.dwLeft=atoi(GetParamN(Params,buf, SIZEOF(buf),8,',',0));

+					gl.dwTop=atoi(GetParamN(Params,buf, SIZEOF(buf),9,',',0));

+					gl.dwRight=atoi(GetParamN(Params,buf, SIZEOF(buf),10,',',0));

+					gl.dwBottom=atoi(GetParamN(Params,buf, SIZEOF(buf),11,',',0));

+					gl.dwAlpha =atoi(GetParamN(Params,buf, SIZEOF(buf),12,',',0));

+					GetParamN(Params,buf, SIZEOF(buf),7,',',0);

+					if (mir_bool_strcmpi(buf,"TileBoth")) gl.FitMode=FM_TILE_BOTH;

+					else if (mir_bool_strcmpi(buf,"TileVert")) gl.FitMode=FM_TILE_VERT;

+					else if (mir_bool_strcmpi(buf,"TileHorz")) gl.FitMode=FM_TILE_HORZ;

+					else gl.FitMode=0;

+				}

+				else

+				{

+					//None

+					gl.Style=ST_SKIP;

+				}

+				obj.Data=&gl;

+				res=ske_AddDescriptorToSkinObjectList(&obj,NULL);

+				mir_free_and_nill(obj.szObjectID);

+				if (gl.szFileName) mir_free_and_nill(gl.szFileName);

+				return res;

+			}

+			break;

+		}

+	}

+	return 0;

+}

+

+

+int SkinDrawGlyphMask(HDC hdc, RECT * rcSize, RECT * rcClip, MODERNMASK * ModernMask)

+{

+	if (!ModernMask) return 0;

+

+	SKINDRAWREQUEST rq;

+	rq.hDC=hdc;

+	rq.rcDestRect=*rcSize;

+	rq.rcClipRect=*rcClip;  

+	strncpy(rq.szObjectID,"Masked draw",SIZEOF("Masked draw"));

+	return ske_Service_DrawGlyph((WPARAM)&rq,(LPARAM)ModernMask);

+}

+

+

+int __inline SkinDrawWindowBack(HWND hwndIn, HDC hdc, RECT * rcClip, char * objectID)

+{

+	SKINDRAWREQUEST rq;

+	POINT pt={0};

+	RECT rc,r1;

+

+	HWND hwnd=(HWND)CallService(MS_CLUI_GETHWND,0,0);

+	if (!objectID) return 0;

+	GetWindowRect(hwndIn,&r1);

+	pt.x=r1.left;

+	pt.y=r1.top;

+	//ClientToScreen(hwndIn,&pt);

+	GetWindowRect(hwnd,&rc);

+	OffsetRect(&rc,-pt.x ,-pt.y);

+	rq.hDC=hdc;

+	rq.rcDestRect=rc;

+	rq.rcClipRect=*rcClip;

+	strncpy(rq.szObjectID,objectID,SIZEOF(rq.szObjectID));

+	///ske_Service_DrawGlyph((WPARAM)&rq,0);    //$$$

+	return CallService(MS_SKIN_DRAWGLYPH,(WPARAM)&rq,0);

+}