/*

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_nil(mmTemplateList->pl_Masks);
	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_nil(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_nil(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(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_nil(obj.szObjectID);
				mir_free_and_nil(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);
}