- crash fix in Clist Modern cache

- code cleaning

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

1 files changed, 1424 insertions, 1424 deletions

diff --git a/plugins/Clist_modern/modern_skinengine.cpp b/plugins/Clist_modern/modern_skinengine.cpp
index ea99b3e76b..4ddbdcb982 100644
--- a/plugins/Clist_modern/modern_skinengine.cpp
+++ b/plugins/Clist_modern/modern_skinengine.cpp
@@ -23,7 +23,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 

 //Include 

 #include "hdr/modern_commonheaders.h"

-#include <m_png.h> 

+#include  < m_png.h> 

 #include "m_api/m_skin_eng.h"

 #include "hdr/modern_skinselector.h"

 #include "hdr/modern_cluiframes.h"

@@ -34,48 +34,48 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 

 #include "hdr/modern_skinengine.h"

 #include "hdr/modern_commonprototypes.h"

-#include <shlwapi.h>

+#include  < shlwapi.h>

 #include "hdr/modern_sync.h"

 //Implementation

 

 /* Global variables */

 

-SKINOBJECTSLIST g_SkinObjectList={0};

-CURRWNDIMAGEDATA * g_pCachedWindow=NULL;

+SKINOBJECTSLIST g_SkinObjectList = {0};

+CURRWNDIMAGEDATA * g_pCachedWindow = NULL;

 

 BOOL (WINAPI *g_proc_UpdateLayeredWindow)(HWND,HDC,POINT*,SIZE*,HDC,POINT*,COLORREF,BLENDFUNCTION*,DWORD);

 

-BOOL    g_flag_bPostWasCanceled =FALSE;

-BOOL	g_flag_bFullRepaint     =FALSE;

-BOOL    g_mutex_bLockUpdating   =FALSE;

+BOOL    g_flag_bPostWasCanceled  = FALSE;

+BOOL	g_flag_bFullRepaint      = FALSE;

+BOOL    g_mutex_bLockUpdating    = FALSE;

 

-SortedList * gl_plGlyphTexts=NULL;

-SortedList * gl_plSkinFonts =NULL;

+SortedList * gl_plGlyphTexts = NULL;

+SortedList * gl_plSkinFonts  = NULL;

 

 /* Private module variables */

 

 static HANDLE  hSkinLoadedEvent;

 

-static GLYPHIMAGE * pLoadedImages=NULL;

-static DWORD        dwLoadedImagesCount=0;

-static DWORD        dwLoadedImagesAlocated=0;

+static GLYPHIMAGE * pLoadedImages = NULL;

+static DWORD        dwLoadedImagesCount = 0;

+static DWORD        dwLoadedImagesAlocated = 0;

 

-static BOOL flag_bUpdateQueued=FALSE;

-static BOOL	flag_bJustDrawNonFramedObjects=FALSE;

-static BOOL mutex_bLockUpdate=FALSE;

+static BOOL flag_bUpdateQueued = FALSE;

+static BOOL	flag_bJustDrawNonFramedObjects = FALSE;

+static BOOL mutex_bLockUpdate = FALSE;

 

-static SortedList       * pEffectStack=NULL;

-static SKINOBJECTSLIST  * pCurrentSkin=NULL;

-static char            ** pszSettingName=NULL;

-static int                nArrayLen=0;

-static char             * iniCurrentSection=NULL;

-static char             * szFileName=NULL;

+static SortedList       * pEffectStack = NULL;

+static SKINOBJECTSLIST  * pCurrentSkin = NULL;

+static char            ** pszSettingName = NULL;

+static int                nArrayLen = 0;

+static char             * iniCurrentSection = NULL;

+static char             * szFileName = NULL;

 

-static BYTE             pbGammaWeight[256]={0};

-static BYTE             pbGammaWeightAdv[256]={0};

-static BOOL             bGammaWeightFilled=FALSE;

+static BYTE             pbGammaWeight[256] = {0};

+static BYTE             pbGammaWeightAdv[256] = {0};

+static BOOL             bGammaWeightFilled = FALSE;

 

-static CRITICAL_SECTION cs_SkinChanging={0};

+static CRITICAL_SECTION cs_SkinChanging = {0};

 

 

 /* Private module procedures */

@@ -115,7 +115,7 @@ static pfnImgDeleteDIBSection ImgDeleteDIBSection;
 typedef DWORD (__stdcall *pfnImgGetHandle)(LPVOID /*in*/pImg, HBITMAP /*out*/*pBitmap, LPVOID /*out*/*ppDIBBits);

 static pfnImgGetHandle ImgGetHandle;    

 

-static MODERNEFFECT meCurrentEffect={-1,{0},0,0};

+static MODERNEFFECT meCurrentEffect = {-1,{0},0,0};

 

 

 //////////////////////////////////////////////////////////////////////////

@@ -135,7 +135,7 @@ IniParser::IniParser( TCHAR * tcsFileName, BYTE flags ) : _Flags( flags )
 

 	_hFile = _tfopen( tcsFileName, _T("r"));

 

-	if ( _hFile != NULL )

+	if ( _hFile !=NULL )

 	{

 		_eType = IT_FILE;

 		_isValid = true;

@@ -194,29 +194,29 @@ HRESULT IniParser::WriteStrToDb( const char * szSection, const char * szName, co
 		return S_OK;					 // skip not objects

 

 

-//	if ( strlen(szValue)>0 && szValue[strlen(szValue)-1]=='\n' ) 

-//		szValue[strlen(szValue)-1]='\0';  //kill linefeed at the end  

+//	if ( strlen(szValue)>0 && szValue[strlen(szValue)-1] == '\n' ) 

+//		szValue[strlen(szValue)-1] = '\0';  //kill linefeed at the end  

 

 	switch(szValue[0]) 

 	{

 	case 'b':

 		{

 			BYTE P;

-			P=(BYTE)atoi(szValue+1);

+			P = (BYTE)atoi(szValue+1);

 			db_set_b(NULL,szSection,szName,P);

 		}

 		break;

 	case 'w':

 		{

 			WORD P;

-			P=(WORD)atoi(szValue+1);

+			P = (WORD)atoi(szValue+1);

 			db_set_w(NULL,szSection,szName,P);

 		}

 		break;

 	case 'd':

 		{

 			DWORD P;

-			P=(DWORD)atoi(szValue+1);

+			P = (DWORD)atoi(szValue+1);

 			db_set_dw(NULL,szSection,szName,P);

 		}

 		break;

@@ -226,14 +226,14 @@ HRESULT IniParser::WriteStrToDb( const char * szSection, const char * szName, co
 	case 'f':

 		if (szFileName)

 		{

-			char fn[MAX_PATH]={0};

-			char bb[MAX_PATH*2]={0};

+			char fn[MAX_PATH] = {0};

+			char bb[MAX_PATH*2] = {0};

 			int pp, i;

-			pp=-1;

+			pp = -1;

 			CallService(MS_UTILS_PATHTORELATIVE, (WPARAM)szFileName, (LPARAM)fn);

 			{

-				for (i=strlen(fn); i>=0; i--)  if (fn[i]=='.') break;

-				if (i>0) fn[i]='\0';

+				for (i = strlen(fn); i >= 0; i--)  if (fn[i] == '.') break;

+				if (i>0) fn[i] = '\0';

 			}                      

 			_snprintf(bb,SIZEOF(bb),"%s\\%s",fn,szValue+1);

 			db_set_s(NULL,szSection,szName,bb);

@@ -249,17 +249,17 @@ int IniParser::GetSkinFolder( IN const TCHAR * szFileName, OUT TCHAR * pszFolder
 

 	szBuff = mir_tstrdup( szFileName );

 	pszPos = szBuff + _tcslen( szBuff );

-	while ( pszPos > szBuff && *pszPos!= _T('.')) { pszPos--; }

-	*pszPos=_T('\0');

+	while ( pszPos > szBuff && *pszPos != _T('.')) { pszPos--; }

+	*pszPos = _T('\0');

 	_tcscpy( pszFolderName, szBuff );

 

 	TCHAR custom_folder[MAX_PATH];

 	TCHAR cus[MAX_PATH];

 	TCHAR *b3;

 	_tcscpy( custom_folder, pszFolderName );

-	b3=custom_folder + _tcslen( custom_folder );

-	while ( b3 > custom_folder && *b3!= _T('\\')) { b3--; }

-	*b3=_T('\0');

+	b3 = custom_folder + _tcslen( custom_folder );

+	while ( b3 > custom_folder && *b3 != _T('\\')) { b3--; }

+	*b3 = _T('\0');

 

 	GetPrivateProfileString(_T("Skin_Description_Section"),_T("SkinFolder"),_T(""),cus,SIZEOF(custom_folder),szFileName);

 	if ( cus && _tcslen(cus)>0)

@@ -287,16 +287,16 @@ void IniParser::_DoInit()
 void IniParser::_LoadResourceIni( HINSTANCE hInst,  const char *  resourceName, const char * resourceType )

 {

 

-	if ( _eType != IT_UNKNOWN ) return;

+	if ( _eType !=IT_UNKNOWN ) return;

 

 	HRSRC hRSrc = FindResourceA( hInst, resourceName, resourceType );

 	if ( !hRSrc ) return;

 

-	_hGlobalRes=LoadResource( hInst, hRSrc );

+	_hGlobalRes = LoadResource( hInst, hRSrc );

 	if ( !_hGlobalRes ) return;

 

 	_dwSizeOfRes = SizeofResource( hInst, hRSrc );

-	_pPosition =(char*) LockResource( _hGlobalRes );

+	_pPosition  = (char*) LockResource( _hGlobalRes );

 

 	_isValid = true;

 	_eType	 = IT_RESOURCE;

@@ -309,13 +309,13 @@ HRESULT IniParser::_DoParseFile()
 {

 	char szLine[MAX_LINE_LEN];

 	_nLine = 0;

-	while ( fgets( szLine, SIZEOF(szLine), _hFile ) != NULL )

+	while ( fgets( szLine, SIZEOF(szLine), _hFile ) !=NULL )

 	{	

 		size_t len = 0;

 		char * pLine = (char*)_RemoveTailings( szLine, len );

 		if ( len > 0 )

 		{

-			pLine[len]='\0';

+			pLine[len] = '\0';

 			if ( !_DoParseLine( pLine ))	return E_FAIL;

 		}

 		else

@@ -333,21 +333,21 @@ HRESULT IniParser::_DoParseResource()
 

 	while ( pos < _pPosition + _dwSizeOfRes )

 	{

-		int i=0;

-		while ( pos < _pPosition + _dwSizeOfRes && *pos != '\n' && *pos!= '\0' && i < MAX_LINE_LEN - 1 )

+		int i = 0;

+		while ( pos < _pPosition + _dwSizeOfRes && *pos !='\n' && *pos != '\0' && i < MAX_LINE_LEN - 1 )

 		{

-			if ( (*pos) != '\r' ) 

+			if ( (*pos) !='\r' ) 

 				szLine[ i++ ] = *pos;

 			pos++;

 		}

-		szLine[ i ]='\0';

+		szLine[ i ] = '\0';

 		pos++;

 		

 		size_t len = 0;

 		char * pLine = (char*) _RemoveTailings( szLine, len );

 		if ( len > 0 )

 		{

-			pLine[len]='\0';

+			pLine[len] = '\0';

 			if ( !_DoParseLine( pLine ))	return E_FAIL;

 		}

 		else

@@ -359,7 +359,7 @@ HRESULT IniParser::_DoParseResource()
 const char * IniParser::_RemoveTailings( const char * szLine, size_t& len )

 {

 	const char * pStart = szLine;

-	while( *pStart == ' ' || *pStart=='\t' ) pStart++; //skip spaces at begin

+	while( *pStart == ' ' || *pStart == '\t' ) pStart++; //skip spaces at begin

 	const char * pEnd = pStart + strlen( pStart );

 	while( pEnd > pStart && ( *pEnd == ' ' || *pEnd == '\t' || *pEnd == '\n' || *pEnd == '\r' )) pEnd--;

 

@@ -386,16 +386,16 @@ BOOL IniParser::_DoParseLine( char * szLine )
 

 			char *tbuf = szLine + 1;	// skip [

 	

-			char *ebuf= tbuf;

+			char *ebuf = tbuf;

 

-			while ( *ebuf != ']' && *ebuf !='\0' ) ebuf++;

+			while ( *ebuf !=']' && *ebuf !='\0' ) ebuf++;

 			if ( *ebuf == '\0' ) 

 				return FALSE; // no close bracket

 	

 			DWORD sectionLen = ebuf - tbuf;

 			_szSection = (char*) mir_alloc( sectionLen + 1 );

 			strncpy( _szSection, tbuf, sectionLen );

-			_szSection[sectionLen]='\0';

+			_szSection[sectionLen] = '\0';

 		}

 		return TRUE;

 

@@ -403,17 +403,17 @@ BOOL IniParser::_DoParseLine( char * szLine )
 		if ( !_szSection ) 

 			return TRUE;  //param found out of section

 

-		char *keyName=szLine;

-		char *keyValue=szLine;

+		char *keyName = szLine;

+		char *keyValue = szLine;

 

-		DWORD eqPlace=0;

-		DWORD len2=strlen(keyName);

+		DWORD eqPlace = 0;

+		DWORD len2 = strlen(keyName);

 

-		while ( eqPlace < len2 && keyName[ eqPlace ] != '=' ) 

-			eqPlace++; //find '='

+		while ( eqPlace < len2 && keyName[ eqPlace ] !=' = ' ) 

+			eqPlace++; //find ' = '

 

-		if (eqPlace==0 || eqPlace==len2) 

-			return TRUE; //= not found or no key name //say false

+		if (eqPlace == 0 || eqPlace == len2) 

+			return TRUE; // = not found or no key name //say false

 

 		keyName[eqPlace] = '\0';

 

@@ -421,24 +421,24 @@ BOOL IniParser::_DoParseLine( char * szLine )
 

 		//remove tail spaces in Name

 		{

-			DWORD len3=strlen(keyName);

-			int j=len3-1;

-			while (j>0 && (keyName[j]==' ' || keyName[j]=='\t')) j--;

-			if (j>=0) keyName[j+1]='\0';

+			DWORD len3 = strlen(keyName);

+			int j = len3-1;

+			while (j>0 && (keyName[j] == ' ' || keyName[j] == '\t')) j--;

+			if (j >= 0) keyName[j+1] = '\0';

 		}		

 		//remove start spaces in Value

 		{

-			DWORD len3=strlen(keyValue);

-			DWORD j=0;

-			while (j<len3 && (keyValue[j]==' ' || keyValue[j]=='\t')) j++;

-			if (j<len3) keyValue+=j;

+			DWORD len3 = strlen(keyValue);

+			DWORD j = 0;

+			while (j < len3 && (keyValue[j] == ' ' || keyValue[j] == '\t')) j++;

+			if (j < len3) keyValue += j;

 		}

 		//remove tail spaces in Value

 		{

-			DWORD len3=strlen(keyValue);

-			int j=len3-1;

-			while (j>0 && (keyValue[j]==' ' || keyValue[j]=='\t' || keyValue[j]=='\n')) j--;

-			if (j>=0) keyValue[j+1]='\0';

+			DWORD len3 = strlen(keyValue);

+			int j = len3-1;

+			while (j>0 && (keyValue[j] == ' ' || keyValue[j] == '\t' || keyValue[j] == '\n')) j--;

+			if (j >= 0) keyValue[j+1] = '\0';

 		}

 		_pLineCallBackProc( _szSection, keyName, keyValue, this );

 	}

@@ -452,26 +452,26 @@ HRESULT SkinEngineLoadModule()
 {

 	ModernSkinButtonLoadModule();

 	InitializeCriticalSection(&cs_SkinChanging);

-	MainModernMaskList=(LISTMODERNMASK*)mir_calloc(sizeof(LISTMODERNMASK));

+	MainModernMaskList = (LISTMODERNMASK*)mir_calloc(sizeof(LISTMODERNMASK));

 	//init variables

-	g_SkinObjectList.dwObjLPAlocated=0;

-	g_SkinObjectList.dwObjLPReserved=0;

-	g_SkinObjectList.pObjects=NULL;

+	g_SkinObjectList.dwObjLPAlocated = 0;

+	g_SkinObjectList.dwObjLPReserved = 0;

+	g_SkinObjectList.pObjects = NULL;

 	// Initialize GDI+

 	InitGdiPlus();

 	AniAva_InitModule();

 	//load decoder

-	hImageDecoderModule=NULL;

+	hImageDecoderModule = NULL;

 	if (g_CluiData.fGDIPlusFail)

 	{

 		hImageDecoderModule = LoadLibrary(TEXT("ImgDecoder.dll"));

-		if (hImageDecoderModule==NULL) 

+		if (hImageDecoderModule == NULL) 

 		{

 			char tDllPath[ MAX_PATH ];

 			GetModuleFileNameA( g_hInst, tDllPath, sizeof( tDllPath ));

 			{

 				char* p = strrchr( tDllPath, '\\' );

-				if ( p != NULL )

+				if ( p !=NULL )

 					strcpy( p+1, "ImgDecoder.dll" );

 				else

 				{

@@ -481,13 +481,13 @@ HRESULT SkinEngineLoadModule()
 

 			hImageDecoderModule = LoadLibraryA(tDllPath);

 		}

-		if (hImageDecoderModule!=NULL) 

+		if (hImageDecoderModule != NULL) 

 		{

-			ImgNewDecoder=(pfnImgNewDecoder )GetProcAddress( hImageDecoderModule, "ImgNewDecoder");

-			ImgDeleteDecoder=(pfnImgDeleteDecoder )GetProcAddress( hImageDecoderModule, "ImgDeleteDecoder");

-			ImgNewDIBFromFile=(pfnImgNewDIBFromFile)GetProcAddress( hImageDecoderModule, "ImgNewDIBFromFile");

-			ImgDeleteDIBSection=(pfnImgDeleteDIBSection)GetProcAddress( hImageDecoderModule, "ImgDeleteDIBSection");

-			ImgGetHandle=(pfnImgGetHandle)GetProcAddress( hImageDecoderModule, "ImgGetHandle");

+			ImgNewDecoder = (pfnImgNewDecoder )GetProcAddress( hImageDecoderModule, "ImgNewDecoder");

+			ImgDeleteDecoder = (pfnImgDeleteDecoder )GetProcAddress( hImageDecoderModule, "ImgDeleteDecoder");

+			ImgNewDIBFromFile = (pfnImgNewDIBFromFile)GetProcAddress( hImageDecoderModule, "ImgNewDIBFromFile");

+			ImgDeleteDIBSection = (pfnImgDeleteDIBSection)GetProcAddress( hImageDecoderModule, "ImgDeleteDIBSection");

+			ImgGetHandle = (pfnImgGetHandle)GetProcAddress( hImageDecoderModule, "ImgGetHandle");

 		}

 	}

 	//create services

@@ -500,7 +500,7 @@ HRESULT SkinEngineLoadModule()
     CreateServiceFunction(MS_DRAW_TEXT_WITH_EFFECT,ske_Service_DrawTextWithEffect);

 

 	//create event handle

-	hSkinLoadedEvent=ModernHookEvent(ME_SKIN_SERVICESCREATED,CLUI_OnSkinLoad);

+	hSkinLoadedEvent = ModernHookEvent(ME_SKIN_SERVICESCREATED,CLUI_OnSkinLoad);

 	NotifyEventHooks(g_CluiData.hEventSkinServicesCreated,0,0);

 	return S_OK;

 }

@@ -520,10 +520,10 @@ int SkinEngineUnloadModule()
 	if (pEffectStack)

 	{

 		int i;

-		for (i=0; i<pEffectStack->realCount; i++)

+		for (i = 0; i < pEffectStack->realCount; i++)

 			if (pEffectStack->items[i])

 			{

-				EFFECTSSTACKITEM * effect=(EFFECTSSTACKITEM*)(pEffectStack->items[i]);

+				EFFECTSSTACKITEM * effect = (EFFECTSSTACKITEM*)(pEffectStack->items[i]);

 				mir_free_and_nill(effect);

 			}

 			List_Destroy(pEffectStack);

@@ -539,7 +539,7 @@ int SkinEngineUnloadModule()
 		mod_DeleteDC(g_pCachedWindow->hImageDC);

 		ReleaseDC(NULL,g_pCachedWindow->hScreenDC);

 		mir_free_and_nill(g_pCachedWindow);

-		g_pCachedWindow=NULL;

+		g_pCachedWindow = NULL;

 	}

 	DeleteCriticalSection(&cs_SkinChanging);

 	GdiFlush();

@@ -559,7 +559,7 @@ BOOL ske_AlphaBlend(HDC hdcDest,int nXOriginDest,int nYOriginDest,int nWidthDest
 {

 	if (g_CluiData.fDisableSkinEngine && !(!g_CluiData.fGDIPlusFail && blendFunction.BlendFlags&128))

 	{

-		if (nWidthDest!=nWidthSrc || nHeightDest!=nHeightSrc) 

+		if (nWidthDest != nWidthSrc || nHeightDest != nHeightSrc) 

 			return StretchBlt(hdcDest,nXOriginDest,nYOriginDest,nWidthDest,nHeightDest,hdcSrc,nXOriginSrc,nYOriginSrc,nWidthSrc,nHeightSrc, SRCCOPY);

 		else

 			return BitBlt(hdcDest,nXOriginDest,nYOriginDest,nWidthDest,nHeightDest,hdcSrc,nXOriginSrc,nYOriginSrc, SRCCOPY);

@@ -571,7 +571,7 @@ BOOL ske_AlphaBlend(HDC hdcDest,int nXOriginDest,int nYOriginDest,int nWidthDest
 			hdcSrc,nXOriginSrc,nYOriginSrc,nWidthSrc,nHeightSrc,

 			&blendFunction);

 	}

-	blendFunction.BlendFlags&=~128;

+	blendFunction.BlendFlags &= ~128;

 	return AlphaBlend(hdcDest,nXOriginDest,nYOriginDest,nWidthDest,nHeightDest,hdcSrc,nXOriginSrc,nYOriginSrc,nWidthSrc,nHeightSrc,blendFunction);

 }

 

@@ -599,21 +599,21 @@ typedef struct _tagDCBuffer
 	HBITMAP hBitmap;

 	DWORD dwDestroyAfterTime;

 }DCBUFFER;

-CRITICAL_SECTION BufferListCS={0};

+CRITICAL_SECTION BufferListCS = {0};

 

-SortedList * BufferList=NULL;

+SortedList * BufferList = NULL;

 enum

 {

-	BUFFER_DRAWICON=0,

+	BUFFER_DRAWICON = 0,

 	BUFFER_DRAWIMAGE

 };

 

 int SortBufferList(void* it1, void * it2)

 {

-	DCBUFFER * buf1=(DCBUFFER *)it1;

-	DCBUFFER * buf2=(DCBUFFER *)it2;

-	if (buf1->hdcOwnedBy!=buf2->hdcOwnedBy) return (int)(buf1->hdcOwnedBy < buf2->hdcOwnedBy);

-	else if (buf1->nUsageID!=buf2->nUsageID) return (int) (buf1->nUsageID < buf2->nUsageID);

+	DCBUFFER * buf1 = (DCBUFFER *)it1;

+	DCBUFFER * buf2 = (DCBUFFER *)it2;

+	if (buf1->hdcOwnedBy != buf2->hdcOwnedBy) return (int)(buf1->hdcOwnedBy < buf2->hdcOwnedBy);

+	else if (buf1->nUsageID != buf2->nUsageID) return (int) (buf1->nUsageID < buf2->nUsageID);

 	else return (int) (buf1->hDC < buf2->hDC);

 }

 

@@ -621,70 +621,70 @@ HDC ske_RequestBufferDC(HDC hdcOwner, int dcID, int width, int height, BOOL fCle
 {

 	DCBUFFER buf;

 	DCBUFFER * pBuf;

-	if (BufferList==NULL)

+	if (BufferList == NULL)

 	{

-		BufferList=List_Create(0,2);

-		BufferList->sortFunc=SortBufferList;

+		BufferList = List_Create(0,2);

+		BufferList->sortFunc = SortBufferList;

 		InitializeCriticalSection(&BufferListCS);

 	}

 	EnterCriticalSection(&BufferListCS);

 	//Try to find DC in buffer list	

-	buf.hdcOwnedBy=hdcOwner;

-	buf.nUsageID=dcID;

-	buf.hDC=NULL;

-	pBuf=(DCBUFFER*)List_Find(BufferList,(void*)&buf);

+	buf.hdcOwnedBy = hdcOwner;

+	buf.nUsageID = dcID;

+	buf.hDC = NULL;

+	pBuf = (DCBUFFER*)List_Find(BufferList,(void*)&buf);

 	if (!pBuf)

 	{

 		//if not found - allocate it

-		pBuf=(DCBUFFER *)mir_alloc(sizeof(DCBUFFER));

-		*pBuf=buf;

-		pBuf->width=width;

-		pBuf->height=height;

-		pBuf->hBitmap=ske_CreateDIB32Point(width,height,&(pBuf->pImage));

-		pBuf->hDC=CreateCompatibleDC(hdcOwner);

-		pBuf->oldBitmap=(HBITMAP)SelectObject(pBuf->hDC,pBuf->hBitmap);

-		pBuf->dwDestroyAfterTime=0;

+		pBuf = (DCBUFFER *)mir_alloc(sizeof(DCBUFFER));

+		*pBuf = buf;

+		pBuf->width = width;

+		pBuf->height = height;

+		pBuf->hBitmap = ske_CreateDIB32Point(width,height,&(pBuf->pImage));

+		pBuf->hDC = CreateCompatibleDC(hdcOwner);

+		pBuf->oldBitmap = (HBITMAP)SelectObject(pBuf->hDC,pBuf->hBitmap);

+		pBuf->dwDestroyAfterTime = 0;

 		List_InsertPtr(BufferList,pBuf);		

 	}

 	else 

 	{

-		if (pBuf->width!=width || pBuf->height!=height)

+		if (pBuf->width != width || pBuf->height != height)

 		{

 			//resize

 			SelectObject(pBuf->hDC,pBuf->oldBitmap);

 			DeleteObject(pBuf->hBitmap);

-			pBuf->width=width;

-			pBuf->height=height;

-			pBuf->hBitmap=ske_CreateDIB32Point(width,height,&(pBuf->pImage));

-			pBuf->oldBitmap=(HBITMAP)SelectObject(pBuf->hDC,pBuf->hBitmap);

+			pBuf->width = width;

+			pBuf->height = height;

+			pBuf->hBitmap = ske_CreateDIB32Point(width,height,&(pBuf->pImage));

+			pBuf->oldBitmap = (HBITMAP)SelectObject(pBuf->hDC,pBuf->hBitmap);

 		}  else	if (fClear)

 			memset(pBuf->pImage,0,width*height*sizeof(DWORD));

 	}

-	pBuf->dwDestroyAfterTime=0;

+	pBuf->dwDestroyAfterTime = 0;

 	LeaveCriticalSection(&BufferListCS);

 	return pBuf->hDC;

 }

 

 int ske_ReleaseBufferDC(HDC hDC, int keepTime)

 {

-	DWORD dwCurrentTime=GetTickCount();

-	DCBUFFER * pBuf=NULL;

+	DWORD dwCurrentTime = GetTickCount();

+	DCBUFFER * pBuf = NULL;

 	//Try to find DC in buffer list - set flag to be release after time;

-	int i=0;

+	int i = 0;

 	EnterCriticalSection(&BufferListCS);

-	for (i=0; i<BufferList->realCount; i++)

+	for (i = 0; i < BufferList->realCount; i++)

 	{

-		pBuf=(DCBUFFER *)BufferList->items[i];

+		pBuf = (DCBUFFER *)BufferList->items[i];

 		if (pBuf)

 		{

-			if (hDC!=NULL && pBuf->hDC==hDC)

+			if (hDC != NULL && pBuf->hDC == hDC)

 			{

-				pBuf->dwDestroyAfterTime=dwCurrentTime+keepTime;

+				pBuf->dwDestroyAfterTime = dwCurrentTime+keepTime;

 				break;

 			}

 			else  

 			{

-				if ((pBuf->dwDestroyAfterTime && pBuf->dwDestroyAfterTime < dwCurrentTime) || keepTime==-1)

+				if ((pBuf->dwDestroyAfterTime && pBuf->dwDestroyAfterTime < dwCurrentTime) || keepTime == -1)

 				{

 					SelectObject(pBuf->hDC,pBuf->oldBitmap);

 					DeleteObject(pBuf->hBitmap);

@@ -707,11 +707,11 @@ BOOL ske_SetRgnOpaque(HDC memdc,HRGN hrgn, BOOL force)
 	DWORD d;

 	RECT * rect;

 	if (g_CluiData.fDisableSkinEngine && !force) return TRUE;

-	rgnsz=GetRegionData(hrgn,0,NULL);

-	rdata=(RGNDATA *) mir_alloc(rgnsz);

+	rgnsz = GetRegionData(hrgn,0,NULL);

+	rdata = (RGNDATA *) mir_alloc(rgnsz);

 	GetRegionData(hrgn,rgnsz,rdata);

-	rect=(RECT *)rdata->Buffer;

-	for (d=0; d<rdata->rdh.nCount; d++)

+	rect = (RECT *)rdata->Buffer;

+	for (d = 0; d < rdata->rdh.nCount; d++)

 	{

 		ske_SetRectOpaque(memdc,&rect[d], force);

 	}

@@ -722,7 +722,7 @@ BOOL ske_SetRgnOpaque(HDC memdc,HRGN hrgn, BOOL force)
 

 BOOL ske_SetRectOpaque(HDC memdc,RECT *fr, BOOL force)

 {

-	int f=0;

+	int f = 0;

 	BYTE * bits;

 	BITMAP bmp;

 	HBITMAP hbmp;

@@ -730,27 +730,27 @@ BOOL ske_SetRectOpaque(HDC memdc,RECT *fr, BOOL force)
 	if ( g_CluiData.fDisableSkinEngine && !force ) 

 		return TRUE;

 

-	hbmp=(HBITMAP)GetCurrentObject( memdc,OBJ_BITMAP );  

+	hbmp = (HBITMAP)GetCurrentObject( memdc,OBJ_BITMAP );  

 	GetObject( hbmp, sizeof(bmp), &bmp );

 

-	if ( bmp.bmPlanes != 1 )

+	if ( bmp.bmPlanes !=1 )

 		return FALSE;

 	

 	if (!bmp.bmBits)

 	{

-		f=1;

-		bits=(BYTE*)malloc(bmp.bmWidthBytes*bmp.bmHeight);

+		f = 1;

+		bits = (BYTE*)malloc(bmp.bmWidthBytes*bmp.bmHeight);

 		GetBitmapBits(hbmp,bmp.bmWidthBytes*bmp.bmHeight,bits);

 	}

 	else

-		bits=(BYTE*)bmp.bmBits;

+		bits = (BYTE*)bmp.bmBits;

 

-	int sx =( fr->left > 0 ) ? fr->left : 0;

-	int sy =( fr->top > 0 ) ? fr->top : 0;

-	int ex =( fr->right < bmp.bmWidth ) ? fr->right : bmp.bmWidth;

-	int ey =( fr->bottom<bmp.bmHeight) ? fr->bottom : bmp.bmHeight;

+	int sx  = ( fr->left > 0 ) ? fr->left : 0;

+	int sy  = ( fr->top > 0 ) ? fr->top : 0;

+	int ex  = ( fr->right < bmp.bmWidth ) ? fr->right : bmp.bmWidth;

+	int ey  = ( fr->bottom < bmp.bmHeight) ? fr->bottom : bmp.bmHeight;

 

-	int width=ex-sx;

+	int width = ex-sx;

 	

 	BYTE* pLine = ((BYTE*)bits) + (bmp.bmHeight-sy-1)*bmp.bmWidthBytes + (sx << 2) + 3;

 	for ( int y = 0; y < (ey - sy); y++ )

@@ -759,9 +759,9 @@ BOOL ske_SetRectOpaque(HDC memdc,RECT *fr, BOOL force)
 		for ( int x = 0; x < width; x++ )

 		{	

 			*pColumn = 255; 

-			pColumn += 4;

+			pColumn  += 4;

 		}

-		pLine -= bmp.bmWidthBytes;

+		pLine  -= bmp.bmWidthBytes;

 	}

 	if (f)

 	{

@@ -774,31 +774,31 @@ BOOL ske_SetRectOpaque(HDC memdc,RECT *fr, BOOL force)
 

 static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT * rGlyph, RECT * rClip, BYTE mode, BYTE drawMode, int depth)

 {

-	int destw=0, desth=0;

-	int xstart=0, xmax=0;

-	int ystart=0, ymax=0;

-	BLENDFUNCTION bfa={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA }; 

-	BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA }; 

+	int destw = 0, desth = 0;

+	int xstart = 0, xmax = 0;

+	int ystart = 0, ymax = 0;

+	BLENDFUNCTION bfa = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA }; 

+	BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA }; 

 

 	//initializations

-	if (mode==FM_STRETCH)

+	if (mode == FM_STRETCH)

 	{

 		HDC mem2dc;

 		HBITMAP mem2bmp, oldbmp;

 		RECT wr;

 		IntersectRect(&wr,rClip,rFill);

-		if ((wr.bottom-wr.top)*(wr.right-wr.left)==0) return 0;       

-		if (drawMode!=2)

+		if ((wr.bottom-wr.top)*(wr.right-wr.left) == 0) return 0;       

+		if (drawMode != 2)

 		{

-			mem2dc=CreateCompatibleDC(hDest);

-			mem2bmp=ske_CreateDIB32(wr.right-wr.left,wr.bottom-wr.top);

-			oldbmp=(HBITMAP)SelectObject(mem2dc,mem2bmp);

+			mem2dc = CreateCompatibleDC(hDest);

+			mem2bmp = ske_CreateDIB32(wr.right-wr.left,wr.bottom-wr.top);

+			oldbmp = (HBITMAP)SelectObject(mem2dc,mem2bmp);

 

 		}

 

-		if (drawMode==0 || drawMode==2)

+		if (drawMode == 0 || drawMode == 2)

 		{

-			if (drawMode==0)

+			if (drawMode == 0)

 			{

 				ske_AlphaBlend(mem2dc,rFill->left-wr.left,rFill->top-wr.top,rFill->right-rFill->left,rFill->bottom-rFill->top,

 					hSource,rGlyph->left,rGlyph->top,rGlyph->right-rGlyph->left,rGlyph->bottom-rGlyph->top,bf);

@@ -813,12 +813,12 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 		}

 		else

 		{

-			//            BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, 0 };

+			//            BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, 0 };

 			ske_AlphaBlend(mem2dc,rFill->left-wr.left,rFill->top-wr.top,rFill->right-rFill->left,rFill->bottom-rFill->top,

 				hSource,rGlyph->left,rGlyph->top,rGlyph->right-rGlyph->left,rGlyph->bottom-rGlyph->top,bf); 

 			ske_AlphaBlend(hDest,wr.left,wr.top,wr.right-wr.left, wr.bottom -wr.top,mem2dc,0,0,wr.right-wr.left, wr.bottom -wr.top,bf);

 		}

-		if (drawMode!=2)

+		if (drawMode != 2)

 		{

 			SelectObject(mem2dc,oldbmp);

 			DeleteObject(mem2bmp);

@@ -826,69 +826,69 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 		}

 		return 1;

 	}

-	else if (mode==FM_TILE_VERT && (rGlyph->bottom-rGlyph->top>0)&& (rGlyph->right-rGlyph->left>0))

+	else if (mode == FM_TILE_VERT && (rGlyph->bottom-rGlyph->top>0)&& (rGlyph->right-rGlyph->left>0))

 	{

 		HDC mem2dc;

 		HBITMAP mem2bmp,oldbmp;

 		RECT wr;

 		IntersectRect(&wr,rClip,rFill);

-		if ((wr.bottom-wr.top)*(wr.right-wr.left)==0) return 0;

-		mem2dc=CreateCompatibleDC(hDest);

+		if ((wr.bottom-wr.top)*(wr.right-wr.left) == 0) return 0;

+		mem2dc = CreateCompatibleDC(hDest);

 		//SetStretchBltMode(mem2dc, HALFTONE);

-		mem2bmp=ske_CreateDIB32(wr.right-wr.left, rGlyph->bottom-rGlyph->top);

-		oldbmp=(HBITMAP)SelectObject(mem2dc,mem2bmp);

+		mem2bmp = ske_CreateDIB32(wr.right-wr.left, rGlyph->bottom-rGlyph->top);

+		oldbmp = (HBITMAP)SelectObject(mem2dc,mem2bmp);

 		if (!oldbmp) 

 			return 0;

 

 		/// draw here

 		{

-			int  y=0, sy=0, maxy=0;

-			int w=rFill->right-rFill->left;

-			int h=rGlyph->bottom-rGlyph->top;

-			if (h>0 && (wr.bottom-wr.top)*(wr.right-wr.left)!=0)

+			int  y = 0, sy = 0, maxy = 0;

+			int w = rFill->right-rFill->left;

+			int h = rGlyph->bottom-rGlyph->top;

+			if (h>0 && (wr.bottom-wr.top)*(wr.right-wr.left) != 0)

 			{

-				w=wr.right-wr.left;

+				w = wr.right-wr.left;

 				{

-					//                   BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, 0 };

+					//                   BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, 0 };

 					ske_AlphaBlend(mem2dc,-(wr.left-rFill->left),0,rFill->right-rFill->left,h,hSource,rGlyph->left,rGlyph->top,rGlyph->right-rGlyph->left,h,bf);

 					//StretchBlt(mem2dc,-(wr.left-rFill->left),0,rFill->right-rFill->left,h,hSource,rGlyph->left,rGlyph->top,rGlyph->right-rGlyph->left,h,SRCCOPY);

 				}

-				if (drawMode==0 || drawMode==2)

+				if (drawMode == 0 || drawMode == 2)

 				{

-					if (drawMode==0 )

+					if (drawMode == 0 )

 					{

 

 						int dy;

-						dy=(wr.top-rFill->top)%h;

-						if (dy>=0)

+						dy = (wr.top-rFill->top)%h;

+						if (dy >= 0)

 						{

 							int ht;

-							y=wr.top;

-							ht=(y+h-dy<=wr.bottom)?(h-dy):(wr.bottom-wr.top);

+							y = wr.top;

+							ht = (y+h-dy <= wr.bottom)?(h-dy):(wr.bottom-wr.top);

 							BitBlt(hDest,wr.left,y,w,ht,mem2dc,0,dy,SRCCOPY);

 						}

 

-						y=wr.top+h-dy;

-						while (y<wr.bottom-h){

+						y = wr.top+h-dy;

+						while (y < wr.bottom-h){

 							BitBlt(hDest,wr.left,y,w,h,mem2dc,0,0,SRCCOPY);

-							y+=h;

+							y += h;

 						}

-						if (y<=wr.bottom)

+						if (y <= wr.bottom)

 							BitBlt(hDest,wr.left,y,w,wr.bottom-y, mem2dc,0,0,SRCCOPY);                                            

 

 					}

 					else 

 					{  

-						y=wr.top;

-						while (y<wr.bottom-h)

+						y = wr.top;

+						while (y < wr.bottom-h)

 						{

-							//                             BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, 0 };

+							//                             BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, 0 };

 							ske_AlphaBlend(hDest,wr.left,y,w,h, mem2dc,0,0,w,h,bf);                    

-							y+=h;

+							y += h;

 						}

-						if (y<=wr.bottom)

+						if (y <= wr.bottom)

 						{

-							//                           BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, 0 };

+							//                           BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, 0 };

 							ske_AlphaBlend(hDest,wr.left,y,w,wr.bottom-y, mem2dc,0,0,w,wr.bottom-y,bf);                                            

 						}

 					}

@@ -898,25 +898,25 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 				{

 					int dy;

 

-					BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+					BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 

-					dy=(wr.top-rFill->top)%h;

+					dy = (wr.top-rFill->top)%h;

 

-					if (dy>=0)

+					if (dy >= 0)

 					{

 						int ht;

-						y=wr.top;

-						ht=(y+h-dy<=wr.bottom)?(h-dy):(wr.bottom-wr.top);

+						y = wr.top;

+						ht = (y+h-dy <= wr.bottom)?(h-dy):(wr.bottom-wr.top);

 						ske_AlphaBlend(hDest,wr.left,y,w,ht,mem2dc,0,dy,w,ht,bf);

 					}

 

-					y=wr.top+h-dy;

-					while (y<wr.bottom-h)

+					y = wr.top+h-dy;

+					while (y < wr.bottom-h)

 					{

 						ske_AlphaBlend(hDest,wr.left,y,w,h,mem2dc,0,0,w,h,bf);

-						y+=h;

+						y += h;

 					}

-					if (y<=wr.bottom)

+					if (y <= wr.bottom)

 						ske_AlphaBlend(hDest,wr.left,y,w,wr.bottom-y, mem2dc,0,0,w,wr.bottom-y,bf);

 				}

 			}

@@ -925,86 +925,86 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 		DeleteObject(mem2bmp);

 		mod_DeleteDC(mem2dc);

 	}

-	else if (mode==FM_TILE_HORZ && (rGlyph->right-rGlyph->left>0)&& (rGlyph->bottom-rGlyph->top>0)&&(rFill->bottom-rFill->top)>0 && (rFill->right-rFill->left)>0)

+	else if (mode == FM_TILE_HORZ && (rGlyph->right-rGlyph->left>0)&& (rGlyph->bottom-rGlyph->top>0)&&(rFill->bottom-rFill->top)>0 && (rFill->right-rFill->left)>0)

 	{

 		HDC mem2dc;

 		RECT wr;

 		HBITMAP mem2bmp,oldbmp;

-		int w=rGlyph->right-rGlyph->left;

-		int h=rFill->bottom-rFill->top;

+		int w = rGlyph->right-rGlyph->left;

+		int h = rFill->bottom-rFill->top;

 		IntersectRect(&wr,rClip,rFill);

-		if ((wr.bottom-wr.top)*(wr.right-wr.left)==0) return 0;

-		h=wr.bottom-wr.top;

-		mem2dc=CreateCompatibleDC(hDest);

+		if ((wr.bottom-wr.top)*(wr.right-wr.left) == 0) return 0;

+		h = wr.bottom-wr.top;

+		mem2dc = CreateCompatibleDC(hDest);

 

-		mem2bmp=ske_CreateDIB32(w,h);

-		oldbmp=(HBITMAP)SelectObject(mem2dc,mem2bmp);

+		mem2bmp = ske_CreateDIB32(w,h);

+		oldbmp = (HBITMAP)SelectObject(mem2dc,mem2bmp);

 

 		if (!oldbmp)

 			return 0;

 		/// draw here

 		{

-			int  x=0, sy=0, maxy=0;

+			int  x = 0, sy = 0, maxy = 0;

 			{

 				//SetStretchBltMode(mem2dc, HALFTONE);

 				//StretchBlt(mem2dc,0,0,w,h,hSource,rGlyph->left+(wr.left-rFill->left),rGlyph->top,w,h,SRCCOPY);

 

-				//                    BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, 0 };

+				//                    BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, 0 };

 				ske_AlphaBlend(mem2dc,0,-(wr.top-rFill->top),w,rFill->bottom-rFill->top,hSource,rGlyph->left,rGlyph->top,w,rGlyph->bottom-rGlyph->top,bf);

-				if (drawMode==0 || drawMode==2)

+				if (drawMode == 0 || drawMode == 2)

 				{

-					if (drawMode==0)

+					if (drawMode == 0)

 					{

 

 						int dx;

-						dx=(wr.left-rFill->left)%w;

-						if (dx>=0)

+						dx = (wr.left-rFill->left)%w;

+						if (dx >= 0)

 						{   

 							int wt;

-							x=wr.left;

-							wt=(x+w-dx<=wr.right)?(w-dx):(wr.right-wr.left);                                                   

+							x = wr.left;

+							wt = (x+w-dx <= wr.right)?(w-dx):(wr.right-wr.left);                                                   

 							BitBlt(hDest,x,wr.top,wt,h,mem2dc,dx,0,SRCCOPY);

 						}

-						x=wr.left+w-dx;                        

-						while (x<wr.right-w){

+						x = wr.left+w-dx;                        

+						while (x < wr.right-w){

 							BitBlt(hDest,x,wr.top,w,h,mem2dc,0,0,SRCCOPY);

-							x+=w;

+							x += w;

 						}

-						if (x<=wr.right)

+						if (x <= wr.right)

 						BitBlt(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,SRCCOPY);  

 					}

 					else 

 					{

 						int dx;

-						dx=(wr.left-rFill->left)%w;

-						x=wr.left-dx;

-						while (x<wr.right-w){

+						dx = (wr.left-rFill->left)%w;

+						x = wr.left-dx;

+						while (x < wr.right-w){

 							ske_AlphaBlend(hDest,x,wr.top,w,h,mem2dc,0,0,w,h,bf);

-							x+=w;

+							x += w;

 						}

-						if (x<=wr.right)

+						if (x <= wr.right)

 							ske_AlphaBlend(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,wr.right-x,h,bf);

 					}

 

 				}

 				else

 				{

-					BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+					BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 					int dx;

-					dx=(wr.left-rFill->left)%w;

-					if (dx>=0)

+					dx = (wr.left-rFill->left)%w;

+					if (dx >= 0)

 					{

 						int wt;

-						x=wr.left;

-						wt=(x+w-dx<=wr.right)?(w-dx):(wr.right-wr.left); 

+						x = wr.left;

+						wt = (x+w-dx <= wr.right)?(w-dx):(wr.right-wr.left); 

 						ske_AlphaBlend(hDest,x,wr.top,wt,h,mem2dc,dx,0,wt,h,bf);

 					}

-					x=wr.left+w-dx;

-					while (x<wr.right-w){

+					x = wr.left+w-dx;

+					while (x < wr.right-w){

 						ske_AlphaBlend(hDest,x,wr.top,w,h,mem2dc,0,0,w,h,bf);

-						x+=w;

+						x += w;

 					}

-					if (x<=wr.right)

+					if (x <= wr.right)

 						ske_AlphaBlend(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,wr.right-x,h,bf);  

 

 				}

@@ -1014,20 +1014,20 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 		DeleteObject(mem2bmp);

 		mod_DeleteDC(mem2dc);

 	}

-	else if (mode==FM_TILE_BOTH && (rGlyph->right-rGlyph->left>0) && (rGlyph->bottom-rGlyph->top>0))

+	else if (mode == FM_TILE_BOTH && (rGlyph->right-rGlyph->left>0) && (rGlyph->bottom-rGlyph->top>0))

 	{

 		HDC mem2dc;

-		int w=rGlyph->right-rGlyph->left;

-		int  x=0, sy=0, maxy=0;

-		int h=rFill->bottom-rFill->top;

+		int w = rGlyph->right-rGlyph->left;

+		int  x = 0, sy = 0, maxy = 0;

+		int h = rFill->bottom-rFill->top;

 		HBITMAP mem2bmp,oldbmp;

 		RECT wr;

 		IntersectRect(&wr,rClip,rFill);

-		if ((wr.bottom-wr.top)*(wr.right-wr.left)==0) return 0;

-		mem2dc=CreateCompatibleDC(hDest);

-		mem2bmp=ske_CreateDIB32(w,wr.bottom-wr.top);

-		h=wr.bottom-wr.top;

-		oldbmp=(HBITMAP)SelectObject(mem2dc,mem2bmp);

+		if ((wr.bottom-wr.top)*(wr.right-wr.left) == 0) return 0;

+		mem2dc = CreateCompatibleDC(hDest);

+		mem2bmp = ske_CreateDIB32(w,wr.bottom-wr.top);

+		h = wr.bottom-wr.top;

+		oldbmp = (HBITMAP)SelectObject(mem2dc,mem2bmp);

 #ifdef _DEBUG

 		if (!oldbmp) 

 			(NULL,"Tile bitmap not selected","ERROR", MB_OK);

@@ -1039,72 +1039,72 @@ static BOOL ske_SkinFillRectByGlyph(HDC hDest, HDC hSource, RECT * rFill, RECT *
 			{

 				int y;

 				int dy;

-				dy=(wr.top-rFill->top)%(rGlyph->bottom-rGlyph->top);

-				y=-dy;

-				while (y<wr.bottom-wr.top)

+				dy = (wr.top-rFill->top)%(rGlyph->bottom-rGlyph->top);

+				y = -dy;

+				while (y < wr.bottom-wr.top)

 				{

 

 					ske_AlphaBlend(mem2dc,0,y,w,rGlyph->bottom-rGlyph->top, hSource,rGlyph->left,rGlyph->top,w,rGlyph->bottom-rGlyph->top,bf);                    

-					y+=rGlyph->bottom-rGlyph->top;

+					y += rGlyph->bottom-rGlyph->top;

 				}

 

 				//--    

 				//end temp bitmap

-				if (drawMode==0 || drawMode==2)

+				if (drawMode == 0 || drawMode == 2)

 				{

-					if (drawMode==0)

+					if (drawMode == 0)

 					{

 

 						int dx;

-						dx=(wr.left-rFill->left)%w;

-						if (dx>=0)

+						dx = (wr.left-rFill->left)%w;

+						if (dx >= 0)

 						{   

 							int wt;

-							x=wr.left;

-							wt=(x+w-dx<=wr.right)?(w-dx):(wr.right-wr.left);                                                   

+							x = wr.left;

+							wt = (x+w-dx <= wr.right)?(w-dx):(wr.right-wr.left);                                                   

 							BitBlt(hDest,x,wr.top,wt,h,mem2dc,dx,0,SRCCOPY);

 						}

-						x=wr.left+w-dx;                        

-						while (x<wr.right-w){

+						x = wr.left+w-dx;                        

+						while (x < wr.right-w){

 							BitBlt(hDest,x,wr.top,w,h,mem2dc,0,0,SRCCOPY);

-							x+=w;

+							x += w;

 						}

-						if (x<=wr.right)

+						if (x <= wr.right)

 						BitBlt(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,SRCCOPY);  

 					}

 					else 

 					{

 						int dx;

-						dx=(wr.left-rFill->left)%w;

-						x=wr.left-dx;

-						while (x<wr.right-w){

+						dx = (wr.left-rFill->left)%w;

+						x = wr.left-dx;

+						while (x < wr.right-w){

 							ske_AlphaBlend(hDest,x,wr.top,w,h,mem2dc,0,0,w,h,bf);

-							x+=w;

+							x += w;

 						}

-						if (x<=wr.right)

+						if (x <= wr.right)

 							ske_AlphaBlend(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,wr.right-x,h,bf);

 					}

 

 				}

 				else

 				{

-					BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+					BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 

 					int dx;

-					dx=(wr.left-rFill->left)%w;

-					if (dx>=0)

+					dx = (wr.left-rFill->left)%w;

+					if (dx >= 0)

 					{

 						int wt;

-						x=wr.left;

-						wt=(x+w-dx<=wr.right)?(w-dx):(wr.right-wr.left); 

+						x = wr.left;

+						wt = (x+w-dx <= wr.right)?(w-dx):(wr.right-wr.left); 

 						ske_AlphaBlend(hDest,x,wr.top,wt,h,mem2dc,dx,0,wt,h,bf);

 					}

-					x=wr.left+w-dx;

-					while (x<wr.right-w){

+					x = wr.left+w-dx;

+					while (x < wr.right-w){

 						ske_AlphaBlend(hDest,x,wr.top,w,h,mem2dc,0,0,w,h,bf);

-						x+=w;

+						x += w;

 					}

-					if (x<=wr.right)

+					if (x <= wr.right)

 						ske_AlphaBlend(hDest,x,wr.top,wr.right-x,h, mem2dc,0,0,wr.right-x,h,bf);  

 

 				}

@@ -1138,11 +1138,11 @@ HBITMAP ske_CreateDIB32Point(int cx, int cy, void ** bits)
 	}

 

 	ZeroMemory(&RGB32BitsBITMAPINFO,sizeof(BITMAPINFO));

-	RGB32BitsBITMAPINFO.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);

-	RGB32BitsBITMAPINFO.bmiHeader.biWidth=cx;//bm.bmWidth;

-	RGB32BitsBITMAPINFO.bmiHeader.biHeight=cy;//bm.bmHeight;

-	RGB32BitsBITMAPINFO.bmiHeader.biPlanes=1;

-	RGB32BitsBITMAPINFO.bmiHeader.biBitCount=32;

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

+	RGB32BitsBITMAPINFO.bmiHeader.biWidth = cx;//bm.bmWidth;

+	RGB32BitsBITMAPINFO.bmiHeader.biHeight = cy;//bm.bmHeight;

+	RGB32BitsBITMAPINFO.bmiHeader.biPlanes = 1;

+	RGB32BitsBITMAPINFO.bmiHeader.biBitCount = 32;

 	// pointer used for direct Bitmap pixels access

 

 

@@ -1151,7 +1151,7 @@ HBITMAP ske_CreateDIB32Point(int cx, int cy, void ** bits)
 		DIB_RGB_COLORS,

 		(void **)&ptPixels, 

 		NULL, 0);

-	if ((DirectBitmap == NULL || ptPixels == NULL) && cx!= 0 && cy!=0) 

+	if ((DirectBitmap == NULL || ptPixels == NULL) && cx != 0 && cy != 0) 

 	{

 #ifdef _DEBUG

 		MessageBoxA(NULL,"Object not allocated. Check GDI object count","ERROR",MB_OK|MB_ICONERROR); 

@@ -1160,7 +1160,7 @@ HBITMAP ske_CreateDIB32Point(int cx, int cy, void ** bits)
 		;

 	}

 	else	memset(ptPixels,0,cx*cy*4);

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

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

 	return DirectBitmap;

 }

 

@@ -1189,7 +1189,7 @@ HRGN ske_CreateOpaqueRgn(BYTE Level, bool Opaque)
 			inside = Opaque ? (buf->rgbReserved > Level) : (buf->rgbReserved < Level);

 			++buf;

 

-			if (inside != lastin)

+			if (inside !=lastin)

 			{

 				if (inside)

 				{

@@ -1229,44 +1229,44 @@ HRGN ske_CreateOpaqueRgn(BYTE Level, bool Opaque)
 

 static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)

 {

-	HDC memdc=NULL, glyphdc=NULL;

-	int k=0;

-	//BITMAP bmp={0};

-	HBITMAP membmp=0,oldbmp=0,oldglyph=0;

-	BYTE Is32Bit=0;

+	HDC memdc = NULL, glyphdc = NULL;

+	int k = 0;

+	//BITMAP bmp = {0};

+	HBITMAP membmp = 0,oldbmp = 0,oldglyph = 0;

+	BYTE Is32Bit = 0;

 	RECT PRect;

-	POINT mode2offset={0};

-	int depth=0; 

-	int mode=0; //0-FastDraw, 1-DirectAlphaDraw, 2-BufferedAlphaDraw

+	POINT mode2offset = {0};

+	int depth = 0; 

+	int mode = 0; //0-FastDraw, 1-DirectAlphaDraw, 2-BufferedAlphaDraw

 

 	if (!(preq && pobj)) return -1;

-	if ((!pobj->hGlyph || pobj->hGlyph==(HBITMAP)-1) && ((pobj->Style&7) ==ST_IMAGE ||(pobj->Style&7) ==ST_FRAGMENT|| (pobj->Style&7) ==ST_SOLARIZE)) return 0;

+	if ((!pobj->hGlyph || pobj->hGlyph == (HBITMAP)-1) && ((pobj->Style&7)  == ST_IMAGE ||(pobj->Style&7)  == ST_FRAGMENT|| (pobj->Style&7)  == ST_SOLARIZE)) return 0;

 	// Determine painting mode   

-	depth=GetDeviceCaps(preq->hDC,BITSPIXEL);

-	depth=depth<16?16:depth;

-	Is32Bit=pobj->bmBitsPixel==32;

-	if ((!Is32Bit && pobj->dwAlpha==255)&& pobj->Style!=ST_BRUSH) mode=0;

-	else if (pobj->dwAlpha==255 && pobj->Style!=ST_BRUSH) mode=1;

-	else mode=2;

+	depth = GetDeviceCaps(preq->hDC,BITSPIXEL);

+	depth = depth < 16?16:depth;

+	Is32Bit = pobj->bmBitsPixel == 32;

+	if ((!Is32Bit && pobj->dwAlpha == 255)&& pobj->Style != ST_BRUSH) mode = 0;

+	else if (pobj->dwAlpha == 255 && pobj->Style != ST_BRUSH) mode = 1;

+	else mode = 2;

 	// End painting mode

 

 	//force mode

 

-	if(preq->rcClipRect.bottom-preq->rcClipRect.top*preq->rcClipRect.right-preq->rcClipRect.left==0)

-		preq->rcClipRect=preq->rcDestRect;

+	if (preq->rcClipRect.bottom-preq->rcClipRect.top*preq->rcClipRect.right-preq->rcClipRect.left == 0)

+		preq->rcClipRect = preq->rcDestRect;

 	IntersectRect(&PRect,&preq->rcDestRect,&preq->rcClipRect);

 	if (IsRectEmpty(&PRect))

 	{

 		return 0;

 	}

-	if (mode==2)

+	if (mode == 2)

 	{   

-		memdc=CreateCompatibleDC(preq->hDC);

-		membmp=ske_CreateDIB32(PRect.right-PRect.left,PRect.bottom-PRect.top);

-		oldbmp=(HBITMAP)SelectObject(memdc,membmp);

-		if (oldbmp==NULL) 

+		memdc = CreateCompatibleDC(preq->hDC);

+		membmp = ske_CreateDIB32(PRect.right-PRect.left,PRect.bottom-PRect.top);

+		oldbmp = (HBITMAP)SelectObject(memdc,membmp);

+		if (oldbmp == NULL) 

 		{

-			if (mode==2)

+			if (mode == 2)

 			{

 				SelectObject(memdc,oldbmp);

 				mod_DeleteDC(memdc);

@@ -1276,24 +1276,24 @@ static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)
 		}

 	} 

 

-	if (mode!=2) memdc=preq->hDC;

+	if (mode != 2) memdc = preq->hDC;

 	{

-		if (pobj->hGlyph && pobj->hGlyph!=(HBITMAP)-1)

+		if (pobj->hGlyph && pobj->hGlyph != (HBITMAP)-1)

 		{

-			glyphdc=CreateCompatibleDC(preq->hDC);

+			glyphdc = CreateCompatibleDC(preq->hDC);

 			if (!oldglyph)

-				oldglyph=(HBITMAP)SelectObject(glyphdc,pobj->hGlyph);

+				oldglyph = (HBITMAP)SelectObject(glyphdc,pobj->hGlyph);

 			else 

 				SelectObject(glyphdc,pobj->hGlyph);

 		}

 		// Drawing

 		{    

 			RECT rFill, rGlyph, rClip;

-			if ((pobj->Style&7) ==ST_BRUSH)

+			if ((pobj->Style&7)  == ST_BRUSH)

 			{

-				HBRUSH br=CreateSolidBrush(pobj->dwColor);

+				HBRUSH br = CreateSolidBrush(pobj->dwColor);

 				RECT fr;

-				if (mode==2)

+				if (mode == 2)

 				{

 					SetRect(&fr,0,0,PRect.right-PRect.left,PRect.bottom-PRect.top);

 					FillRect(memdc,&fr,br);

@@ -1302,220 +1302,220 @@ static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)
 				}

 				else

 				{

-					fr=PRect;

+					fr = PRect;

 					// SetRect(&fr,0,0,PRect.right-PRect.left,PRect.bottom-PRect.top);

 					FillRect(preq->hDC,&fr,br);

 				}

 				DeleteObject(br);

-				k=-1;

+				k = -1;

 			}

 			else

 			{

-				if (mode==2)  

+				if (mode == 2)  

 				{

-					mode2offset.x=PRect.left;

-					mode2offset.y=PRect.top;

+					mode2offset.x = PRect.left;

+					mode2offset.y = PRect.top;

 					OffsetRect(&PRect,-mode2offset.x,-mode2offset.y);

 				}

-				rClip=(preq->rcClipRect);

+				rClip = (preq->rcClipRect);

 

 				{

-					int lft=0;

-					int top=0;

-					int rgh=pobj->bmWidth;

-					int btm=pobj->bmHeight;

-					if ((pobj->Style&7) ==ST_FRAGMENT)

+					int lft = 0;

+					int top = 0;

+					int rgh = pobj->bmWidth;

+					int btm = pobj->bmHeight;

+					if ((pobj->Style&7)  == ST_FRAGMENT)

 					{

-						lft=pobj->clipArea.x;

-						top=pobj->clipArea.y;

-						rgh=min(rgh,lft+pobj->szclipArea.cx);

-						btm=min(btm,top+pobj->szclipArea.cy);

+						lft = pobj->clipArea.x;

+						top = pobj->clipArea.y;

+						rgh = min(rgh,lft+pobj->szclipArea.cx);

+						btm = min(btm,top+pobj->szclipArea.cy);

 					}

 

 					// Draw center...

 					if (1)

 					{

-						rFill.top=preq->rcDestRect.top+pobj->dwTop;

-						rFill.bottom=preq->rcDestRect.bottom-pobj->dwBottom; 

-						rFill.left=preq->rcDestRect.left+pobj->dwLeft;

-						rFill.right=preq->rcDestRect.right-pobj->dwRight;

+						rFill.top = preq->rcDestRect.top+pobj->dwTop;

+						rFill.bottom = preq->rcDestRect.bottom-pobj->dwBottom; 

+						rFill.left = preq->rcDestRect.left+pobj->dwLeft;

+						rFill.right = preq->rcDestRect.right-pobj->dwRight;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

-						rGlyph.top=top+pobj->dwTop;

-						rGlyph.left=lft+pobj->dwLeft;

-						rGlyph.right=rgh-pobj->dwRight;

-						rGlyph.bottom=btm-pobj->dwBottom;

+						rGlyph.top = top+pobj->dwTop;

+						rGlyph.left = lft+pobj->dwLeft;

+						rGlyph.right = rgh-pobj->dwRight;

+						rGlyph.bottom = btm-pobj->dwBottom;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode,mode,depth);

 					}

 

 					// Draw top side...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.top;

-						rFill.bottom=preq->rcDestRect.top+pobj->dwTop; 

-						rFill.left=preq->rcDestRect.left+pobj->dwLeft;

-						rFill.right=preq->rcDestRect.right-pobj->dwRight;

+						rFill.top = preq->rcDestRect.top;

+						rFill.bottom = preq->rcDestRect.top+pobj->dwTop; 

+						rFill.left = preq->rcDestRect.left+pobj->dwLeft;

+						rFill.right = preq->rcDestRect.right-pobj->dwRight;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

-						rGlyph.top=top+0;

-						rGlyph.left=lft+pobj->dwLeft;

-						rGlyph.right=rgh-pobj->dwRight;

-						rGlyph.bottom=top+pobj->dwTop;

+						rGlyph.top = top+0;

+						rGlyph.left = lft+pobj->dwLeft;

+						rGlyph.right = rgh-pobj->dwRight;

+						rGlyph.bottom = top+pobj->dwTop;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_HORZ,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_HORZ,mode,depth);

 					}

 					// Draw bottom side...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.bottom-pobj->dwBottom;

-						rFill.bottom=preq->rcDestRect.bottom; 

-						rFill.left=preq->rcDestRect.left+pobj->dwLeft;

-						rFill.right=preq->rcDestRect.right-pobj->dwRight;

+						rFill.top = preq->rcDestRect.bottom-pobj->dwBottom;

+						rFill.bottom = preq->rcDestRect.bottom; 

+						rFill.left = preq->rcDestRect.left+pobj->dwLeft;

+						rFill.right = preq->rcDestRect.right-pobj->dwRight;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.top=btm-pobj->dwBottom;

-						rGlyph.left=lft+pobj->dwLeft;

-						rGlyph.right=rgh-pobj->dwRight;

-						rGlyph.bottom=btm;

+						rGlyph.top = btm-pobj->dwBottom;

+						rGlyph.left = lft+pobj->dwLeft;

+						rGlyph.right = rgh-pobj->dwRight;

+						rGlyph.bottom = btm;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_HORZ,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_HORZ,mode,depth);

 					}

 					// Draw left side...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.top+pobj->dwTop;

-						rFill.bottom=preq->rcDestRect.bottom-pobj->dwBottom; 

-						rFill.left=preq->rcDestRect.left;

-						rFill.right=preq->rcDestRect.left+pobj->dwLeft;

+						rFill.top = preq->rcDestRect.top+pobj->dwTop;

+						rFill.bottom = preq->rcDestRect.bottom-pobj->dwBottom; 

+						rFill.left = preq->rcDestRect.left;

+						rFill.right = preq->rcDestRect.left+pobj->dwLeft;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.top=top+pobj->dwTop;

-						rGlyph.left=lft;

-						rGlyph.right=lft+pobj->dwLeft;

-						rGlyph.bottom=btm-pobj->dwBottom;

+						rGlyph.top = top+pobj->dwTop;

+						rGlyph.left = lft;

+						rGlyph.right = lft+pobj->dwLeft;

+						rGlyph.bottom = btm-pobj->dwBottom;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_VERT,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_VERT,mode,depth);

 					}

 

 					// Draw right side...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.top+pobj->dwTop;

-						rFill.bottom=preq->rcDestRect.bottom-pobj->dwBottom; 

-						rFill.left=preq->rcDestRect.right-pobj->dwRight;

-						rFill.right=preq->rcDestRect.right;

+						rFill.top = preq->rcDestRect.top+pobj->dwTop;

+						rFill.bottom = preq->rcDestRect.bottom-pobj->dwBottom; 

+						rFill.left = preq->rcDestRect.right-pobj->dwRight;

+						rFill.right = preq->rcDestRect.right;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.top=top+pobj->dwTop;

-						rGlyph.left=rgh-pobj->dwRight;

-						rGlyph.right=rgh;

-						rGlyph.bottom=btm-pobj->dwBottom;

+						rGlyph.top = top+pobj->dwTop;

+						rGlyph.left = rgh-pobj->dwRight;

+						rGlyph.right = rgh;

+						rGlyph.bottom = btm-pobj->dwBottom;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_VERT,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,pobj->FitMode&FM_TILE_VERT,mode,depth);

 					}

 

 

 					// Draw Top-Left corner...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.top;

-						rFill.bottom=preq->rcDestRect.top+pobj->dwTop; 

-						rFill.left=preq->rcDestRect.left;

-						rFill.right=preq->rcDestRect.left+pobj->dwLeft;

+						rFill.top = preq->rcDestRect.top;

+						rFill.bottom = preq->rcDestRect.top+pobj->dwTop; 

+						rFill.left = preq->rcDestRect.left;

+						rFill.right = preq->rcDestRect.left+pobj->dwLeft;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.top=top;

-						rGlyph.left=lft;

-						rGlyph.right=lft+pobj->dwLeft;

-						rGlyph.bottom=top+pobj->dwTop;

+						rGlyph.top = top;

+						rGlyph.left = lft;

+						rGlyph.right = lft+pobj->dwLeft;

+						rGlyph.bottom = top+pobj->dwTop;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

 					}

 					// Draw Top-Right corner...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.top;

-						rFill.bottom=preq->rcDestRect.top+pobj->dwTop; 

-						rFill.left=preq->rcDestRect.right-pobj->dwRight;

-						rFill.right=preq->rcDestRect.right;

+						rFill.top = preq->rcDestRect.top;

+						rFill.bottom = preq->rcDestRect.top+pobj->dwTop; 

+						rFill.left = preq->rcDestRect.right-pobj->dwRight;

+						rFill.right = preq->rcDestRect.right;

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.top=top;

-						rGlyph.left=rgh-pobj->dwRight;

-						rGlyph.right=rgh;

-						rGlyph.bottom=top+pobj->dwTop;

+						rGlyph.top = top;

+						rGlyph.left = rgh-pobj->dwRight;

+						rGlyph.right = rgh;

+						rGlyph.bottom = top+pobj->dwTop;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

 					}

 

 					// Draw Bottom-Left corner...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.bottom-pobj->dwBottom;

-						rFill.bottom=preq->rcDestRect.bottom; 

-						rFill.left=preq->rcDestRect.left;

-						rFill.right=preq->rcDestRect.left+pobj->dwLeft;

+						rFill.top = preq->rcDestRect.bottom-pobj->dwBottom;

+						rFill.bottom = preq->rcDestRect.bottom; 

+						rFill.left = preq->rcDestRect.left;

+						rFill.right = preq->rcDestRect.left+pobj->dwLeft;

 

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

 

-						rGlyph.left=lft;

-						rGlyph.right=lft+pobj->dwLeft; 

-						rGlyph.top=btm-pobj->dwBottom;

-						rGlyph.bottom=btm;

+						rGlyph.left = lft;

+						rGlyph.right = lft+pobj->dwLeft; 

+						rGlyph.top = btm-pobj->dwBottom;

+						rGlyph.bottom = btm;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

 					}

 					// Draw Bottom-Right corner...

-					if(1)

+					if (1)

 					{

-						rFill.top=preq->rcDestRect.bottom-pobj->dwBottom;

-						rFill.bottom=preq->rcDestRect.bottom;

-						rFill.left=preq->rcDestRect.right-pobj->dwRight;

-						rFill.right=preq->rcDestRect.right;

+						rFill.top = preq->rcDestRect.bottom-pobj->dwBottom;

+						rFill.bottom = preq->rcDestRect.bottom;

+						rFill.left = preq->rcDestRect.right-pobj->dwRight;

+						rFill.right = preq->rcDestRect.right;

 

 

-						if (mode==2)

+						if (mode == 2)

 							OffsetRect(&rFill,-mode2offset.x,-mode2offset.y);

 

-						rGlyph.left=rgh-pobj->dwRight;

-						rGlyph.right=rgh;

-						rGlyph.top=btm-pobj->dwBottom;

-						rGlyph.bottom=btm;

+						rGlyph.left = rgh-pobj->dwRight;

+						rGlyph.right = rgh;

+						rGlyph.top = btm-pobj->dwBottom;

+						rGlyph.bottom = btm;

 

-						k+=ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

+						k += ske_SkinFillRectByGlyph(memdc,glyphdc,&rFill,&rGlyph,&PRect,0,mode,depth);

 					}

 				}

 

 			}

 

-			if ((k>0 || k==-1) && mode==2)

+			if ((k>0 || k == -1) && mode == 2)

 			{            

 				{

-					BLENDFUNCTION bf={AC_SRC_OVER, 0, /*(bm.bmBitsPixel==32)?255:*/pobj->dwAlpha, (pobj->bmBitsPixel==32 && pobj->Style!=ST_BRUSH)?AC_SRC_ALPHA:0};

-					if (mode==2)

+					BLENDFUNCTION bf = {AC_SRC_OVER, 0, /*(bm.bmBitsPixel == 32)?255:*/pobj->dwAlpha, (pobj->bmBitsPixel == 32 && pobj->Style != ST_BRUSH)?AC_SRC_ALPHA:0};

+					if (mode == 2)

 						OffsetRect(&PRect,mode2offset.x,mode2offset.y);

 					ske_AlphaBlend( preq->hDC,PRect.left,PRect.top,PRect.right-PRect.left,PRect.bottom-PRect.top, 

 						memdc,0,0,PRect.right-PRect.left,PRect.bottom-PRect.top,bf);

@@ -1531,7 +1531,7 @@ static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)
 			if (oldglyph) SelectObject(glyphdc,oldglyph);

 			if (glyphdc) mod_DeleteDC(glyphdc);

 		}    

-		if (mode==2)

+		if (mode == 2)

 		{

 			SelectObject(memdc,oldbmp);

 			mod_DeleteDC(memdc);

@@ -1543,49 +1543,49 @@ static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)
 	{

 		int i;

 		HFONT hOldFont;

-		for (i=0; i<pobj->plTextList->realCount; i++)

+		for (i = 0; i < pobj->plTextList->realCount; i++)

 		{

-			GLYPHTEXT * gt=(GLYPHTEXT *)pobj->plTextList->items[i];

+			GLYPHTEXT * gt = (GLYPHTEXT *)pobj->plTextList->items[i];

 			if (!gt->hFont)

 			{

 				if (gl_plSkinFonts && gl_plSkinFonts->realCount>0)

 				{

-					int j=0;

-					for (j=0; j<gl_plSkinFonts->realCount; j++)

+					int j = 0;

+					for (j = 0; j < gl_plSkinFonts->realCount; j++)

 					{

 						SKINFONT * sf;

-						sf=(SKINFONT*)gl_plSkinFonts->items[j];

+						sf = (SKINFONT*)gl_plSkinFonts->items[j];

 						if (sf->szFontID && !strcmp(sf->szFontID,gt->szFontID))

 						{

-							gt->hFont=sf->hFont;

+							gt->hFont = sf->hFont;

 							break;

 						}

 					}

 				}

-				if (!gt->hFont) gt->hFont=(HFONT)-1;

+				if (!gt->hFont) gt->hFont = (HFONT)-1;

 			}

-			if (gt->hFont!=(HFONT)-1)

+			if (gt->hFont != (HFONT)-1)

 			{

-				RECT rc={0};

-				hOldFont=(HFONT)SelectObject(preq->hDC,gt->hFont);

+				RECT rc = {0};

+				hOldFont = (HFONT)SelectObject(preq->hDC,gt->hFont);

 

 

 

-				if (gt->RelativeFlags&2) rc.left=preq->rcDestRect.right+gt->iLeft;

-				else if (gt->RelativeFlags&1) rc.left=((preq->rcDestRect.right-preq->rcDestRect.left)>>1)+gt->iLeft;

-				else rc.left=preq->rcDestRect.left+gt->iLeft;

+				if (gt->RelativeFlags&2) rc.left = preq->rcDestRect.right+gt->iLeft;

+				else if (gt->RelativeFlags&1) rc.left = ((preq->rcDestRect.right-preq->rcDestRect.left)>>1)+gt->iLeft;

+				else rc.left = preq->rcDestRect.left+gt->iLeft;

 

-				if (gt->RelativeFlags&8) rc.top=preq->rcDestRect.bottom+gt->iTop;

-				else if (gt->RelativeFlags&4) rc.top=((preq->rcDestRect.bottom-preq->rcDestRect.top)>>1)+gt->iTop;

-				else rc.top=preq->rcDestRect.top+gt->iTop;

+				if (gt->RelativeFlags&8) rc.top = preq->rcDestRect.bottom+gt->iTop;

+				else if (gt->RelativeFlags&4) rc.top = ((preq->rcDestRect.bottom-preq->rcDestRect.top)>>1)+gt->iTop;

+				else rc.top = preq->rcDestRect.top+gt->iTop;

 

-				if (gt->RelativeFlags&32) rc.right=preq->rcDestRect.right+gt->iRight;

-				else if (gt->RelativeFlags&16) rc.right=((preq->rcDestRect.right-preq->rcDestRect.left)>>1)+gt->iRight;

-				else rc.right=preq->rcDestRect.left+gt->iRight;

+				if (gt->RelativeFlags&32) rc.right = preq->rcDestRect.right+gt->iRight;

+				else if (gt->RelativeFlags&16) rc.right = ((preq->rcDestRect.right-preq->rcDestRect.left)>>1)+gt->iRight;

+				else rc.right = preq->rcDestRect.left+gt->iRight;

 

-				if (gt->RelativeFlags&128) rc.bottom=preq->rcDestRect.bottom+gt->iBottom;

-				else if (gt->RelativeFlags&64) rc.bottom=((preq->rcDestRect.bottom-preq->rcDestRect.top)>>1)+gt->iBottom;

-				else rc.bottom=preq->rcDestRect.top+gt->iBottom;

+				if (gt->RelativeFlags&128) rc.bottom = preq->rcDestRect.bottom+gt->iBottom;

+				else if (gt->RelativeFlags&64) rc.bottom = ((preq->rcDestRect.bottom-preq->rcDestRect.top)>>1)+gt->iBottom;

+				else rc.bottom = preq->rcDestRect.top+gt->iBottom;

 

 				ske_AlphaTextOut(preq->hDC, gt->stText, -1, &rc,gt->dwFlags, gt->dwColor);

 				SelectObject(preq->hDC,hOldFont);

@@ -1601,44 +1601,44 @@ static int ske_DrawSkinObject(SKINDRAWREQUEST * preq, GLYPHOBJECT * pobj)
 int ske_AddDescriptorToSkinObjectList (LPSKINOBJECTDESCRIPTOR lpDescr, SKINOBJECTSLIST* Skin)

 {

 	SKINOBJECTSLIST *sk;

-	if (Skin) sk=Skin; else sk=&g_SkinObjectList;

+	if (Skin) sk = Skin; else sk = &g_SkinObjectList;

 	if (!sk) return 0;

 	if (mir_bool_strcmpi(lpDescr->szObjectID,"_HEADER_")) return 0;

 	{//check if new object allready presents.

-		DWORD i=0;

-		for (i=0; i<sk->dwObjLPAlocated;i++)

+		DWORD i = 0;

+		for (i = 0; i < sk->dwObjLPAlocated;i++)

 			if (!mir_strcmp(sk->pObjects[i].szObjectID,lpDescr->szObjectID)) return 0;

 	}

 	if (sk->dwObjLPAlocated+1>sk->dwObjLPReserved)

 	{ // Realocated list to add space for new object

 

-		sk->pObjects=(SKINOBJECTDESCRIPTOR*)mir_realloc(sk->pObjects,sizeof(SKINOBJECTDESCRIPTOR)*(sk->dwObjLPReserved+1)/*alloc step*/);

+		sk->pObjects = (SKINOBJECTDESCRIPTOR*)mir_realloc(sk->pObjects,sizeof(SKINOBJECTDESCRIPTOR)*(sk->dwObjLPReserved+1)/*alloc step*/);

 		sk->dwObjLPReserved++; 

 	}

 	{ //filling new objects field

-		sk->pObjects[sk->dwObjLPAlocated].bType=lpDescr->bType;

-		sk->pObjects[sk->dwObjLPAlocated].Data=NULL;

-		sk->pObjects[sk->dwObjLPAlocated].szObjectID=mir_strdup(lpDescr->szObjectID);

-		//  sk->Objects[sk->dwObjLPAlocated].szObjectName=mir_strdup(lpDescr->szObjectName);

-		if (lpDescr->Data!=NULL)

+		sk->pObjects[sk->dwObjLPAlocated].bType = lpDescr->bType;

+		sk->pObjects[sk->dwObjLPAlocated].Data = NULL;

+		sk->pObjects[sk->dwObjLPAlocated].szObjectID = mir_strdup(lpDescr->szObjectID);

+		//  sk->Objects[sk->dwObjLPAlocated].szObjectName = mir_strdup(lpDescr->szObjectName);

+		if (lpDescr->Data != NULL)

 		{   //Copy defaults values

 			switch (lpDescr->bType) 

 			{

 			case OT_GLYPHOBJECT:

 				{   

 					GLYPHOBJECT * obdat;

-					GLYPHOBJECT * gl=(GLYPHOBJECT*)lpDescr->Data;

-					sk->pObjects[sk->dwObjLPAlocated].Data=mir_alloc(sizeof(GLYPHOBJECT));

-					obdat=(GLYPHOBJECT*)sk->pObjects[sk->dwObjLPAlocated].Data;

+					GLYPHOBJECT * gl = (GLYPHOBJECT*)lpDescr->Data;

+					sk->pObjects[sk->dwObjLPAlocated].Data = mir_alloc(sizeof(GLYPHOBJECT));

+					obdat = (GLYPHOBJECT*)sk->pObjects[sk->dwObjLPAlocated].Data;

 					memmove(obdat,gl,sizeof(GLYPHOBJECT));

-					if (gl->szFileName!=NULL)                    

+					if (gl->szFileName != NULL)                    

 					{

-						obdat->szFileName=mir_strdup(gl->szFileName);

+						obdat->szFileName = mir_strdup(gl->szFileName);

 						mir_free_and_nill(gl->szFileName);

 					}

 					else

-						obdat->szFileName=NULL;

-					obdat->hGlyph=NULL;

+						obdat->szFileName = NULL;

+					obdat->hGlyph = NULL;

 					break;

 				}

 			}

@@ -1653,7 +1653,7 @@ static LPSKINOBJECTDESCRIPTOR ske_FindObject(const char * szName, BYTE objType,
 {

 	// DWORD i;

 	SKINOBJECTSLIST* sk;

-	sk=(Skin==NULL)?(&g_SkinObjectList):Skin;

+	sk = (Skin == NULL)?(&g_SkinObjectList):Skin;

 	return skin_FindObjectByRequest((char *)szName,sk->pMaskList);

 }

 

@@ -1661,7 +1661,7 @@ static LPSKINOBJECTDESCRIPTOR ske_FindObjectByMask(MODERNMASK * pModernMask, BYT
 {

 	// DWORD i;

 	SKINOBJECTSLIST* sk;

-	sk=(Skin==NULL)?(&g_SkinObjectList):Skin;

+	sk = (Skin == NULL)?(&g_SkinObjectList):Skin;

 	if (!sk->pMaskList) return NULL;

 	return skin_FindObjectByMask(pModernMask,sk->pMaskList);

 }

@@ -1670,10 +1670,10 @@ LPSKINOBJECTDESCRIPTOR ske_FindObjectByName(const char * szName, BYTE objType, S
 {

 	DWORD i;

 	SKINOBJECTSLIST* sk;

-	sk=(Skin==NULL)?(&g_SkinObjectList):Skin;

-	for (i=0; i<sk->dwObjLPAlocated; i++)

+	sk = (Skin == NULL)?(&g_SkinObjectList):Skin;

+	for (i = 0; i < sk->dwObjLPAlocated; i++)

 	{

-		if (sk->pObjects[i].bType==objType || objType==OT_ANY)

+		if (sk->pObjects[i].bType == objType || objType == OT_ANY)

 		{

 			if (!mir_strcmp(sk->pObjects[i].szObjectID,szName))

 				return &(sk->pObjects[i]);

@@ -1697,32 +1697,32 @@ INT_PTR ske_Service_DrawGlyph(WPARAM wParam,LPARAM lParam)
 	ske_LockSkin();

 	__try

 	{

-		preq=(LPSKINDRAWREQUEST)wParam;   

+		preq = (LPSKINDRAWREQUEST)wParam;   

 		if (lParam)

-			pgl=ske_FindObjectByMask((MODERNMASK*)lParam, OT_GLYPHOBJECT,NULL);

+			pgl = ske_FindObjectByMask((MODERNMASK*)lParam, OT_GLYPHOBJECT,NULL);

 		else

-			pgl=ske_FindObject(preq->szObjectID, OT_GLYPHOBJECT,NULL);

-		if (pgl==NULL) return -1;

-		if (pgl->Data==NULL) return -1;

-		gl= (LPGLYPHOBJECT)pgl->Data;

-		if ((gl->Style&7) ==ST_SKIP) return ST_SKIP;

-		if (gl->hGlyph==NULL && gl->hGlyph!=(HBITMAP)-1 &&

-			(  (gl->Style&7)==ST_IMAGE 

-			||(gl->Style&7)==ST_FRAGMENT 

-			||(gl->Style&7)==ST_SOLARIZE ))

+			pgl = ske_FindObject(preq->szObjectID, OT_GLYPHOBJECT,NULL);

+		if (pgl == NULL) return -1;

+		if (pgl->Data == NULL) return -1;

+		gl = (LPGLYPHOBJECT)pgl->Data;

+		if ((gl->Style&7)  == ST_SKIP) return ST_SKIP;

+		if (gl->hGlyph == NULL && gl->hGlyph != (HBITMAP)-1 &&

+			(  (gl->Style&7) == ST_IMAGE 

+			||(gl->Style&7) == ST_FRAGMENT 

+			||(gl->Style&7) == ST_SOLARIZE ))

 			if (gl->szFileName) 

 			{

-				gl->hGlyph=ske_LoadGlyphImage(gl->szFileName);

+				gl->hGlyph = ske_LoadGlyphImage(gl->szFileName);

 				if (gl->hGlyph)

 				{

-					BITMAP bmp={0};

+					BITMAP bmp = {0};

 					GetObject(gl->hGlyph,sizeof(BITMAP),&bmp);

-					gl->bmBitsPixel=(BYTE)bmp.bmBitsPixel;

-					gl->bmHeight=bmp.bmHeight;

-					gl->bmWidth=bmp.bmWidth;

+					gl->bmBitsPixel = (BYTE)bmp.bmBitsPixel;

+					gl->bmHeight = bmp.bmHeight;

+					gl->bmWidth = bmp.bmWidth;

 				}

 				else

-					gl->hGlyph=(HBITMAP)-1; //invalid

+					gl->hGlyph = (HBITMAP)-1; //invalid

 			}

 			return ske_DrawSkinObject(preq,gl);

 	}

@@ -1737,45 +1737,45 @@ INT_PTR ske_Service_DrawGlyph(WPARAM wParam,LPARAM lParam)
 void ske_PreMultiplyChanells(HBITMAP hbmp,BYTE Mult)

 {

 	BITMAP bmp;     

-	BOOL flag=FALSE;

+	BOOL flag = FALSE;

 	BYTE * pBitmapBits;

 	DWORD Len;

 	int bh,bw,y,x;

 

 	GetObject(hbmp, sizeof(BITMAP), (LPSTR)&bmp);

-	bh=bmp.bmHeight;

-	bw=bmp.bmWidth;

-	Len=bh*bw*4;

-	flag=(bmp.bmBits==NULL);

+	bh = bmp.bmHeight;

+	bw = bmp.bmWidth;

+	Len = bh*bw*4;

+	flag = (bmp.bmBits == NULL);

 	if (flag)

 	{

-		pBitmapBits=(LPBYTE)malloc(Len);

+		pBitmapBits = (LPBYTE)malloc(Len);

 		GetBitmapBits(hbmp,Len,pBitmapBits);

 	}

 	else 

-		pBitmapBits=(BYTE*)bmp.bmBits;

-	for (y=0; y<bh; ++y)

+		pBitmapBits = (BYTE*)bmp.bmBits;

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

 	{

-		BYTE *pPixel= pBitmapBits + bw * 4 * y;

+		BYTE *pPixel = pBitmapBits + bw * 4 * y;

 

-		for (x=0; x<bw ; ++x)

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

 		{

 			if (Mult)

 			{

-				pPixel[0]= pPixel[0]*pPixel[3]/255;

-				pPixel[1]= pPixel[1]*pPixel[3]/255;

-				pPixel[2]= pPixel[2]*pPixel[3]/255;

+				pPixel[0] = pPixel[0]*pPixel[3]/255;

+				pPixel[1] = pPixel[1]*pPixel[3]/255;

+				pPixel[2] = pPixel[2]*pPixel[3]/255;

 			}

 			else

 			{

-				pPixel[3]=255;

+				pPixel[3] = 255;

 			}

-			pPixel+= 4;

+			pPixel += 4;

 		}

 	}

 	if (flag)

 	{

-		Len=SetBitmapBits(hbmp,Len,pBitmapBits);

+		Len = SetBitmapBits(hbmp,Len,pBitmapBits);

 		free (pBitmapBits);

 	}

 	return;

@@ -1783,22 +1783,22 @@ void ske_PreMultiplyChanells(HBITMAP hbmp,BYTE Mult)
 

 int ske_GetFullFilename(char * buf, char *file, char * skinfolder,BOOL madeAbsolute)

 {

-	char b2[MAX_PATH]={0};

-	char *SkinPlace= db_get_sa(NULL,SKIN,"SkinFolder");

-	if (!SkinPlace) SkinPlace=mir_strdup("\\Skin\\default");

-	if (file[0]!='\\' && file[1]!=':') 

-		_snprintf(b2, MAX_PATH,"%s\\%s",(skinfolder==NULL)?SkinPlace:((INT_PTR)skinfolder!=-1)?skinfolder:"",file);

+	char b2[MAX_PATH] = {0};

+	char *SkinPlace = db_get_sa(NULL,SKIN,"SkinFolder");

+	if (!SkinPlace) SkinPlace = mir_strdup("\\Skin\\default");

+	if (file[0] != '\\' && file[1] != ':') 

+		_snprintf(b2, MAX_PATH,"%s\\%s",(skinfolder == NULL)?SkinPlace:((INT_PTR)skinfolder != -1)?skinfolder:"",file);

 	else

 		_snprintf(b2, MAX_PATH,"%s",file);

 	if (madeAbsolute) 

-		if (b2[0]=='\\' && b2[1]!='\\')

+		if (b2[0] == '\\' && b2[1] != '\\')

 			CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)(b2+1), (LPARAM)buf);

 		else

 			CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)(b2), (LPARAM)buf);

 	else

 		memcpy(buf,b2,MAX_PATH);

 

-	if(SkinPlace) mir_free_and_nill(SkinPlace);

+	if (SkinPlace) mir_free_and_nill(SkinPlace);

 	return 0;

 }

 

@@ -1818,34 +1818,34 @@ Major part of routines is from http://tfcduke.developpez.com/tutoriel/format/tga
 

 static BOOL ske_ReadTGAImageData(void * From, DWORD fromSize, BYTE * destBuf, DWORD bufSize, BOOL RLE)

 {

-	BYTE * pos=destBuf;

-	BYTE * from=fromSize?(BYTE*)From:NULL;

-	FILE * fp=!fromSize?(FILE*)From:NULL;

-	DWORD destCount=0;

-	DWORD fromCount=0;

+	BYTE * pos = destBuf;

+	BYTE * from = fromSize?(BYTE*)From:NULL;

+	FILE * fp = !fromSize?(FILE*)From:NULL;

+	DWORD destCount = 0;

+	DWORD fromCount = 0;

 	if (!RLE)

 	{

-		while (((from&&fromCount<fromSize) || (fp&& fromCount<bufSize))

-			&&(destCount<bufSize))

+		while (((from&&fromCount < fromSize) || (fp&& fromCount < bufSize))

+			&&(destCount < bufSize))

 		{

-			BYTE r=from?from[fromCount++]:(BYTE)fgetc(fp);

-			BYTE g=from?from[fromCount++]:(BYTE)fgetc(fp);

-			BYTE b=from?from[fromCount++]:(BYTE)fgetc(fp);

-			BYTE a=from?from[fromCount++]:(BYTE)fgetc(fp);

-			pos[destCount++]=r;

-			pos[destCount++]=g;

-			pos[destCount++]=b;

-			pos[destCount++]=a;

+			BYTE r = from?from[fromCount++]:(BYTE)fgetc(fp);

+			BYTE g = from?from[fromCount++]:(BYTE)fgetc(fp);

+			BYTE b = from?from[fromCount++]:(BYTE)fgetc(fp);

+			BYTE a = from?from[fromCount++]:(BYTE)fgetc(fp);

+			pos[destCount++] = r;

+			pos[destCount++] = g;

+			pos[destCount++] = b;

+			pos[destCount++] = a;

 

 			if (destCount>bufSize) break;

-			if (from) 	if (fromCount<fromSize) break;

+			if (from) 	if (fromCount < fromSize) break;

 		}

 	}

 	else

 	{

 		BYTE rgba[4];

 		BYTE packet_header;

-		BYTE *ptr=pos;

+		BYTE *ptr = pos;

 		BYTE size;

 		int i;

 		while (ptr < pos + bufSize)

@@ -1859,11 +1859,11 @@ static BOOL ske_ReadTGAImageData(void * From, DWORD fromSize, BYTE * destBuf, DW
 				/* run-length packet */

 				if (from) 

 				{

-					*((DWORD*)rgba)=*((DWORD*)(from+fromCount));

-					fromCount+=4;

+					*((DWORD*)rgba) = *((DWORD*)(from+fromCount));

+					fromCount += 4;

 				}

 				else fread (rgba, sizeof (BYTE), 4, fp);

-				for (i = 0; i < size; ++i, ptr += 4)

+				for (i = 0; i < size; ++i, ptr  += 4)

 				{

 					ptr[2] = rgba[2];

 					ptr[1] = rgba[1];

@@ -1873,7 +1873,7 @@ static BOOL ske_ReadTGAImageData(void * From, DWORD fromSize, BYTE * destBuf, DW
 			}

 			else

 			{	/* not run-length packet */

-				for (i = 0; i < size; ++i, ptr += 4)

+				for (i = 0; i < size; ++i, ptr  += 4)

 				{

 					ptr[0] = from? from[fromCount++]:(BYTE)fgetc (fp);

 					ptr[1] = from? from[fromCount++]:(BYTE)fgetc (fp);

@@ -1889,8 +1889,8 @@ static BOOL ske_ReadTGAImageData(void * From, DWORD fromSize, BYTE * destBuf, DW
 static HBITMAP ske_LoadGlyphImage_TGA(char * szFilename)

 {

 	BYTE *colormap = NULL;

-	int cx=0,cy=0;

-	BOOL err=FALSE;

+	int cx = 0,cy = 0;

+	BOOL err = FALSE;

 	tga_header_t header;

 	if (!szFilename) return NULL;

 	if (!wildcmpi(szFilename,"*\\*%.tga")) 

@@ -1905,8 +1905,8 @@ static HBITMAP ske_LoadGlyphImage_TGA(char * szFilename)
 		}

 		/* read header */

 		fread (&header, sizeof (tga_header_t), 1, fp);

-		if (  (header.pixel_depth!=32)

-			||((header.image_type!=10)&&(header.image_type!=2))

+		if (  (header.pixel_depth != 32)

+			||((header.image_type != 10)&&(header.image_type != 2))

 			)

 		{

 			fclose(fp);

@@ -1914,12 +1914,12 @@ static HBITMAP ske_LoadGlyphImage_TGA(char * szFilename)
 		}

 

 		/*memory allocation */

-		colormap=(BYTE*)malloc(header.width*header.height*4);	

-		cx=header.width;

-		cy=header.height;

+		colormap = (BYTE*)malloc(header.width*header.height*4);	

+		cx = header.width;

+		cy = header.height;

 		fseek (fp, header.id_lenght, SEEK_CUR);

 		fseek (fp, header.cm_length, SEEK_CUR);

-		err=!ske_ReadTGAImageData((void*)fp, 0, colormap, header.width*header.height*4,header.image_type==10);

+		err = !ske_ReadTGAImageData((void*)fp, 0, colormap, header.width*header.height*4,header.image_type == 10);

 		fclose(fp);

 	}

 

@@ -1927,24 +1927,24 @@ static HBITMAP ske_LoadGlyphImage_TGA(char * szFilename)
 	else 

 	{

 		/* reading from resources IDR_TGA_DEFAULT_SKIN */

-		DWORD size=0;

+		DWORD size = 0;

 		BYTE * mem;

 		HGLOBAL hRes;

-		HRSRC hRSrc=FindResourceA(g_hInst,MAKEINTRESOURCEA(IDR_TGA_DEFAULT_SKIN),"TGA");

+		HRSRC hRSrc = FindResourceA(g_hInst,MAKEINTRESOURCEA(IDR_TGA_DEFAULT_SKIN),"TGA");

 		if (!hRSrc) return NULL;

-		hRes=LoadResource(g_hInst,hRSrc);

+		hRes = LoadResource(g_hInst,hRSrc);

 		if (!hRes) return NULL;

-		size=SizeofResource(g_hInst,hRSrc);

-		mem=(BYTE*) LockResource(hRes);

+		size = SizeofResource(g_hInst,hRSrc);

+		mem = (BYTE*) LockResource(hRes);

 		if (size>sizeof(header))

 		{

-			tga_header_t * header=(tga_header_t *)mem;

-			if (header->pixel_depth==32&& (header->image_type==2 ||header->image_type==10))

+			tga_header_t * header = (tga_header_t *)mem;

+			if (header->pixel_depth == 32&& (header->image_type == 2 ||header->image_type == 10))

 			{

-				colormap=(BYTE*)malloc(header->width*header->height*4);	

-				cx=header->width;

-				cy=header->height;

-				ske_ReadTGAImageData((void*)(mem+sizeof(tga_header_t)+header->id_lenght+header->cm_length), size-(sizeof(tga_header_t)+header->id_lenght+header->cm_length), colormap, cx*cy*4,header->image_type==10);

+				colormap = (BYTE*)malloc(header->width*header->height*4);	

+				cx = header->width;

+				cy = header->height;

+				ske_ReadTGAImageData((void*)(mem+sizeof(tga_header_t)+header->id_lenght+header->cm_length), size-(sizeof(tga_header_t)+header->id_lenght+header->cm_length), colormap, cx*cy*4,header->image_type == 10);

 			}

 		}

 		FreeResource(hRes);

@@ -1952,7 +1952,7 @@ static HBITMAP ske_LoadGlyphImage_TGA(char * szFilename)
 	if (colormap)  //create dib section

 	{

 		BYTE * pt;

-		HBITMAP hbmp=ske_CreateDIB32Point(cx,cy,(void**)&pt);

+		HBITMAP hbmp = ske_CreateDIB32Point(cx,cy,(void**)&pt);

 		if (hbmp) memcpy(pt,colormap,cx*cy*4);

 		free(colormap);

 		return hbmp;

@@ -1977,12 +1977,12 @@ HBITMAP ske_LoadGlyphImage_Png2Dib(char * szFilename)
 			return (HBITMAP)NULL;

 		}

 

-		if (( hFile = CreateFileA( szFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL )) != INVALID_HANDLE_VALUE )

-			if (( hMap = CreateFileMapping( hFile, NULL, PAGE_READONLY, 0, 0, NULL )) != NULL )

-				if (( ppMap = ( BYTE* )MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 )) != NULL )

+		if (( hFile = CreateFileA( szFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL )) !=INVALID_HANDLE_VALUE )

+			if (( hMap = CreateFileMapping( hFile, NULL, PAGE_READONLY, 0, 0, NULL )) !=NULL )

+				if (( ppMap = ( BYTE* )MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 )) !=NULL )

 					cbFileSize = GetFileSize( hFile, NULL );

 

-		if ( cbFileSize != 0 ) {

+		if ( cbFileSize !=0 ) {

 			PNG2DIB param;

 			param.pSource = ppMap;

 			param.cbSourceSize = cbFileSize;

@@ -1993,18 +1993,18 @@ HBITMAP ske_LoadGlyphImage_Png2Dib(char * szFilename)
 				cbFileSize = 0;

 		}

 

-		if ( ppMap != NULL )	UnmapViewOfFile( ppMap );

-		if ( hMap  != NULL )	CloseHandle( hMap );

-		if ( hFile != NULL ) CloseHandle( hFile );

+		if ( ppMap !=NULL )	UnmapViewOfFile( ppMap );

+		if ( hMap  !=NULL )	CloseHandle( hMap );

+		if ( hFile !=NULL ) CloseHandle( hFile );

 

 		if ( cbFileSize == 0 )

 			return (HBITMAP)NULL;

 

 		{

-			BITMAPINFO* bi=( BITMAPINFO* )pDib;

-			BYTE *pt=(BYTE*)bi;

-			pt+=bi->bmiHeader.biSize;

-			if (bi->bmiHeader.biBitCount!=32)

+			BITMAPINFO* bi = ( BITMAPINFO* )pDib;

+			BYTE *pt = (BYTE*)bi;

+			pt += bi->bmiHeader.biSize;

+			if (bi->bmiHeader.biBitCount != 32)

 			{

 				HDC sDC = GetDC( NULL );

 				HBITMAP hBitmap = CreateDIBitmap( sDC, pDib, CBM_INIT, pDibBits, bi, DIB_PAL_COLORS );

@@ -2015,8 +2015,8 @@ HBITMAP ske_LoadGlyphImage_Png2Dib(char * szFilename)
 			}

 			else

 			{

-				BYTE * ptPixels=pt;

-				HBITMAP hBitmap=CreateDIBSection(NULL,bi, DIB_RGB_COLORS, (void **)&ptPixels,  NULL, 0);         

+				BYTE * ptPixels = pt;

+				HBITMAP hBitmap = CreateDIBSection(NULL,bi, DIB_RGB_COLORS, (void **)&ptPixels,  NULL, 0);         

 				memcpy(ptPixels,pt,bi->bmiHeader.biSizeImage);

 				GlobalFree( pDib );

 				return hBitmap;

@@ -2028,39 +2028,39 @@ HBITMAP ske_LoadGlyphImage_Png2Dib(char * szFilename)
 static HBITMAP ske_LoadGlyphImageByDecoders(char * szFileName)

 {

 	// Loading image from file by imgdecoder...    

-	HBITMAP hBitmap=NULL;

+	HBITMAP hBitmap = NULL;

 	char ext[5];

-	BYTE f=0;

+	BYTE f = 0;

 	LPBYTE pBitmapBits;

-	LPVOID pImg= NULL;

+	LPVOID pImg = NULL;

 	LPVOID m_pImgDecoder;

 

 	BITMAP bmpInfo;

 	{

 		int l;

-		l=mir_strlen(szFileName);

+		l = mir_strlen(szFileName);

 		memmove(ext,szFileName +(l-4),5);   

 	}

 	if (!strchr(szFileName,'%') && !PathFileExistsA(szFileName)) return NULL;

 	if (mir_bool_strcmpi(ext,".tga"))

 	{

-		hBitmap=ske_LoadGlyphImage_TGA(szFileName);

-		f=1;

+		hBitmap = ske_LoadGlyphImage_TGA(szFileName);

+		f = 1;

 	}

 	else if (ServiceExists("Image/Png2Dib") && mir_bool_strcmpi(ext,".png"))

 	{

-		hBitmap=ske_LoadGlyphImage_Png2Dib(szFileName);

+		hBitmap = ske_LoadGlyphImage_Png2Dib(szFileName);

 		GetObject(hBitmap, sizeof(BITMAP), &bmpInfo);

-		f=(bmpInfo.bmBits!=NULL);

-		// hBitmap=(HBITMAP)CallService(MS_UTILS_LOADBITMAP,0,(LPARAM)szFileName);

-		// f=1;

+		f = (bmpInfo.bmBits != NULL);

+		// hBitmap = (HBITMAP)CallService(MS_UTILS_LOADBITMAP,0,(LPARAM)szFileName);

+		// f = 1;

 

 	}

-	else if (hImageDecoderModule==NULL || !mir_bool_strcmpi(ext,".png"))

-		hBitmap=(HBITMAP)CallService(MS_UTILS_LOADBITMAP,0,(LPARAM)szFileName);

+	else if (hImageDecoderModule == NULL || !mir_bool_strcmpi(ext,".png"))

+		hBitmap = (HBITMAP)CallService(MS_UTILS_LOADBITMAP,0,(LPARAM)szFileName);

 	else

 	{

-		f=1;

+		f = 1;

 		ImgNewDecoder(&m_pImgDecoder);

 		if (!ImgNewDIBFromFile(m_pImgDecoder, szFileName, &pImg))	

 		{

@@ -2078,18 +2078,18 @@ static HBITMAP ske_LoadGlyphImageByDecoders(char * szFileName)
 		{

 			HDC dc24,dc32;

 			HBITMAP hBitmap32,obmp24,obmp32;

-			dc32=CreateCompatibleDC(NULL);

-			dc24=CreateCompatibleDC(NULL);

-			hBitmap32=ske_CreateDIB32(bmpInfo.bmWidth,bmpInfo.bmHeight);

-			obmp24=(HBITMAP)SelectObject(dc24,hBitmap);

-			obmp32=(HBITMAP)SelectObject(dc32,hBitmap32);

+			dc32 = CreateCompatibleDC(NULL);

+			dc24 = CreateCompatibleDC(NULL);

+			hBitmap32 = ske_CreateDIB32(bmpInfo.bmWidth,bmpInfo.bmHeight);

+			obmp24 = (HBITMAP)SelectObject(dc24,hBitmap);

+			obmp32 = (HBITMAP)SelectObject(dc32,hBitmap32);

 			BitBlt(dc32,0,0,bmpInfo.bmWidth,bmpInfo.bmHeight,dc24,0,0,SRCCOPY);

 			SelectObject(dc24,obmp24);

 			SelectObject(dc32,obmp32);

 			mod_DeleteDC(dc24);

 			mod_DeleteDC(dc32);

 			DeleteObject(hBitmap);

-			hBitmap=hBitmap32;

+			hBitmap = hBitmap32;

 			ske_PreMultiplyChanells(hBitmap,0);

 		}

 

@@ -2102,12 +2102,12 @@ HBITMAP ske_LoadGlyphImage(char * szFileName)
 	// try to find image in loaded

 	DWORD i;

 	HBITMAP hbmp;

-	char szFile [MAX_PATH]={0};	

+	char szFile [MAX_PATH] = {0};	

 	ske_GetFullFilename(szFile,szFileName,g_SkinObjectList.szSkinPlace,TRUE);

 	ske_LockSkin();

 	if (pLoadedImages)

 	{

-		for (i=0; i<dwLoadedImagesCount; i++)

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

 		{

 			if (mir_bool_strcmpi(pLoadedImages[i].szFileName,szFile))

 			{

@@ -2118,8 +2118,8 @@ HBITMAP ske_LoadGlyphImage(char * szFileName)
 		}

 	}

 	// load new image

-	hbmp=ske_skinLoadGlyphImage(szFile);

-	if (hbmp==NULL) 

+	hbmp = ske_skinLoadGlyphImage(szFile);

+	if (hbmp == NULL) 

 	{

 		ske_UnlockSkin();

 		return NULL;

@@ -2127,7 +2127,7 @@ HBITMAP ske_LoadGlyphImage(char * szFileName)
 	// add to loaded list

 	if (dwLoadedImagesCount+1>dwLoadedImagesAlocated)

 	{

-		pLoadedImages=(GLYPHIMAGE*)mir_realloc(pLoadedImages,sizeof(GLYPHIMAGE)*(dwLoadedImagesCount+1));

+		pLoadedImages = (GLYPHIMAGE*)mir_realloc(pLoadedImages,sizeof(GLYPHIMAGE)*(dwLoadedImagesCount+1));

 		if (pLoadedImages) dwLoadedImagesAlocated++;

 		else 

 		{

@@ -2135,9 +2135,9 @@ HBITMAP ske_LoadGlyphImage(char * szFileName)
 			return NULL;

 		}

 	}

-	pLoadedImages[dwLoadedImagesCount].dwLoadedTimes=1;

-	pLoadedImages[dwLoadedImagesCount].hGlyph=hbmp;

-	pLoadedImages[dwLoadedImagesCount].szFileName=mir_strdup(szFile);

+	pLoadedImages[dwLoadedImagesCount].dwLoadedTimes = 1;

+	pLoadedImages[dwLoadedImagesCount].hGlyph = hbmp;

+	pLoadedImages[dwLoadedImagesCount].szFileName = mir_strdup(szFile);

 	dwLoadedImagesCount++;

 	ske_UnlockSkin();

 	return hbmp;

@@ -2145,21 +2145,21 @@ HBITMAP ske_LoadGlyphImage(char * szFileName)
 int ske_UnloadGlyphImage(HBITMAP hbmp)

 {

 	DWORD i;

-	for (i=0; i<dwLoadedImagesCount; i++)

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

 	{

-		if (hbmp==pLoadedImages[i].hGlyph)

+		if (hbmp == pLoadedImages[i].hGlyph)

 		{

 			pLoadedImages[i].dwLoadedTimes--;

-			if (pLoadedImages[i].dwLoadedTimes==0)

+			if (pLoadedImages[i].dwLoadedTimes == 0)

 			{

-				LPGLYPHIMAGE gl=&(pLoadedImages[i]);

+				LPGLYPHIMAGE gl = &(pLoadedImages[i]);

 				if (gl->szFileName) mir_free_and_nill(gl->szFileName);

 				memmove(&(pLoadedImages[i]),&(pLoadedImages[i+1]),sizeof(GLYPHIMAGE)*(dwLoadedImagesCount-i-1));

 				dwLoadedImagesCount--;

 				DeleteObject(hbmp);

-				if (pLoadedImages && dwLoadedImagesCount==0) 

+				if (pLoadedImages && dwLoadedImagesCount == 0) 

 				{

-					dwLoadedImagesAlocated=0;

+					dwLoadedImagesAlocated = 0;

 					mir_free_and_nill(pLoadedImages);

 				}

 			}

@@ -2181,9 +2181,9 @@ int ske_UnloadSkin(SKINOBJECTSLIST * Skin)
 		int i;

 		if (gl_plSkinFonts && gl_plSkinFonts->realCount>0)

 		{

-			for (i=0; i<gl_plSkinFonts->realCount; i++)

+			for (i = 0; i < gl_plSkinFonts->realCount; i++)

 			{

-				SKINFONT * sf=(SKINFONT *)gl_plSkinFonts->items[i];

+				SKINFONT * sf = (SKINFONT *)gl_plSkinFonts->items[i];

 				if (sf)

 				{

 					if (sf->szFontID) mir_free_and_nill(sf->szFontID);

@@ -2200,26 +2200,26 @@ int ske_UnloadSkin(SKINOBJECTSLIST * Skin)
 	if (Skin->pTextList) List_Destroy(Skin->pTextList);

 	mir_free_and_nill(Skin->pTextList);

 	ModernSkinButtonDeleteAll();

-	if (Skin->dwObjLPAlocated==0) { ske_UnlockSkin(); return 0;}

-	for (i=0; i<Skin->dwObjLPAlocated; i++)

+	if (Skin->dwObjLPAlocated == 0) { ske_UnlockSkin(); return 0;}

+	for (i = 0; i < Skin->dwObjLPAlocated; i++)

 	{

 		switch(Skin->pObjects[i].bType)

 		{

 		case OT_GLYPHOBJECT:

 			{

 				GLYPHOBJECT * dt;

-				dt=(GLYPHOBJECT*)Skin->pObjects[i].Data;

-				if (dt->hGlyph && dt->hGlyph!=(HBITMAP)-1) 

+				dt = (GLYPHOBJECT*)Skin->pObjects[i].Data;

+				if (dt->hGlyph && dt->hGlyph != (HBITMAP)-1) 

 					ske_UnloadGlyphImage(dt->hGlyph);

-				dt->hGlyph=NULL;

+				dt->hGlyph = NULL;

 				if (dt->szFileName) mir_free_and_nill(dt->szFileName);

 				{// delete texts

 					int i;

 					if (dt->plTextList && dt->plTextList->realCount>0)

 					{

-						for (i=0; i<dt->plTextList->realCount; i++)

+						for (i = 0; i < dt->plTextList->realCount; i++)

 						{

-							GLYPHTEXT * gt=(GLYPHTEXT *)dt->plTextList->items[i];

+							GLYPHTEXT * gt = (GLYPHTEXT *)dt->plTextList->items[i];

 							if (gt)

 							{

 								if (gt->stText)       mir_free_and_nill(gt->stText);

@@ -2241,9 +2241,9 @@ int ske_UnloadSkin(SKINOBJECTSLIST * Skin)
 

 	}

 	mir_free_and_nill(Skin->pObjects);

-	Skin->pTextList=NULL;

-	Skin->dwObjLPAlocated=0;

-	Skin->dwObjLPReserved=0;

+	Skin->pTextList = NULL;

+	Skin->dwObjLPAlocated = 0;

+	Skin->dwObjLPReserved = 0;

 	ske_UnlockSkin();

 	return 0;

 }

@@ -2251,17 +2251,17 @@ int ske_UnloadSkin(SKINOBJECTSLIST * Skin)
 static void RegisterMaskByParce(const char * szSetting, char * szValue, SKINOBJECTSLIST * pSkin)

 {

 	int i;

-	DWORD ID=atoi(szSetting+1);

-	for (i=0; i<mir_strlen(szValue); i++)  if (szValue[i]==':') break;

-	if (i<mir_strlen(szValue))

+	DWORD ID = atoi(szSetting+1);

+	for (i = 0; i < mir_strlen(szValue); i++)  if (szValue[i] == ':') break;

+	if (i < mir_strlen(szValue))

 	{

 		char * Obj, *Mask;

 		int res;

-		Mask=szValue+i+1;

-		Obj=(char*)mir_alloc(i+1);

+		Mask = szValue+i+1;

+		Obj = (char*)mir_alloc(i+1);

 		strncpy(Obj,szValue,i);

-		Obj[i]='\0';

-		res=AddStrModernMaskToList(ID,Mask,Obj,pSkin->pMaskList,pSkin);

+		Obj[i] = '\0';

+		res = AddStrModernMaskToList(ID,Mask,Obj,pSkin->pMaskList,pSkin);

 		mir_free_and_nill(Obj);

 	}

 }

@@ -2269,15 +2269,15 @@ static void RegisterMaskByParce(const char * szSetting, char * szValue, SKINOBJE
 static int ske_ProcessLoadindString(const char * szSetting, char *szValue)

 {	

 	if (!pCurrentSkin) return 0;

-	if (szSetting[0]=='$')

+	if (szSetting[0] == '$')

 		RegisterObjectByParce((char *)szSetting, szValue);

-	else if (szSetting[0]=='#')

+	else if (szSetting[0] == '#')

 		RegisterButtonByParce((char *)szSetting,szValue);

-	else if (szSetting[0]=='@')

+	else if (szSetting[0] == '@')

 		RegisterMaskByParce((char *)szSetting,  szValue, pCurrentSkin); ///

-	else if (szSetting[0]=='t')

+	else if (szSetting[0] == 't')

 		ske_AddParseTextGlyphObject((char*)szSetting,szValue,pCurrentSkin);

-	else if (szSetting[0]=='f')

+	else if (szSetting[0] == 'f')

 		ske_AddParseSkinFont((char*)szSetting,szValue,pCurrentSkin);

 	else return 0;

 	return 1;

@@ -2285,7 +2285,7 @@ static int ske_ProcessLoadindString(const char * szSetting, char *szValue)
 static int ske_enumdb_SkinObjectsProc (const char *szSetting,LPARAM lParam)

 {   

 	char *value;

-	value= db_get_sa(NULL,SKIN,szSetting);

+	value = db_get_sa(NULL,SKIN,szSetting);

 	ske_ProcessLoadindString(szSetting,value);

 	mir_free_and_nill(value);

 

@@ -2301,43 +2301,43 @@ static void ske_LinkSkinObjects(SKINOBJECTSLIST * pObjectList)
 {

 	DWORD i;

 	// LINK Mask with objects

-	for (i=0; i<pObjectList->pMaskList->dwMaskCnt; i++)

+	for (i = 0; i < pObjectList->pMaskList->dwMaskCnt; i++)

 	{

-		MODERNMASK *mm=&(pObjectList->pMaskList->pl_Masks[i]);

-		void * pObject=(void*) ske_FindObjectByName(mm->szObjectName, OT_ANY, (SKINOBJECTSLIST*) pObjectList);

+		MODERNMASK *mm = &(pObjectList->pMaskList->pl_Masks[i]);

+		void * pObject = (void*) ske_FindObjectByName(mm->szObjectName, OT_ANY, (SKINOBJECTSLIST*) pObjectList);

 		mir_free_and_nill(mm->szObjectName);

-		mm->bObjectFound=TRUE;

-		mm->pObject=pObject;

+		mm->bObjectFound = TRUE;

+		mm->pObject = pObject;

 	}	

 

 	if (pObjectList->pTextList)

 	{

 		int i;

 		// LINK Text with objects

-		for (i=0; i<pObjectList->pTextList->realCount; i++)

+		for (i = 0; i < pObjectList->pTextList->realCount; i++)

 		{

 			GLYPHTEXT * glText;

-			GLYPHOBJECT *globj=NULL;

+			GLYPHOBJECT *globj = NULL;

 			SKINOBJECTDESCRIPTOR * lpobj;

-			glText=(GLYPHTEXT *)pObjectList->pTextList->items[i];

-			lpobj=ske_FindObjectByName(glText->szObjectName,OT_GLYPHOBJECT, pObjectList);

+			glText = (GLYPHTEXT *)pObjectList->pTextList->items[i];

+			lpobj = ske_FindObjectByName(glText->szObjectName,OT_GLYPHOBJECT, pObjectList);

 			mir_free_and_nill(glText->szObjectName);

 			if (lpobj)

-				globj=(GLYPHOBJECT*)lpobj->Data;

+				globj = (GLYPHOBJECT*)lpobj->Data;

 			if (globj)

 			{

 				if (!globj->plTextList)

 				{

-					globj->plTextList=List_Create(0,1);

-					globj->plTextList->sortFunc=ske_SortTextGlyphObjectFunc;

+					globj->plTextList = List_Create(0,1);

+					globj->plTextList->sortFunc = ske_SortTextGlyphObjectFunc;

 				}

 				List_Insert(globj->plTextList,(void*)glText,globj->plTextList->realCount);     

 				qsort(globj->plTextList->items,globj->plTextList->realCount,sizeof(void*),(int(*)(const void*, const void*))globj->plTextList->sortFunc);

-				pObjectList->pTextList->items[i]=NULL;

+				pObjectList->pTextList->items[i] = NULL;

 			}

 			else

 			{

-				GLYPHTEXT * gt=glText;

+				GLYPHTEXT * gt = glText;

 				if (gt)

 				{

 					if (gt->stText)       mir_free_and_nill(gt->stText);

@@ -2355,44 +2355,44 @@ static void ske_LinkSkinObjects(SKINOBJECTSLIST * pObjectList)
 // Getting skin objects and masks from DB

 static int ske_GetSkinFromDB(char * szSection, SKINOBJECTSLIST * Skin)

 {

-	if (Skin==NULL) return 0;

+	if (Skin == NULL) return 0;

 	ske_UnloadSkin(Skin);

-	g_CluiData.fDisableSkinEngine=db_get_b(NULL,"ModernData","DisableEngine", SETTING_DISABLESKIN_DEFAULT);

+	g_CluiData.fDisableSkinEngine = db_get_b(NULL,"ModernData","DisableEngine", SETTING_DISABLESKIN_DEFAULT);

 	//window borders

 	if (g_CluiData.fDisableSkinEngine) {

-		g_CluiData.LeftClientMargin=0;

-		g_CluiData.RightClientMargin=0; 

-		g_CluiData.TopClientMargin=0;

-		g_CluiData.BottomClientMargin=0;

+		g_CluiData.LeftClientMargin = 0;

+		g_CluiData.RightClientMargin = 0; 

+		g_CluiData.TopClientMargin = 0;

+		g_CluiData.BottomClientMargin = 0;

 	} else {

 		//window borders

-		g_CluiData.LeftClientMargin=(int)db_get_b(NULL,"CLUI","LeftClientMargin",SETTING_LEFTCLIENTMARIGN_DEFAULT);

-		g_CluiData.RightClientMargin=(int)db_get_b(NULL,"CLUI","RightClientMargin",SETTING_RIGHTCLIENTMARIGN_DEFAULT); 

-		g_CluiData.TopClientMargin=(int)db_get_b(NULL,"CLUI","TopClientMargin",SETTING_TOPCLIENTMARIGN_DEFAULT);

-		g_CluiData.BottomClientMargin=(int)db_get_b(NULL,"CLUI","BottomClientMargin",SETTING_BOTTOMCLIENTMARIGN_DEFAULT);

+		g_CluiData.LeftClientMargin = (int)db_get_b(NULL,"CLUI","LeftClientMargin",SETTING_LEFTCLIENTMARIGN_DEFAULT);

+		g_CluiData.RightClientMargin = (int)db_get_b(NULL,"CLUI","RightClientMargin",SETTING_RIGHTCLIENTMARIGN_DEFAULT); 

+		g_CluiData.TopClientMargin = (int)db_get_b(NULL,"CLUI","TopClientMargin",SETTING_TOPCLIENTMARIGN_DEFAULT);

+		g_CluiData.BottomClientMargin = (int)db_get_b(NULL,"CLUI","BottomClientMargin",SETTING_BOTTOMCLIENTMARIGN_DEFAULT);

 	}

 

 	if (g_CluiData.fDisableSkinEngine) return 0;

 

-	Skin->pMaskList=(LISTMODERNMASK*)mir_alloc(sizeof(LISTMODERNMASK));

+	Skin->pMaskList = (LISTMODERNMASK*)mir_alloc(sizeof(LISTMODERNMASK));

 	memset(Skin->pMaskList,0,sizeof(LISTMODERNMASK));

-	Skin->szSkinPlace= db_get_sa(NULL,SKIN,"SkinFolder");

+	Skin->szSkinPlace = db_get_sa(NULL,SKIN,"SkinFolder");

 	if (!Skin->szSkinPlace || (strchr(Skin->szSkinPlace, '%') && !db_get_b(NULL,SKIN,"Modified",0))) 

 	{

-		BOOL bOnlyObjects=FALSE;

+		BOOL bOnlyObjects = FALSE;

 		if (Skin->szSkinPlace && strchr(Skin->szSkinPlace, '%'))

-			bOnlyObjects=TRUE;

+			bOnlyObjects = TRUE;

 		mir_free(Skin->szSkinPlace);

-		Skin->szSkinPlace=mir_strdup("%Default%");

+		Skin->szSkinPlace = mir_strdup("%Default%");

 		ske_LoadSkinFromResource( bOnlyObjects );

 	}

 	//Load objects

 	{

 		DBCONTACTENUMSETTINGS dbces;

-		pCurrentSkin=Skin;

-		dbces.pfnEnumProc=ske_enumdb_SkinObjectsProc;

-		dbces.szModule=SKIN;

-		dbces.ofsSettings=0;

+		pCurrentSkin = Skin;

+		dbces.pfnEnumProc = ske_enumdb_SkinObjectsProc;

+		dbces.szModule = SKIN;

+		dbces.ofsSettings = 0;

 		CallService(MS_DB_CONTACT_ENUMSETTINGS,0,(LPARAM)&dbces);

 

 		SortMaskList(pCurrentSkin->pMaskList);

@@ -2406,7 +2406,7 @@ static int ske_GetSkinFromDB(char * szSection, SKINOBJECTSLIST * Skin)
 void ske_LoadSkinFromDB(void) 

 { 

 	ske_GetSkinFromDB(SKIN,&g_SkinObjectList); 

-	g_CluiData.dwKeyColor=db_get_dw(NULL,"ModernSettings","KeyColor",(DWORD)SETTING_KEYCOLOR_DEFAULT);

+	g_CluiData.dwKeyColor = db_get_dw(NULL,"ModernSettings","KeyColor",(DWORD)SETTING_KEYCOLOR_DEFAULT);

 }

 

 

@@ -2417,11 +2417,11 @@ void ske_LoadSkinFromDB(void)
 /*

 static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)

 {

-	DWORD i=0;

-	DWORD len=strlen(Line);

-	while (i<len && (Line[i]==' ' || Line[i]=='\t')) i++; //skip spaces&tabs

-	if (i>=len) return FALSE; //only spaces (or tabs)

-	if (len>0 && Line[len-1]==10) Line[len-1]='\0';

+	DWORD i = 0;

+	DWORD len = strlen(Line);

+	while (i < len && (Line[i] == ' ' || Line[i] == '\t')) i++; //skip spaces&tabs

+	if (i >= len) return FALSE; //only spaces (or tabs)

+	if (len>0 && Line[len-1] == 10) Line[len-1] = '\0';

 	switch(Line[i])

 	{

 	case ';':

@@ -2430,47 +2430,47 @@ static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)
 		//New section start here

 		if (iniCurrentSection) mir_free_and_nill(iniCurrentSection);

 		{

-			char *tbuf=Line+i+1;		

-			DWORD len2=strlen(tbuf);

-			DWORD k=len2;

-			while (k>0 && tbuf[k]!=']') k--; //searching close bracket

-			tbuf[k]='\0';   //closing string

-			if (k==0) return FALSE;

-			iniCurrentSection=mir_strdup(tbuf);

+			char *tbuf = Line+i+1;		

+			DWORD len2 = strlen(tbuf);

+			DWORD k = len2;

+			while (k>0 && tbuf[k] != ']') k--; //searching close bracket

+			tbuf[k] = '\0';   //closing string

+			if (k == 0) return FALSE;

+			iniCurrentSection = mir_strdup(tbuf);

 		}

 		return TRUE;

 	default:

 		if (!iniCurrentSection) return FALSE;  //param found out of section

 		{

-			char *keyName=Line+i;

-			char *keyValue=Line+i;

-

-			DWORD eqPlace=0;

-			DWORD len2=strlen(keyName);

-			while (eqPlace<len2 && keyName[eqPlace]!='=') eqPlace++; //find '='

-			if (eqPlace==0 || eqPlace==len2) return FALSE; //= not found or no key name

-			keyName[eqPlace]='\0';

-			keyValue=keyName+eqPlace+1;

+			char *keyName = Line+i;

+			char *keyValue = Line+i;

+

+			DWORD eqPlace = 0;

+			DWORD len2 = strlen(keyName);

+			while (eqPlace < len2 && keyName[eqPlace] != ' = ') eqPlace++; //find ' = '

+			if (eqPlace == 0 || eqPlace == len2) return FALSE; // = not found or no key name

+			keyName[eqPlace] = '\0';

+			keyValue = keyName+eqPlace+1;

 			//remove tail spaces in Name

 			{

-				DWORD len3=strlen(keyName);

-				int j=len3-1;

-				while (j>0 && (keyName[j]==' ' || keyName[j]=='\t')) j--;

-				if (j>=0) keyName[j+1]='\0';

+				DWORD len3 = strlen(keyName);

+				int j = len3-1;

+				while (j>0 && (keyName[j] == ' ' || keyName[j] == '\t')) j--;

+				if (j >= 0) keyName[j+1] = '\0';

 			}		

 			//remove start spaces in Value

 			{

-				DWORD len3=strlen(keyValue);

-				DWORD j=0;

-				while (j<len3 && (keyValue[j]==' ' || keyValue[j]=='\t')) j++;

-				if (j<len3) keyValue+=j;

+				DWORD len3 = strlen(keyValue);

+				DWORD j = 0;

+				while (j < len3 && (keyValue[j] == ' ' || keyValue[j] == '\t')) j++;

+				if (j < len3) keyValue += j;

 			}

 			//remove tail spaces in Value

 			{

-				DWORD len3=strlen(keyValue);

-				int j=len3-1;

-				while (j>0 && (keyValue[j]==' ' || keyValue[j]=='\t')) j--;

-				if (j>=0) keyValue[j+1]='\0';

+				DWORD len3 = strlen(keyValue);

+				int j = len3-1;

+				while (j>0 && (keyValue[j] == ' ' || keyValue[j] == '\t')) j--;

+				if (j >= 0) keyValue[j+1] = '\0';

 			}

 			ske_WriteParamToDatabase(iniCurrentSection,keyName,keyValue,TRUE);

 		}

@@ -2487,63 +2487,63 @@ static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)
 //	char bsn[MAXSN_BUFF_SIZE];

 //	char * Buff;

 //

-//	int i=0;

-//	int f=0;

-//	int ReadingSection=0;

+//	int i = 0;

+//	int f = 0;

+//	int ReadingSection = 0;

 //	char AllowedSection[260];

-//	int AllowedAll=0;

+//	int AllowedAll = 0;

 //	char t2[MAX_PATH];

 //	char t3[MAX_PATH];

 //

-//	DWORD retu=GetPrivateProfileSectionNamesA(bsn,MAXSN_BUFF_SIZE,szFileName);

+//	DWORD retu = GetPrivateProfileSectionNamesA(bsn,MAXSN_BUFF_SIZE,szFileName);

 //	ske_DeleteAllSettingInSection("ModernSkin");

 //	ske_GetSkinFolder(szFileName,t2);

 //	db_set_s(NULL,SKIN,"SkinFolder",t2);

 //	CallService(MS_UTILS_PATHTORELATIVE, (WPARAM)szFileName, (LPARAM)t3);

 //	db_set_s(NULL,SKIN,"SkinFile",t3);

-//	Buff=bsn;

-//	AllowedSection[0]=0;

+//	Buff = bsn;

+//	AllowedSection[0] = 0;

 //	do         

 //	{

-//		f=mir_strlen(Buff);

+//		f = mir_strlen(Buff);

 //		if (f>0 && !mir_bool_strcmpi(Buff,"Skin_Description_Section"))

 //		{

 //			char b3[MAX_BUFF_SIZE];

-//			DWORD ret=0;

-//			ret=GetPrivateProfileSectionA(Buff,b3,MAX_BUFF_SIZE,szFileName);

+//			DWORD ret = 0;

+//			ret = GetPrivateProfileSectionA(Buff,b3,MAX_BUFF_SIZE,szFileName);

 //			if (ret>MAX_BUFF_SIZE-3) continue;

-//			if (ret==0) continue;

+//			if (ret == 0) continue;

 //			{

-//				DWORD p=0;

+//				DWORD p = 0;

 //				char *s1;

 //				char *s2;

 //				char *s3;

 //				{

 //					DWORD t;

-//					BOOL LOCK=FALSE;

-//					for (t=0; t<ret-1;t++)

+//					BOOL LOCK = FALSE;

+//					for (t = 0; t < ret-1;t++)

 //					{

-//						if (b3[t]=='\0') LOCK=FALSE;

-//						if (b3[t]=='=' && !LOCK) 

+//						if (b3[t] == '\0') LOCK = FALSE;

+//						if (b3[t] == ' = ' && !LOCK) 

 //						{

-//							b3[t]='\0';

-//							LOCK=TRUE;

+//							b3[t] = '\0';

+//							LOCK = TRUE;

 //						}

 //					}

 //				}

 //				do

 //				{

-//					s1=b3+p;

+//					s1 = b3+p;

 //

-//					s2=s1+mir_strlen(s1)+1;

+//					s2 = s1+mir_strlen(s1)+1;

 //					switch (s2[0])

 //					{

 //					case 'b':

 //						{

 //							BYTE P;

 //							//                            char ba[255];

-//							s3=s2+1;

-//							P=(BYTE)atoi(s3);

+//							s3 = s2+1;

+//							P = (BYTE)atoi(s3);

 //							db_set_b(NULL,Buff,s1,P);

 //						}

 //						break;

@@ -2551,23 +2551,23 @@ static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)
 //						{

 //							WORD P;

 //							//                           char ba[255];

-//							s3=s2+1;

-//							P=(WORD)atoi(s3);

+//							s3 = s2+1;

+//							P = (WORD)atoi(s3);

 //							db_set_w(NULL,Buff,s1,P);

 //						}break;

 //					case 'd':

 //						{

 //							DWORD P;

 //

-//							s3=s2+1;

-//							P=(DWORD)atoi(s3);

+//							s3 = s2+1;

+//							P = (DWORD)atoi(s3);

 //							db_set_dw(NULL,Buff,s1,P);

 //						}break;

 //					case 's':

 //						{

 //							//                          char ba[255];

 //							char bb[255];

-//							s3=s2+1;

+//							s3 = s2+1;

 //							strncpy(bb,s3,sizeof(bb));

 //							db_set_s(NULL,Buff,s1,s3);

 //						}break;

@@ -2576,17 +2576,17 @@ static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)
 //							//                         char ba[255];

 //							char bb[255];

 //

-//							s3=s2+1;

+//							s3 = s2+1;

 //							{

 //								char fn[MAX_PATH];

 //								int pp, i;

-//								pp=-1;

+//								pp = -1;

 //								CallService(MS_UTILS_PATHTORELATIVE, (WPARAM)szFileName, (LPARAM)fn);

 //								{

-//									for (i=0; i<mir_strlen(fn); i++)  if (fn[i]=='.') pp=i;

-//									if (pp!=-1)

+//									for (i = 0; i < mir_strlen(fn); i++)  if (fn[i] == '.') pp = i;

+//									if (pp != -1)

 //									{

-//										fn[pp]='\0';

+//										fn[pp] = '\0';

 //									}

 //								}                      

 //								sprintf(bb,"%s\\%s",fn,s3);

@@ -2594,13 +2594,13 @@ static BOOL ske_ParseLineOfIniFile(char * Line, BOOL bOnlyObjects)
 //							}

 //						}break;

 //					}

-//					p=p+mir_strlen(s1)+mir_strlen(s2)+2;

-//				} while (p<ret);

+//					p = p+mir_strlen(s1)+mir_strlen(s2)+2;

+//				} while (p < ret);

 //

 //			}

 //		}

-//		Buff+=mir_strlen(Buff)+1;

-//	}while (((DWORD)Buff-(DWORD)bsn)<retu);

+//		Buff += mir_strlen(Buff)+1;

+//	}while (((DWORD)Buff-(DWORD)bsn) < retu);

 //	return 0;

 //}

 //

@@ -2623,8 +2623,8 @@ static int ske_LoadSkinFromResource(BOOL bOnlyObjects)
 //Load data from ini file

 int ske_LoadSkinFromIniFile(TCHAR * szFileName, BOOL bOnlyObjects)

 {

-	TCHAR skinFolder[MAX_PATH]={0};

-	TCHAR skinFile[MAX_PATH]={0};

+	TCHAR skinFolder[MAX_PATH] = {0};

+	TCHAR skinFile[MAX_PATH] = {0};

 	if (_tcschr(szFileName,_T('%'))) 

 		return ske_LoadSkinFromResource( bOnlyObjects );

 

@@ -2647,35 +2647,35 @@ int ske_LoadSkinFromIniFile(TCHAR * szFileName, BOOL bOnlyObjects)
 static int ske_enumdb_SkinSectionDeletionProc (const char *szSetting,LPARAM lParam)

 {

 

-	if (szSetting==NULL){return(0);};

+	if (szSetting == NULL){return(0);};

 	nArrayLen++;

-	pszSettingName=(char **)realloc(pszSettingName,nArrayLen*sizeof(char *));

-	pszSettingName[nArrayLen-1]=_strdup(szSetting);

+	pszSettingName = (char **)realloc(pszSettingName,nArrayLen*sizeof(char *));

+	pszSettingName[nArrayLen-1] = _strdup(szSetting);

 	return(0);

 };

 static int ske_DeleteAllSettingInSection(char * SectionName)

 {

 	DBCONTACTENUMSETTINGS dbces;

-	nArrayLen=0;

-	pszSettingName=NULL;

-	dbces.pfnEnumProc=ske_enumdb_SkinSectionDeletionProc;

-	dbces.szModule=SectionName;

-	dbces.ofsSettings=0;

+	nArrayLen = 0;

+	pszSettingName = NULL;

+	dbces.pfnEnumProc = ske_enumdb_SkinSectionDeletionProc;

+	dbces.szModule = SectionName;

+	dbces.ofsSettings = 0;

 

 	CallService(MS_DB_CONTACT_ENUMSETTINGS,0,(LPARAM)&dbces);

 

 	//delete all settings

-	if (nArrayLen==0){return(0);};

+	if (nArrayLen == 0){return(0);};

 	{

 		int i;

-		for (i=0;i<nArrayLen;i++)

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

 		{

 			db_unset(0,SectionName,pszSettingName[i]);

 			free(pszSettingName[i]);

 		};

 		free(pszSettingName);

-		pszSettingName=NULL;

-		nArrayLen=0;    

+		pszSettingName = NULL;

+		nArrayLen = 0;    

 	};

 	return(0);

 };

@@ -2683,10 +2683,10 @@ static int ske_DeleteAllSettingInSection(char * SectionName)
 

 BOOL ske_TextOutA(HDC hdc, int x, int y, char * lpString, int nCount)

 {

-	TCHAR *buf=(TCHAR *)mir_alloc((2+nCount)*sizeof(TCHAR));

+	TCHAR *buf = (TCHAR *)mir_alloc((2+nCount)*sizeof(TCHAR));

 	BOOL res;

 	MultiByteToWideChar(CallService( MS_LANGPACK_GETCODEPAGE, 0, 0 ), 0, lpString, -1, buf, (2+nCount)*sizeof(TCHAR)); 

-	res=ske_TextOut(hdc,x,y,buf,nCount);

+	res = ske_TextOut(hdc,x,y,buf,nCount);

 	mir_free_and_nill(buf);

 	return res;

 }

@@ -2695,7 +2695,7 @@ BOOL ske_TextOut(HDC hdc, int x, int y, LPCTSTR lpString, int nCount)
 {

 	int ta;

 	SIZE sz;

-	RECT rc={0};

+	RECT rc = {0};

 	if (!g_CluiData.fGDIPlusFail &&0) ///text via gdi+

 	{

 		TextOutWithGDIp(hdc,x,y,lpString,nCount);

@@ -2706,7 +2706,7 @@ BOOL ske_TextOut(HDC hdc, int x, int y, LPCTSTR lpString, int nCount)
 	{

 		// return TextOut(hdc, x,y,lpString,nCount);

 		GetTextExtentPoint32(hdc,lpString,nCount,&sz);

-		ta=GetTextAlign(hdc);

+		ta = GetTextAlign(hdc);

 		SetRect(&rc,x,y,x+sz.cx,y+sz.cy);

 		ske_DrawText(hdc,lpString,nCount,&rc,DT_NOCLIP|DT_SINGLELINE|DT_LEFT);

 	}

@@ -2717,7 +2717,7 @@ static INT_PTR ske_Service_AlphaTextOut(WPARAM wParam,LPARAM lParam)
 {

 	if (!wParam) return 0;

 	{

-		AlphaTextOutParams ap=*(AlphaTextOutParams*)wParam;

+		AlphaTextOutParams ap = *(AlphaTextOutParams*)wParam;

 		return ske_AlphaTextOut(ap.hDC,ap.lpString,ap.nCount,ap.lpRect,ap.format,ap.ARGBcolor);

 	}

 }

@@ -2727,21 +2727,21 @@ static __inline void ske_SetMatrix( sbyte * matrix,
 										  sbyte d, sbyte e, sbyte f, 

 										  sbyte g, sbyte h, sbyte i)

 {

-	matrix[0]=a;	matrix[1]=b;	matrix[2]=c;

-	matrix[3]=d;	matrix[4]=e;	matrix[5]=f;

-	matrix[6]=g;	matrix[7]=h;	matrix[8]=i;

+	matrix[0] = a;	matrix[1] = b;	matrix[2] = c;

+	matrix[3] = d;	matrix[4] = e;	matrix[5] = f;

+	matrix[6] = g;	matrix[7] = h;	matrix[8] = i;

 }

 

 static void ske_SetTextEffect(BYTE EffectID, DWORD FirstColor, DWORD SecondColor)

 {

 	if (EffectID>MAXPREDEFINEDEFFECTS) return; 

-	if (EffectID==-1) meCurrentEffect.EffectID=-1;

+	if (EffectID == -1) meCurrentEffect.EffectID = -1;

 	else

 	{

-		meCurrentEffect.EffectID=EffectID;

-		meCurrentEffect.EffectMatrix=ModernEffectsEnum[EffectID];

-		meCurrentEffect.EffectColor1=FirstColor;

-		meCurrentEffect.EffectColor2=SecondColor;

+		meCurrentEffect.EffectID = EffectID;

+		meCurrentEffect.EffectMatrix = ModernEffectsEnum[EffectID];

+		meCurrentEffect.EffectColor1 = FirstColor;

+		meCurrentEffect.EffectColor2 = SecondColor;

 	}

 }

 

@@ -2749,10 +2749,10 @@ BOOL ske_ResetTextEffect(HDC hdc)
 {

 	int i;

 	if (!pEffectStack || !pEffectStack->realCount) return TRUE;

-	for (i=0; i<pEffectStack->realCount; i++)

-		if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc==hdc)

+	for (i = 0; i < pEffectStack->realCount; i++)

+		if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc == hdc)

 		{

-			EFFECTSSTACKITEM * effect=(EFFECTSSTACKITEM*)(pEffectStack->items[i]);

+			EFFECTSSTACKITEM * effect = (EFFECTSSTACKITEM*)(pEffectStack->items[i]);

 			mir_free_and_nill(effect);

 			List_Remove(pEffectStack,i);

 			return TRUE;

@@ -2763,29 +2763,29 @@ BOOL ske_ResetTextEffect(HDC hdc)
 BOOL ske_SelectTextEffect(HDC hdc, BYTE EffectID, DWORD FirstColor, DWORD SecondColor)

 {

 	if (EffectID>MAXPREDEFINEDEFFECTS) return 0; 

-	if (EffectID==-1) return ske_ResetTextEffect(hdc);

+	if (EffectID == -1) return ske_ResetTextEffect(hdc);

 	if (!pEffectStack)

 	{

-		pEffectStack=List_Create(0,1);

+		pEffectStack = List_Create(0,1);

 	}

 	{

 		int i;

-		for (i=0; i<pEffectStack->realCount; i++)

-			if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc==hdc)

+		for (i = 0; i < pEffectStack->realCount; i++)

+			if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc == hdc)

 			{

-				EFFECTSSTACKITEM * effect=(EFFECTSSTACKITEM*)(pEffectStack->items[i]);

-				effect->EffectID=EffectID;		    

-				effect->FirstColor=FirstColor;

-				effect->SecondColor=SecondColor;

+				EFFECTSSTACKITEM * effect = (EFFECTSSTACKITEM*)(pEffectStack->items[i]);

+				effect->EffectID = EffectID;		    

+				effect->FirstColor = FirstColor;

+				effect->SecondColor = SecondColor;

 				return TRUE;

 			}

 	}

 	{

-		EFFECTSSTACKITEM * effect=(EFFECTSSTACKITEM *) mir_alloc(sizeof(EFFECTSSTACKITEM));

-		effect->hdc=hdc;

-		effect->EffectID=EffectID;

-		effect->FirstColor=FirstColor;

-		effect->SecondColor=SecondColor;

+		EFFECTSSTACKITEM * effect = (EFFECTSSTACKITEM *) mir_alloc(sizeof(EFFECTSSTACKITEM));

+		effect->hdc = hdc;

+		effect->EffectID = EffectID;

+		effect->FirstColor = FirstColor;

+		effect->SecondColor = SecondColor;

 		List_Insert(pEffectStack, effect, 0);

 		return TRUE;

 	}	  

@@ -2794,17 +2794,17 @@ BOOL ske_SelectTextEffect(HDC hdc, BYTE EffectID, DWORD FirstColor, DWORD Second
 

 static BOOL ske_GetTextEffect(HDC hdc, MODERNEFFECT * modernEffect)

 {

-	int i=0;

+	int i = 0;

 	if (!pEffectStack || !pEffectStack->realCount) return FALSE;

 	if (!modernEffect) return FALSE;

-	for (i=0; i<pEffectStack->realCount; i++)

-		if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc==hdc)

+	for (i = 0; i < pEffectStack->realCount; i++)

+		if (pEffectStack->items[i] && ((EFFECTSSTACKITEM*)(pEffectStack->items[i]))->hdc == hdc)

 		{

-			EFFECTSSTACKITEM * effect=(EFFECTSSTACKITEM*)(pEffectStack->items[i]);

-			modernEffect->EffectID=effect->EffectID;		    

-			modernEffect->EffectColor1=effect->FirstColor;

-			modernEffect->EffectColor2=effect->SecondColor;

-			modernEffect->EffectMatrix=ModernEffectsEnum[effect->EffectID];

+			EFFECTSSTACKITEM * effect = (EFFECTSSTACKITEM*)(pEffectStack->items[i]);

+			modernEffect->EffectID = effect->EffectID;		    

+			modernEffect->EffectColor1 = effect->FirstColor;

+			modernEffect->EffectColor2 = effect->SecondColor;

+			modernEffect->EffectMatrix = ModernEffectsEnum[effect->EffectID];

 			return TRUE;

 		}

 		return FALSE;

@@ -2815,10 +2815,10 @@ static BOOL ske_DrawTextEffect(BYTE* destPt,BYTE* maskPt, DWORD width, DWORD hei
 	sbyte *buf;

 	sbyte *outbuf;

 	sbyte *bufline, *buflineTop, *buflineMid;

-	int sign=0;

+	int sign = 0;

 	BYTE *maskline,*destline;

 	BYTE al,rl,gl,bl,ad,rd,gd,bd;

-	int k=0;

+	int k = 0;

 	DWORD x,y;

 	sbyte *matrix;

 	BYTE mcTopStart;

@@ -2826,129 +2826,129 @@ static BOOL ske_DrawTextEffect(BYTE* destPt,BYTE* maskPt, DWORD width, DWORD hei
 	BYTE mcLeftStart;

 	BYTE mcRightEnd;

 	BYTE effectCount;

-	int minX=width;

-	int maxX=0;

-	int minY=height;

-	int maxY=0;

-	if (effect->EffectID==0xFF) return FALSE;

+	int minX = width;

+	int maxX = 0;

+	int minY = height;

+	int maxY = 0;

+	if (effect->EffectID == 0xFF) return FALSE;

 	if (!width || ! height) return FALSE;

 	if (!destPt) return FALSE;

-	buf=(sbyte*)malloc(width*height*sizeof(BYTE));

+	buf = (sbyte*)malloc(width*height*sizeof(BYTE));

 	{

-		matrix=effect->EffectMatrix.matrix;

-		mcTopStart=2-effect->EffectMatrix.topEffect;

-		mcBottomEnd=3+effect->EffectMatrix.bottomEffect;

-		mcLeftStart=2-effect->EffectMatrix.leftEffect;

-		mcRightEnd=3+effect->EffectMatrix.rightEffect;

-		effectCount=effect->EffectMatrix.cycleCount;

+		matrix = effect->EffectMatrix.matrix;

+		mcTopStart = 2-effect->EffectMatrix.topEffect;

+		mcBottomEnd = 3+effect->EffectMatrix.bottomEffect;

+		mcLeftStart = 2-effect->EffectMatrix.leftEffect;

+		mcRightEnd = 3+effect->EffectMatrix.rightEffect;

+		effectCount = effect->EffectMatrix.cycleCount;

 	}

-	al=255-((BYTE)(effect->EffectColor1>>24));

-	rl=GetRValue(effect->EffectColor1);

-	gl=GetGValue(effect->EffectColor1);

-	bl=GetBValue(effect->EffectColor1);

-	rd=GetRValue(effect->EffectColor2);

-	gd=GetGValue(effect->EffectColor2);

-	bd=GetBValue(effect->EffectColor2);

-	ad=255-((BYTE)(effect->EffectColor2>>24));

-	rd=GetRValue(effect->EffectColor2);

-	gd=GetGValue(effect->EffectColor2);

-	bd=GetBValue(effect->EffectColor2);

+	al = 255-((BYTE)(effect->EffectColor1>>24));

+	rl = GetRValue(effect->EffectColor1);

+	gl = GetGValue(effect->EffectColor1);

+	bl = GetBValue(effect->EffectColor1);

+	rd = GetRValue(effect->EffectColor2);

+	gd = GetGValue(effect->EffectColor2);

+	bd = GetBValue(effect->EffectColor2);

+	ad = 255-((BYTE)(effect->EffectColor2>>24));

+	rd = GetRValue(effect->EffectColor2);

+	gd = GetGValue(effect->EffectColor2);

+	bd = GetBValue(effect->EffectColor2);

 

 	//Fill buffer by mid values of image

-	for (y=0; y<height; y++)

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

 	{

-		bufline=buf+y*width;

-		maskline=maskPt+((y*width)<<2);

-		for (x=0; x<width; x++)

+		bufline = buf+y*width;

+		maskline = maskPt+((y*width) << 2);

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

 		{

-			BYTE a=(sbyte)(DWORD)((maskline[0]+maskline[2]+maskline[1]+maskline[1])>>4);

-			*bufline=a;

-			if (a!=0)

+			BYTE a = (sbyte)(DWORD)((maskline[0]+maskline[2]+maskline[1]+maskline[1])>>4);

+			*bufline = a;

+			if (a != 0)

 			{

-				minX=min((int)x,minX);

-				minY=min((int)y,minY);

-				maxX=max((int)x,maxX);

-				maxY=max((int)y,maxY);

+				minX = min((int)x,minX);

+				minY = min((int)y,minY);

+				maxX = max((int)x,maxX);

+				maxY = max((int)y,maxY);

 			}

 			bufline++;

-			maskline+=4;

+			maskline += 4;

 		}

 	}

 	//Here perform effect on buffer and place results to outbuf

-	for (k=0; k<(effectCount&0x7F); k++)

+	for (k = 0; k < (effectCount&0x7F); k++)

 	{

 		minX = max( 0,           minX + mcLeftStart - 2 );

 		minY = max( 0,           minY + mcTopStart  - 2 );

 		maxX = min( (int)width,  maxX + mcRightEnd  - 1 );

 		maxY = min( (int)height, maxY + mcBottomEnd - 1 );

 

-		outbuf=(sbyte*)malloc(width*height*sizeof(sbyte));

+		outbuf = (sbyte*)malloc(width*height*sizeof(sbyte));

 		memset(outbuf,0,width*height*sizeof(sbyte));

-		for (y=(DWORD)minY; y<(DWORD)maxY; y++)

+		for (y = (DWORD)minY; y < (DWORD)maxY; y++)

 		{

 			int val;

-			bufline=outbuf+y*width+minX;

-			buflineMid=buf+y*width+minX; 

-			for (x=(DWORD)minX; x<(DWORD)maxX; x++)

+			bufline = outbuf+y*width+minX;

+			buflineMid = buf+y*width+minX; 

+			for (x = (DWORD)minX; x < (DWORD)maxX; x++)

 			{			

 				int matrixHor,matrixVer;

-				val=0;			

-				for (matrixVer=mcTopStart; matrixVer<mcBottomEnd; matrixVer++)

+				val = 0;			

+				for (matrixVer = mcTopStart; matrixVer < mcBottomEnd; matrixVer++)

 				{

 					int buflineStep = width*(matrixVer-2);

-					int as=y+matrixVer-2;

-					sbyte * buflineTopS=NULL;

-					if (as>=0 && (DWORD)as<height) buflineTopS=buflineMid+buflineStep;

+					int as = y+matrixVer-2;

+					sbyte * buflineTopS = NULL;

+					if (as >= 0 && (DWORD)as < height) buflineTopS = buflineMid+buflineStep;

 

-					for (matrixHor=mcLeftStart; matrixHor<mcRightEnd;matrixHor++)

+					for (matrixHor = mcLeftStart; matrixHor < mcRightEnd;matrixHor++)

 					{						

-						int a=as;

+						int a = as;

 						buflineTop = buflineTopS;

-						a=x+matrixHor-2;

-						if (buflineTop && a>=0 && (DWORD)a<width) buflineTop+=matrixHor-2;

-						else buflineTop=NULL;

+						a = x+matrixHor-2;

+						if (buflineTop && a >= 0 && (DWORD)a < width) buflineTop += matrixHor-2;

+						else buflineTop = NULL;

 						if (buflineTop) 

-							val+=((*buflineTop)*matrix[matrixVer*5+matrixHor]); 					

+							val += ((*buflineTop)*matrix[matrixVer*5+matrixHor]); 					

 					}

 				}

-				val=(val+1)>>5;

-				*bufline=(sbyte)((val>127)?127:(val<-125)?-125:val);

+				val = (val+1)>>5;

+				*bufline = (sbyte)((val>127)?127:(val < -125)?-125:val);

 				bufline++;

 				buflineMid++;

 			}

 		}

 		free(buf);

-		buf=outbuf;

+		buf = outbuf;

 	}

 	{

 		BYTE r1,b1,g1,a1;

-		b1=bl; r1=rl; g1=gl; a1=al; sign=1;

+		b1 = bl; r1 = rl; g1 = gl; a1 = al; sign = 1;

 		//perform out to dest

-		for (y=0; y<height; y++)

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

 		{		

-			bufline=buf+y*width;

-			destline=destPt+((y*width)<<2);

-			for (x=0; x<width; x++)

+			bufline = buf+y*width;

+			destline = destPt+((y*width) << 2);

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

 			{

-				sbyte val=*bufline;

-				BYTE absVal=((val<0)?-val:val);

+				sbyte val = *bufline;

+				BYTE absVal = ((val < 0)?-val:val);

 

-				if (val!=0)

+				if (val != 0)

 				{	

-					if (val>0 && sign<0)

-					{ b1=bl; r1=rl; g1=gl; a1=al; sign=1;}

-					else if (val<0 && sign>0)

-					{ b1=bd; r1=rd; g1=gd; a1=ad; sign=-1;}

+					if (val>0 && sign < 0)

+					{ b1 = bl; r1 = rl; g1 = gl; a1 = al; sign = 1;}

+					else if (val < 0 && sign>0)

+					{ b1 = bd; r1 = rd; g1 = gd; a1 = ad; sign = -1;}

 

-					absVal=absVal*a1/255;				

+					absVal = absVal*a1/255;				

 

-					destline[0]=((destline[0]*(128-absVal))+absVal*b1)>>7;

-					destline[1]=((destline[1]*(128-absVal))+absVal*g1)>>7;

-					destline[2]=((destline[2]*(128-absVal))+absVal*r1)>>7;

-					destline[3]+=((255-destline[3])*(a1*absVal))/32640;				

+					destline[0] = ((destline[0]*(128-absVal))+absVal*b1)>>7;

+					destline[1] = ((destline[1]*(128-absVal))+absVal*g1)>>7;

+					destline[2] = ((destline[2]*(128-absVal))+absVal*r1)>>7;

+					destline[3] += ((255-destline[3])*(a1*absVal))/32640;				

 				}

 				bufline++;

-				destline+=4;

+				destline += 4;

 			}

 		}

 		free(buf);

@@ -2980,7 +2980,7 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 

 		for ( int i = 0; i < 256; i++ )

 		{

-			gammaTbl[i]= (BYTE)( 255 * pow( (double)i / 255, gammaCfPw ));

+			gammaTbl[i] = (BYTE)( 255 * pow( (double)i / 255, gammaCfPw ));

 			blueMulTbl[i] = i * blueCf;

 			redMulTbl[i] = i * redCf;

 			greenMulTbl[i] = i * greenCf;

@@ -3004,9 +3004,9 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 		GetBitmapBits( hDestBitmap, bmpDest.bmHeight*bmpDest.bmWidthBytes, pDestBits );

 	}

 	else 

-		pDestBits=(BYTE*)bmpDest.bmBits;

+		pDestBits = (BYTE*)bmpDest.bmBits;

 

-	BOOL isDest16bit=( bmpDest.bmBitsPixel ) != 32;

+	BOOL isDest16bit = ( bmpDest.bmBitsPixel ) !=32;

 

 

 	// Creating offscreen buffer

@@ -3064,7 +3064,7 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 

 	// Calc sizes and offsets

 

-	textSize.cx += 2;             // CORRECTION: for italic

+	textSize.cx  += 2;             // CORRECTION: for italic

 

 	int drx = 0;                  // x-axis offset of draw point

 

@@ -3102,8 +3102,8 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 		textSize.cy = workRectHeight;

 	}

 

-	textSize.cx += 4;    // CORRECTION: for effects ???

-	textSize.cy += 4;	 // CORRECTION: for effects ???

+	textSize.cx  += 4;    // CORRECTION: for effects ???

+	textSize.cy  += 4;	 // CORRECTION: for effects ???

 

 	if ( textSize.cx > 0 && textSize.cy > 0 )     // Ok we need to paint

 	{

@@ -3112,14 +3112,14 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 		//Create bitmap image for offscreen

 		BYTE * bits     = NULL;

 		HBITMAP hbmp    = ske_CreateDIB32Point( textSize.cx, textSize.cy, (void**)&bits );

-		if ( bits != NULL ) 

+		if ( bits !=NULL ) 

 		{

 			HBITMAP holdbmp = (HBITMAP)SelectObject( hOffscreenDC, hbmp );

 

 			//Create buffer bitmap image for temp text

 			BYTE *  bufbits  = NULL;

 			HBITMAP bufbmp   = ske_CreateDIB32Point( textSize.cx, textSize.cy, (void**)&bufbits );

-			if ( bufbits != NULL )

+			if ( bufbits !=NULL )

 			{

 				HDC     bufDC     = CreateCompatibleDC( hDC );

 				HBITMAP bufoldbmp = (HBITMAP)SelectObject( bufDC, bufbmp );

@@ -3144,8 +3144,8 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 				drawRect.bottom = textSize.cy;

 

 				DWORD x,y;

-				DWORD width=textSize.cx;

-				DWORD heigh=textSize.cy;

+				DWORD width = textSize.cx;

+				DWORD heigh = textSize.cy;

 

 				BYTE * pDestScanLine;

 				BYTE * pBufScanLine;

@@ -3159,26 +3159,26 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 

 				for ( y = 2; y < heigh - 2; y++ )

 				{

-					int lineBytes = y * (width<<2);

+					int lineBytes = y * (width << 2);

 					

 					pDestScanLine = bits + lineBytes;

 					pBufScanLine  = bufbits + lineBytes;

 					

 					for ( x = 2; x < width - 2; x++)

 					{

-						pix    = pDestScanLine + ( x<<2 );

-						bufpix = pBufScanLine  + ( x<<2 );

+						pix    = pDestScanLine + ( x << 2 );

+						bufpix = pBufScanLine  + ( x << 2 );

 

 						// Monochromatic

 						BYTE bx = gammaTbl[ bufpix[0] ];

 						BYTE gx = gammaTbl[ bufpix[1] ];

 						BYTE rx = gammaTbl[ bufpix[2] ];

 

-						if ( al != 255 )

+						if ( al !=255 )

 						{

-							bx*=al/255;

-							gx*=al/255;

-							rx*=al/255;

+							bx *= al/255;

+							gx *= al/255;

+							rx *= al/255;

 						}

 						BYTE ax = (BYTE)( ( (DWORD)rx*77 + (DWORD)gx * 151 + (DWORD)bx *28 + 128 ) / 256 );

 

@@ -3187,19 +3187,19 @@ static int ske_AlphaTextOut (HDC hDC, LPCTSTR lpString, int nCount, RECT * lpRec
 							//Normalize components to gray

 							BYTE axx = 255 - ( ( r + g + b ) >> 2 ) ; // Coefficient of grayance, more white font - more gray edges

 							WORD atx = ax * (255 - axx);

-							bx=( atx + bx * axx )/255;

-							gx=( atx + gx * axx )/255;

-							rx=( atx + rx * axx )/255;

+							bx = ( atx + bx * axx )/255;

+							gx = ( atx + gx * axx )/255;

+							rx = ( atx + rx * axx )/255;

 

 							short rrx, grx, brx;

-							brx=(short)((b-pix[0])*bx/255);

-							grx=(short)((g-pix[1])*gx/255);

-							rrx=(short)((r-pix[2])*rx/255);

-

-							pix[0]+=brx;

-							pix[1]+=grx;

-							pix[2]+=rrx;

-							pix[3]=(BYTE)(ax+(BYTE)(255-ax)*pix[3]/255);

+							brx = (short)((b-pix[0])*bx/255);

+							grx = (short)((g-pix[1])*gx/255);

+							rrx = (short)((r-pix[2])*rx/255);

+

+							pix[0] += brx;

+							pix[1] += grx;

+							pix[2] += rrx;

+							pix[3] = (BYTE)(ax+(BYTE)(255-ax)*pix[3]/255);

 						}

 					}

 				}

@@ -3236,9 +3236,9 @@ static int ske_DrawTextWithEffectWorker( HDC hdc, LPCTSTR lpString, int nCount,
     if (format&DT_CALCRECT) return DrawText(hdc,lpString,nCount,lpRect,format);

 

     if (format&DT_RTLREADING) SetTextAlign(hdc,TA_RTLREADING);

-    DWORD color=GetTextColor(hdc);

+    DWORD color = GetTextColor(hdc);

 

-    RECT r=*lpRect;	

+    RECT r = *lpRect;	

     OffsetRect(&r,1,1);

     DWORD form = format;

     if ( effect && effect->effectIndex )

@@ -3255,16 +3255,16 @@ static int ske_DrawTextWithEffectWorker( HDC hdc, LPCTSTR lpString, int nCount,
 INT_PTR ske_Service_DrawTextWithEffect( WPARAM wParam, LPARAM lParam )

 {

     DrawTextWithEffectParam * p = ( DrawTextWithEffectParam * ) wParam;

-    if ( p->cbSize != sizeof(DrawTextWithEffectParam))

+    if ( p->cbSize !=sizeof(DrawTextWithEffectParam))

         return FALSE;

     return ske_DrawTextWithEffectWorker( p->hdc, p->lpchText, p->cchText, p->lprc, p->dwDTFormat, p->pEffect );

 }

 

 BOOL ske_DrawTextA(HDC hdc, char * lpString, int nCount, RECT * lpRect, UINT format)

 {

-	TCHAR *buf=mir_a2u(lpString);

+	TCHAR *buf = mir_a2u(lpString);

 	BOOL res;

-	res=ske_DrawText(hdc,buf,nCount,lpRect,format);

+	res = ske_DrawText(hdc,buf,nCount,lpRect,format);

 	mir_free(buf);

 	return res;

 }

@@ -3272,15 +3272,15 @@ BOOL ske_DrawTextA(HDC hdc, char * lpString, int nCount, RECT * lpRect, UINT for
 

 BOOL ske_DrawText(HDC hdc, LPCTSTR lpString, int nCount, RECT * lpRect, UINT format)

 {

-	DWORD form=0, color=0;

-	RECT r=*lpRect;	

+	DWORD form = 0, color = 0;

+	RECT r = *lpRect;	

 	OffsetRect(&r,1,1);

 	if (format&DT_RTLREADING) SetTextAlign(hdc,TA_RTLREADING);

 	if (format&DT_CALCRECT) return DrawText(hdc,lpString,nCount,lpRect,format);

 	if (format&DT_FORCENATIVERENDER || g_CluiData.fDisableSkinEngine) 

 		return DrawText(hdc,lpString,nCount,lpRect,format&~DT_FORCENATIVERENDER);

-	form=format;

-	color=GetTextColor(hdc);

+	form = format;

+	color = GetTextColor(hdc);

 	if (!g_CluiData.fGDIPlusFail &&0) ///text via gdi+

 	{

 		TextOutWithGDIp(hdc,lpRect->left,lpRect->top,lpString,nCount);

@@ -3291,13 +3291,13 @@ BOOL ske_DrawText(HDC hdc, LPCTSTR lpString, int nCount, RECT * lpRect, UINT for
 

 HICON ske_ImageList_GetIcon(HIMAGELIST himl, int i, UINT fStyle)

 {

-	IMAGEINFO imi={0};

-	BITMAP bm={0};

-	if ( IsWinVerXPPlus()  && i!=-1 )

+	IMAGEINFO imi = {0};

+	BITMAP bm = {0};

+	if ( IsWinVerXPPlus()  && i != -1 )

 	{

 		ImageList_GetImageInfo(himl,i,&imi);

 		GetObject(imi.hbmImage,sizeof(bm),&bm);

-		if (bm.bmBitsPixel==32) //stupid bug of Microsoft 

+		if (bm.bmBitsPixel == 32) //stupid bug of Microsoft 

 			// Icons bitmaps are not premultiplied

 			// So Imagelist_AddIcon - premultiply alpha

 			// But incorrect - it is possible that alpha will

@@ -3306,45 +3306,45 @@ HICON ske_ImageList_GetIcon(HIMAGELIST himl, int i, UINT fStyle)
 			// TODO: Direct draw Icon from imagelist without 

 			// extracting of icon

 		{

-			BYTE * bits=NULL;	

-			bits=(BYTE*)bm.bmBits;

+			BYTE * bits = NULL;	

+			bits = (BYTE*)bm.bmBits;

 			if (!bits)

 			{

-				bits=(BYTE*)malloc(bm.bmWidthBytes*bm.bmHeight);

+				bits = (BYTE*)malloc(bm.bmWidthBytes*bm.bmHeight);

 				GetBitmapBits(imi.hbmImage,bm.bmWidthBytes*bm.bmHeight,bits);

 			} 

 			{

 				int iy;

 				BYTE *bcbits;

-				int wb=((imi.rcImage.right-imi.rcImage.left)*bm.bmBitsPixel>>3);

-				bcbits=bits+(bm.bmHeight-imi.rcImage.bottom)*bm.bmWidthBytes+(imi.rcImage.left*bm.bmBitsPixel>>3);

-				for (iy=0; iy<imi.rcImage.bottom-imi.rcImage.top; iy++)

+				int wb = ((imi.rcImage.right-imi.rcImage.left)*bm.bmBitsPixel>>3);

+				bcbits = bits+(bm.bmHeight-imi.rcImage.bottom)*bm.bmWidthBytes+(imi.rcImage.left*bm.bmBitsPixel>>3);

+				for (iy = 0; iy < imi.rcImage.bottom-imi.rcImage.top; iy++)

 				{

 					int x;

 					// Dummy microsoft fix - alpha can be less than r,g or b

 					// Looks like color channels in icons should be non-premultiplied with alpha

-					// But AddIcon store it premultiplied (incorrectly cause can be Alpha==7F, but R,G or B==80

+					// But AddIcon store it premultiplied (incorrectly cause can be Alpha == 7F, but R,G or B == 80

 					// So i check that alpha is 0x7F and set it to 0x80

-					DWORD *c=((DWORD*)bcbits);

-					for (x=0;x<imi.rcImage.right-imi.rcImage.left; x++)

+					DWORD *c = ((DWORD*)bcbits);

+					for (x = 0;x < imi.rcImage.right-imi.rcImage.left; x++)

 					{		  

-						DWORD val=*c;

-						BYTE a= (BYTE)((val)>>24);

-						if (a!=0)

+						DWORD val = *c;

+						BYTE a = (BYTE)((val)>>24);

+						if (a != 0)

 						{

-							BYTE r= (BYTE)((val&0xFF0000)>>16);

-							BYTE g= (BYTE)((val&0xFF00)>>8);

-							BYTE b= (BYTE)(val&0xFF);

-							if (a<r || a<g || a<b)

+							BYTE r = (BYTE)((val&0xFF0000)>>16);

+							BYTE g = (BYTE)((val&0xFF00)>>8);

+							BYTE b = (BYTE)(val&0xFF);

+							if (a < r || a < g || a < b)

 							{

-								a=max(max(r,g),b);

-								val=a<<24|r<<16|g<<8|b;

-								*c=val;

+								a = max(max(r,g),b);

+								val = a << 24|r << 16|g << 8|b;

+								*c = val;

 							}

 						}

 						c++;

 					}

-					bcbits+=bm.bmWidthBytes;

+					bcbits += bm.bmWidthBytes;

 				}

 			}  

 			if (!bm.bmBits) 

@@ -3369,20 +3369,20 @@ BOOL ske_ImageList_DrawEx( HIMAGELIST himl,int i,HDC hdcDst,int x,int y,int dx,i
 {    

 	//the routine to directly draw icon from image list without creating icon from there - should be some faster

 

-	if (i<0) return FALSE;

+	if (i < 0) return FALSE;

 

 	if (g_CluiData.fDisableSkinEngine)

 		return ImageList_DrawEx( himl, i, hdcDst, x, y, dx, dy, rgbBk, rgbFg, fStyle);

 

 	BYTE alpha;

-	if (fStyle&ILD_BLEND25) alpha=64;

-	else if (fStyle&ILD_BLEND50) alpha=128;

-	else alpha=255;

+	if (fStyle&ILD_BLEND25) alpha = 64;

+	else if (fStyle&ILD_BLEND50) alpha = 128;

+	else alpha = 255;

 

-	HICON hIcon=ske_ImageList_GetIcon(himl,i,ILD_NORMAL);        

+	HICON hIcon = ske_ImageList_GetIcon(himl,i,ILD_NORMAL);        

 	if (hIcon) 

 	{

-		ske_DrawIconEx(hdcDst,x,y,hIcon,dx?dx:GetSystemMetrics(SM_CXSMICON),dy?dy:GetSystemMetrics(SM_CYSMICON),0,NULL,DI_NORMAL|(alpha<<24));

+		ske_DrawIconEx(hdcDst,x,y,hIcon,dx?dx:GetSystemMetrics(SM_CXSMICON),dy?dy:GetSystemMetrics(SM_CYSMICON),0,NULL,DI_NORMAL|(alpha << 24));

 		DestroyIcon(hIcon);

 		return TRUE;

 	}

@@ -3392,7 +3392,7 @@ BOOL ske_ImageList_DrawEx( HIMAGELIST himl,int i,HDC hdcDst,int x,int y,int dx,i
 

 static INT_PTR ske_Service_DrawIconEx(WPARAM wParam,LPARAM lParam)

 {

-	DrawIconFixParam *p=(DrawIconFixParam*)wParam;

+	DrawIconFixParam *p = (DrawIconFixParam*)wParam;

 	if (!p) return 0;

 	return ske_DrawIconEx(p->hdc,p->xLeft,p->yTop,p->hIcon,p->cxWidth,p->cyWidth,p->istepIfAniCur,p->hbrFlickerFreeDraw,p->diFlags);

 }

@@ -3402,7 +3402,7 @@ BOOL ske_DrawIconEx(HDC hdcDst,int xLeft,int yTop,HICON hIcon,int cxWidth,int cy
 {

 

 	ICONINFO ici;

-	BYTE alpha=(BYTE)((diFlags&0xFF000000)>>24);

+	BYTE alpha = (BYTE)((diFlags&0xFF000000)>>24);

 

 

 	HDC imDC;

@@ -3414,13 +3414,13 @@ BOOL ske_DrawIconEx(HDC hdcDst,int xLeft,int yTop,HICON hIcon,int cxWidth,int cy
 	DWORD cx,cy,icy;

 	BYTE *t1, *t2, *t3;

 

-	BOOL NoDIBImage=FALSE;

+	BOOL NoDIBImage = FALSE;

 	//lockimagelist

-	BYTE hasmask=FALSE;

-	BYTE no32bit=FALSE;

-	BYTE noMirrorMask=FALSE;

-	BYTE hasalpha=FALSE;

-	alpha=alpha?alpha:255;

+	BYTE hasmask = FALSE;

+	BYTE no32bit = FALSE;

+	BYTE noMirrorMask = FALSE;

+	BYTE hasalpha = FALSE;

+	alpha = alpha?alpha:255;

 

 	if ( g_CluiData.fDisableSkinEngine && !(diFlags&0x80))

 		return DrawIconEx(hdcDst,xLeft,yTop,hIcon,cxWidth,cyWidth,istepIfAniCur,hbrFlickerFreeDraw,diFlags&0xFFFF7F);

@@ -3428,115 +3428,115 @@ BOOL ske_DrawIconEx(HDC hdcDst,int xLeft,int yTop,HICON hIcon,int cxWidth,int cy
 	if (!GetIconInfo(hIcon,&ici))  return 0;

 

 	GetObject(ici.hbmColor,sizeof(BITMAP),&imbt);

-	if (imbt.bmWidth*imbt.bmHeight==0)

+	if (imbt.bmWidth*imbt.bmHeight == 0)

 	{

 		DeleteObject(ici.hbmColor);

 		DeleteObject(ici.hbmMask);

 		return 0;

 	}

 	GetObject(ici.hbmMask,sizeof(BITMAP),&immaskbt);

-	cy=imbt.bmHeight;

+	cy = imbt.bmHeight;

 

-	if (imbt.bmBitsPixel!=32)

+	if (imbt.bmBitsPixel != 32)

 	{

 		HDC tempDC1;

 		HBITMAP otBmp;

-		no32bit=TRUE;

-		tempDC1=CreateCompatibleDC(hdcDst);

-		tBmp=ske_CreateDIB32(imbt.bmWidth,imbt.bmHeight);

+		no32bit = TRUE;

+		tempDC1 = CreateCompatibleDC(hdcDst);

+		tBmp = ske_CreateDIB32(imbt.bmWidth,imbt.bmHeight);

 		if (tBmp) 

 		{

 			GetObject(tBmp,sizeof(BITMAP),&imbt);

-			otBmp=(HBITMAP)SelectObject(tempDC1,tBmp);

+			otBmp = (HBITMAP)SelectObject(tempDC1,tBmp);

 			DrawIconEx(tempDC1,0,0,hIcon,imbt.bmWidth,imbt.bmHeight,istepIfAniCur,hbrFlickerFreeDraw,DI_IMAGE);   

-			noMirrorMask=TRUE;

+			noMirrorMask = TRUE;

 

 		}

 		SelectObject(tempDC1,otBmp);

 		mod_DeleteDC(tempDC1);

 	}

 	/*

-	if (imbt.bmBitsPixel!=32)

+	if (imbt.bmBitsPixel != 32)

 	{

 	HDC tempDC1;

 	HBITMAP otBmp;

-	no32bit=TRUE;

-	tempDC1=ske_RequestBufferDC(hdcDst,BUFFER_DRAWICON,imbt.bmWidth,imbt.bmHeight);

+	no32bit = TRUE;

+	tempDC1 = ske_RequestBufferDC(hdcDst,BUFFER_DRAWICON,imbt.bmWidth,imbt.bmHeight);

 	if (tempDC1) 

 	{

 	DrawIconEx(tempDC1,0,0,hIcon,imbt.bmWidth,imbt.bmHeight,istepIfAniCur,hbrFlickerFreeDraw,DI_IMAGE);   

-	noMirrorMask=TRUE;

+	noMirrorMask = TRUE;

 	ske_ReleaseBufferDC(tempDC1,2000); //keep buffer for 2 seconds

 	}        

 	}

 	*/

-	if (imbt.bmBits==NULL)

+	if (imbt.bmBits == NULL)

 	{

-		NoDIBImage=TRUE;

-		imimagbits=(BYTE*)malloc(cy*imbt.bmWidthBytes);

+		NoDIBImage = TRUE;

+		imimagbits = (BYTE*)malloc(cy*imbt.bmWidthBytes);

 		GetBitmapBits(ici.hbmColor,cy*imbt.bmWidthBytes,(void*)imimagbits);

 	}

-	else imimagbits=(BYTE*)imbt.bmBits;

+	else imimagbits = (BYTE*)imbt.bmBits;

 

 

-	if (immaskbt.bmBits==NULL)

+	if (immaskbt.bmBits == NULL)

 	{

-		immaskbits=(BYTE*)malloc(cy*immaskbt.bmWidthBytes);

+		immaskbits = (BYTE*)malloc(cy*immaskbt.bmWidthBytes);

 		GetBitmapBits(ici.hbmMask,cy*immaskbt.bmWidthBytes,(void*)immaskbits);

 	}

 	else 

-		immaskbits=(BYTE*)immaskbt.bmBits;

-	icy=imbt.bmHeight;

-	cx=imbt.bmWidth;

-	imDC=CreateCompatibleDC(hdcDst);

-	imBmp=ske_CreateDIB32Point(cx,icy,(void**)&imbits);

-	oldBmp=(HBITMAP)SelectObject(imDC,imBmp);

-	if (imbits!=NULL && imimagbits!=NULL && immaskbits!=NULL)

+		immaskbits = (BYTE*)immaskbt.bmBits;

+	icy = imbt.bmHeight;

+	cx = imbt.bmWidth;

+	imDC = CreateCompatibleDC(hdcDst);

+	imBmp = ske_CreateDIB32Point(cx,icy,(void**)&imbits);

+	oldBmp = (HBITMAP)SelectObject(imDC,imBmp);

+	if (imbits != NULL && imimagbits != NULL && immaskbits != NULL)

 	{

 		int x; int y;

 		int bottom,right,top,h;

 		int mwb,mwb2;

-		mwb=immaskbt.bmWidthBytes;

-		mwb2=imbt.bmWidthBytes;

-		bottom=icy;

-		right=cx;   

-		top=0;

-		h=icy;

-		for (y=top;(y<bottom)&&!hasmask; y++)

+		mwb = immaskbt.bmWidthBytes;

+		mwb2 = imbt.bmWidthBytes;

+		bottom = icy;

+		right = cx;   

+		top = 0;

+		h = icy;

+		for (y = top;(y < bottom)&&!hasmask; y++)

 		{ 

-			t1=immaskbits+y*mwb;

-			for (x=0; (x<mwb)&&!hasmask; x++)

-				hasmask|=(*(t1+x)!=0);

+			t1 = immaskbits+y*mwb;

+			for (x = 0; (x < mwb)&&!hasmask; x++)

+				hasmask |= (*(t1+x) != 0);

 		}

 

-		for (y=top;(y<bottom)&&!hasalpha; y++)

+		for (y = top;(y < bottom)&&!hasalpha; y++)

 		{

-			t1=imimagbits+(cy-y-1)*mwb2;

-			for (x=0; (x<right)&&!hasalpha; x++)

-				hasalpha|=(*(t1+(x<<2)+3)!=0);

+			t1 = imimagbits+(cy-y-1)*mwb2;

+			for (x = 0; (x < right)&&!hasalpha; x++)

+				hasalpha |= (*(t1+(x << 2)+3) != 0);

 		}

 

-		for (y=0; y<(int)icy; y++)

+		for (y = 0; y < (int)icy; y++)

 		{

-			t1=imimagbits+(h-y-1-top)*mwb2;

-			t2=imbits+(!no32bit?y:(icy-y-1))*mwb2;

-			t3=immaskbits+(noMirrorMask?y:(h-y-1-top))*mwb;

-			for (x=0; x<right; x++)

+			t1 = imimagbits+(h-y-1-top)*mwb2;

+			t2 = imbits+(!no32bit?y:(icy-y-1))*mwb2;

+			t3 = immaskbits+(noMirrorMask?y:(h-y-1-top))*mwb;

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

 			{

 				DWORD * src, *dest;               

-				BYTE mask=0;

+				BYTE mask = 0;

 				BYTE a = 0; 

-				src=(DWORD*)(t1+(x<<2));

-				dest=(DWORD*)(t2+(x<<2));              

+				src = (DWORD*)(t1+(x << 2));

+				dest = (DWORD*)(t2+(x << 2));              

 				if (hasalpha && !hasmask)  

-					a=((BYTE*)src)[3];

+					a = ((BYTE*)src)[3];

 				else

 				{ 

-					mask=((1<<(7-x%8))&(*(t3+(x>>3))))!=0;

+					mask = ((1 << (7-x%8))&(*(t3+(x>>3)))) != 0;

 					if (mask)// && !hasalpha)		

 					{

 						if (!hasalpha) 

-						{ *dest=0; continue; }

+						{ *dest = 0; continue; }

 						else

 						{ 

 							if (((BYTE*)src)[3]>0 )

@@ -3546,32 +3546,32 @@ BOOL ske_DrawIconEx(HDC hdcDst,int xLeft,int yTop,HICON hIcon,int cxWidth,int cy
 						}

 					}

 					else if (hasalpha || hasmask)

-						a=(((BYTE*)src)[3]>0?((BYTE*)src)[3]:255);

+						a = (((BYTE*)src)[3]>0?((BYTE*)src)[3]:255);

 					else if (!hasalpha && !hasmask)

-						a=255;

-					else {  *dest=0; continue; }

+						a = 255;

+					else {  *dest = 0; continue; }

 				}

 				if (a>0)

 				{

-					((BYTE*)dest)[3]=a;

-					((BYTE*)dest)[0]=((BYTE*)src)[0]*a/255;

-					((BYTE*)dest)[1]=((BYTE*)src)[1]*a/255;

-					((BYTE*)dest)[2]=((BYTE*)src)[2]*a/255;

+					((BYTE*)dest)[3] = a;

+					((BYTE*)dest)[0] = ((BYTE*)src)[0]*a/255;

+					((BYTE*)dest)[1] = ((BYTE*)src)[1]*a/255;

+					((BYTE*)dest)[2] = ((BYTE*)src)[2]*a/255;

 				}

 				else 

-					*dest=0;

+					*dest = 0;

 			}

 		}

 	}

 	{

-		BLENDFUNCTION bf={AC_SRC_OVER, diFlags&128, alpha, AC_SRC_ALPHA };   

+		BLENDFUNCTION bf = {AC_SRC_OVER, diFlags&128, alpha, AC_SRC_ALPHA };   

 		ske_AlphaBlend(hdcDst,xLeft,yTop,cxWidth, cyWidth, imDC,0,0, cx,icy,bf);

 	}

-	if (immaskbt.bmBits==NULL) free(immaskbits);

-	if (imbt.bmBits==NULL) free(imimagbits);

+	if (immaskbt.bmBits == NULL) free(immaskbits);

+	if (imbt.bmBits == NULL) free(imimagbits);

 	SelectObject(imDC,oldBmp);

 	DeleteObject(imBmp);

-	if(no32bit)DeleteObject(tBmp);

+	if (no32bit)DeleteObject(tBmp);

 	DeleteObject(ici.hbmColor);

 	DeleteObject(ici.hbmMask);

 	SelectObject(imDC,GetStockObject(DEFAULT_GUI_FONT));

@@ -3585,10 +3585,10 @@ int ske_PrepeareImageButDontUpdateIt(RECT * r)
 {

 	if (g_CluiData.fLayered)

 	{

-		mutex_bLockUpdate=1;

+		mutex_bLockUpdate = 1;

 		ske_DrawNonFramedObjects(TRUE,r);

 		ske_ValidateFrameImageProc(r);

-		mutex_bLockUpdate=0;

+		mutex_bLockUpdate = 0;

 		return 0;

 	}

 	else

@@ -3622,50 +3622,50 @@ static INT_PTR ske_Service_UpdateFrameImage(WPARAM wParam, LPARAM lParam)
 

 	RECT wnd;

 	FRAMEWND *frm;

-	BOOL NoCancelPost=0;

-	BOOL IsAnyQueued=0;

+	BOOL NoCancelPost = 0;

+	BOOL IsAnyQueued = 0;

 	if (!g_CluiData.mutexOnEdgeSizing)

 		GetWindowRect(pcli->hwndContactList,&wnd);

 	else

-		wnd=g_rcEdgeSizingRect;

+		wnd = g_rcEdgeSizingRect;

 	if (!g_CluiData.fLayered)

 	{

 		RedrawWindow((HWND)wParam,NULL,NULL,RDW_UPDATENOW|RDW_ERASE|RDW_INVALIDATE|RDW_FRAME);

 		return 0;

 	}

-	if (g_pCachedWindow==NULL) ske_ValidateFrameImageProc(&wnd);

-	else if (g_pCachedWindow->Width!=wnd.right-wnd.left || g_pCachedWindow->Height!=wnd.bottom-wnd.top) ske_ValidateFrameImageProc(&wnd);

-	else if (wParam==0) ske_ValidateFrameImageProc(&wnd);

+	if (g_pCachedWindow == NULL) ske_ValidateFrameImageProc(&wnd);

+	else if (g_pCachedWindow->Width != wnd.right-wnd.left || g_pCachedWindow->Height != wnd.bottom-wnd.top) ske_ValidateFrameImageProc(&wnd);

+	else if (wParam == 0) ske_ValidateFrameImageProc(&wnd);

 	else // all Ok Update Single Frame

 	{

 		// TO BE LOCKED OR PROXIED

-		frm=FindFrameByItsHWND((HWND)wParam);

+		frm = FindFrameByItsHWND((HWND)wParam);

 		if (!frm)  ske_ValidateFrameImageProc(&wnd);

 		// Validate frame, update window image and remove it from queue

 		else 

 		{

-			if(frm->UpdateRgn)

+			if (frm->UpdateRgn)

 			{

 				DeleteObject(frm->UpdateRgn);

-				frm->UpdateRgn=0;

+				frm->UpdateRgn = 0;

 			}

 			ske_ValidateSingleFrameImage(frm,0);

 			ske_UpdateWindowImage();

-			NoCancelPost=1;

+			NoCancelPost = 1;

 			//-- Remove frame from queue

 			if (flag_bUpdateQueued)

 			{

 				int i;

-				frm->bQueued=0;

-				for(i=0;i<g_nFramesCount;i++)

-					if(IsAnyQueued|=g_pfwFrames[i].bQueued) break;

+				frm->bQueued = 0;

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

+					if (IsAnyQueued |= g_pfwFrames[i].bQueued) break;

 			}

 		}

 	}       

 	if ((!NoCancelPost || !IsAnyQueued) && flag_bUpdateQueued) // no any queued updating cancel post or need to cancel post

 	{

-		flag_bUpdateQueued=0;

-		g_flag_bPostWasCanceled=1;

+		flag_bUpdateQueued = 0;

+		g_flag_bPostWasCanceled = 1;

 	}

 	return 1;   

 }

@@ -3674,15 +3674,15 @@ static INT_PTR ske_Service_InvalidateFrameImage(WPARAM wParam, LPARAM lParam)
 	if ( MirandaLoading()) return 0; 

 	if (wParam)

 	{

-		FRAMEWND *frm=FindFrameByItsHWND((HWND)wParam);

-		sPaintRequest * pr=(sPaintRequest*)lParam;

+		FRAMEWND *frm = FindFrameByItsHWND((HWND)wParam);

+		sPaintRequest * pr = (sPaintRequest*)lParam;

 		if (!g_CluiData.fLayered || (frm && frm->floating)) return InvalidateRect((HWND)wParam,pr?(RECT*)&(pr->rcUpdate):NULL,FALSE);

 		if (frm) 

 		{

-			if (frm->PaintCallbackProc!=NULL)

+			if (frm->PaintCallbackProc != NULL)

 			{

-				frm->PaintData=(sPaintRequest *)pr;

-				frm->bQueued=1;

+				frm->PaintData = (sPaintRequest *)pr;

+				frm->bQueued = 1;

 				if (pr)

 				{

 					HRGN r2;

@@ -3694,17 +3694,17 @@ static INT_PTR ske_Service_InvalidateFrameImage(WPARAM wParam, LPARAM lParam)
 						IntersectRect( &rcUpdate, &rcClient, &pr->rcUpdate );

 						if ( IsRectEmpty( &rcUpdate ))

 							return 0;

-						r2=CreateRectRgn( rcUpdate.left, rcUpdate.top, rcUpdate.right, rcUpdate.bottom );

+						r2 = CreateRectRgn( rcUpdate.left, rcUpdate.top, rcUpdate.right, rcUpdate.bottom );

 					}

 					else

 					{

 						RECT r;

 						GetClientRect(frm->hWnd,&r);

-						r2=CreateRectRgn(r.left,r.top,r.right,r.bottom);

+						r2 = CreateRectRgn(r.left,r.top,r.right,r.bottom);

 					}

 					if (!frm->UpdateRgn)

 					{

-						frm->UpdateRgn=CreateRectRgn(0,0,1,1);

+						frm->UpdateRgn = CreateRectRgn(0,0,1,1);

 						CombineRgn(frm->UpdateRgn,r2,0,RGN_COPY);                                            

 					}

 					else CombineRgn(frm->UpdateRgn,frm->UpdateRgn,r2,RGN_OR);

@@ -3723,8 +3723,8 @@ static INT_PTR ske_Service_InvalidateFrameImage(WPARAM wParam, LPARAM lParam)
 	if (!flag_bUpdateQueued||g_flag_bPostWasCanceled)

 		if (PostMessage(pcli->hwndContactList,UM_UPDATE,0,0))

 		{            

-			flag_bUpdateQueued=1;

-			g_flag_bPostWasCanceled=0;

+			flag_bUpdateQueued = 1;

+			g_flag_bPostWasCanceled = 0;

 		}

 		return 1;

 }

@@ -3733,45 +3733,45 @@ static INT_PTR ske_Service_InvalidateFrameImage(WPARAM wParam, LPARAM lParam)
 static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)                              // Calling frame paint proc

 {

 	if (!g_pCachedWindow) { TRACE("ske_ValidateSingleFrameImage calling without cached\n"); return 0;}

-	if (Frame->hWnd==(HWND)-1 && !Frame->PaintCallbackProc)  { TRACE("ske_ValidateSingleFrameImage calling without FrameProc\n"); return 0;}

+	if (Frame->hWnd == (HWND)-1 && !Frame->PaintCallbackProc)  { TRACE("ske_ValidateSingleFrameImage calling without FrameProc\n"); return 0;}

 	{ // if ok update image 

 		HDC hdc;

 		HBITMAP o,n;

 		RECT rcPaint,wnd;

-		RECT ru={0};

+		RECT ru = {0};

 		int w,h,x,y;

 		int w1,h1,x1,y1;

 

 		CLUI_SizingGetWindowRect(pcli->hwndContactList,&wnd);

-		rcPaint=Frame->wndSize;

+		rcPaint = Frame->wndSize;

 		{

 			int dx,dy,bx,by;

 			if (g_CluiData.mutexOnEdgeSizing)

 			{

-				dx=rcPaint.left-wnd.left;

-				dy=rcPaint.top-wnd.top;

-				bx=rcPaint.right-wnd.right;

-				by=rcPaint.bottom-wnd.bottom;

-				wnd=g_rcEdgeSizingRect;

-				rcPaint.left=wnd.left+dx;

-				rcPaint.top=wnd.top+dy;

-				rcPaint.right=wnd.right+bx;

-				rcPaint.bottom=wnd.bottom+by;

+				dx = rcPaint.left-wnd.left;

+				dy = rcPaint.top-wnd.top;

+				bx = rcPaint.right-wnd.right;

+				by = rcPaint.bottom-wnd.bottom;

+				wnd = g_rcEdgeSizingRect;

+				rcPaint.left = wnd.left+dx;

+				rcPaint.top = wnd.top+dy;

+				rcPaint.right = wnd.right+bx;

+				rcPaint.bottom = wnd.bottom+by;

 			}

 		}

 		//OffsetRect(&rcPaint,-wnd.left,-wnd.top);

-		w=rcPaint.right-rcPaint.left;

-		h=rcPaint.bottom-rcPaint.top;

-		if (w<=0 || h<=0) 

+		w = rcPaint.right-rcPaint.left;

+		h = rcPaint.bottom-rcPaint.top;

+		if (w <= 0 || h <= 0) 

 		{ 

 			TRACE("Frame size smaller than 0\n");

 			return 0;

 		}

-		x=rcPaint.left;

-		y=rcPaint.top;

-		hdc=CreateCompatibleDC(g_pCachedWindow->hImageDC);

-		n=ske_CreateDIB32(w,h);

-		o=(HBITMAP)SelectObject(hdc,n);

+		x = rcPaint.left;

+		y = rcPaint.top;

+		hdc = CreateCompatibleDC(g_pCachedWindow->hImageDC);

+		n = ske_CreateDIB32(w,h);

+		o = (HBITMAP)SelectObject(hdc,n);

 		{

 			if (Frame->UpdateRgn && !SkipBkgBlitting)

 			{

@@ -3779,20 +3779,20 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 				{

 					RECT rc;

 					GetClientRect(Frame->hWnd,&rc);

-					if (ru.top<0) ru.top=0;

-					if (ru.left<0) ru.left=0;

-					if (ru.right>rc.right) ru.right=rc.right;

-					if (ru.bottom>rc.bottom) ru.bottom=rc.bottom;

+					if (ru.top < 0) ru.top = 0;

+					if (ru.left < 0) ru.left = 0;

+					if (ru.right>rc.right) ru.right = rc.right;

+					if (ru.bottom>rc.bottom) ru.bottom = rc.bottom;

 				} 

 				if (!IsRectEmpty(&ru))

 				{

-					x1=ru.left;

-					y1=ru.top;

-					w1=ru.right-ru.left;

-					h1=ru.bottom-ru.top;

+					x1 = ru.left;

+					y1 = ru.top;

+					w1 = ru.right-ru.left;

+					h1 = ru.bottom-ru.top;

 				}

 				else

-				{x1=0; y1=0; w1=w; h1=h;}

+				{x1 = 0; y1 = 0; w1 = w; h1 = h;}

 				// copy image at hdc

 				if (SkipBkgBlitting)  //image already at foreground

 				{

@@ -3809,17 +3809,17 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 			    HRGN rgnUpdate;

 				RECT r;

 				GetClientRect(Frame->hWnd,&r);

-				rgnUpdate=CreateRectRgn(r.left,r.top,r.right,r.bottom); 

-				ru=r;

+				rgnUpdate = CreateRectRgn(r.left,r.top,r.right,r.bottom); 

+				ru = r;

 				if (!IsRectEmpty(&ru))

 				{

-					x1=ru.left;

-					y1=ru.top;

-					w1=ru.right-ru.left;

-					h1=ru.bottom-ru.top;

+					x1 = ru.left;

+					y1 = ru.top;

+					w1 = ru.right-ru.left;

+					h1 = ru.bottom-ru.top;

 				}

 				else

-				{x1=0; y1=0; w1=w; h1=h;}

+				{x1 = 0; y1 = 0; w1 = w; h1 = h;}

 				// copy image at hdc

 				if (SkipBkgBlitting)  //image already at foreground

 				{

@@ -3830,21 +3830,21 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 					BitBlt(hdc,x1,y1,w1,h1,g_pCachedWindow->hBackDC,x+x1,y+y1,SRCCOPY);  

 				}

 				Frame->PaintCallbackProc(Frame->hWnd,hdc,&r,rgnUpdate, Frame->dwFlags,Frame->PaintData);

-				ru=r;

+				ru = r;

 			    DeleteObject(rgnUpdate);

 			}

 			DeleteObject(Frame->UpdateRgn);

-			Frame->UpdateRgn=0;

+			Frame->UpdateRgn = 0;

 		}

 		if (!IsRectEmpty(&ru))

 		{

-			x1=ru.left;

-			y1=ru.top;

-			w1=ru.right-ru.left;

-			h1=ru.bottom-ru.top;

+			x1 = ru.left;

+			y1 = ru.top;

+			w1 = ru.right-ru.left;

+			h1 = ru.bottom-ru.top;

 		}

 		else

-		{x1=0; y1=0; w1=w; h1=h;}

+		{x1 = 0; y1 = 0; w1 = w; h1 = h;}

 		/*  if (!SkipBkgBlitting)

 		{

 		BitBlt(g_pCachedWindow->hImageDC,x+x1,y+y1,w1,h1,g_pCachedWindow->hBackDC,x+x1,y+y1,SRCCOPY);

@@ -3852,9 +3852,9 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 

 		*/  

 		{

-			//BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+			//BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 			BitBlt(g_pCachedWindow->hImageDC,x+x1,y+y1,w1,h1,hdc,x1,y1,SRCCOPY);

-			//BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+			//BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 			//MyAlphaBlend(g_pCachedWindow->hImageDC,x+x1,y+y1,w1,h1,hdc,x1,y1,w1,h1,bf);  

 		}

 		

@@ -3867,21 +3867,21 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 			RECT rDnBtn;

 			RECT rLine;

 			int dx,dy;

-			SCROLLBARINFO si={0};

-			si.cbSize=sizeof(SCROLLBARINFO);

+			SCROLLBARINFO si = {0};

+			si.cbSize = sizeof(SCROLLBARINFO);

 			fnGetScrollBarInfo(Frame->hWnd,OBJID_VSCROLL,&si);

-			rLine=(si.rcScrollBar);

-			rUpBtn=rLine;

-			rDnBtn=rLine;

-			rThumb=rLine;

-

-			rUpBtn.bottom=rUpBtn.top+si.dxyLineButton;

-			rDnBtn.top=rDnBtn.bottom-si.dxyLineButton;

-			rThumb.top=rLine.top+si.xyThumbTop;

-			rThumb.bottom=rLine.top+si.xyThumbBottom;

+			rLine = (si.rcScrollBar);

+			rUpBtn = rLine;

+			rDnBtn = rLine;

+			rThumb = rLine;

+

+			rUpBtn.bottom = rUpBtn.top+si.dxyLineButton;

+			rDnBtn.top = rDnBtn.bottom-si.dxyLineButton;

+			rThumb.top = rLine.top+si.xyThumbTop;

+			rThumb.bottom = rLine.top+si.xyThumbBottom;

 			{

-				dx=Frame->wndSize.right-rLine.right;

-				dy=-rLine.top+Frame->wndSize.top;

+				dx = Frame->wndSize.right-rLine.right;

+				dy = -rLine.top+Frame->wndSize.top;

 			}

 			OffsetRect(&rLine,dx,dy);

 			OffsetRect(&rUpBtn,dx,dy);

@@ -3890,13 +3890,13 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 			BitBlt(g_pCachedWindow->hImageDC,rLine.left,rLine.top,rLine.right-rLine.left,rLine.bottom-rLine.top,g_pCachedWindow->hBackDC,rLine.left,rLine.top,SRCCOPY);

 			{

 				char req[255];

-				_snprintf(req,sizeof(req),"Main,ID=ScrollBar,Frame=%s,Part=Back",Frame->szName);

+				_snprintf(req,sizeof(req),"Main,ID = ScrollBar,Frame = %s,Part = Back",Frame->szName);

 				SkinDrawGlyph(g_pCachedWindow->hImageDC,&rLine,&rLine,req);

-				_snprintf(req,sizeof(req),"Main,ID=ScrollBar,Frame=%s,Part=Thumb",Frame->szName);

+				_snprintf(req,sizeof(req),"Main,ID = ScrollBar,Frame = %s,Part = Thumb",Frame->szName);

 				SkinDrawGlyph(g_pCachedWindow->hImageDC,&rThumb,&rThumb,req);

-				_snprintf(req,sizeof(req),"Main,ID=ScrollBar,Frame=%s,Part=UpLineButton",Frame->szName);

+				_snprintf(req,sizeof(req),"Main,ID = ScrollBar,Frame = %s,Part = UpLineButton",Frame->szName);

 				SkinDrawGlyph(g_pCachedWindow->hImageDC,&rUpBtn,&rUpBtn,req);

-				_snprintf(req,sizeof(req),"Main,ID=ScrollBar,Frame=%s,Part=DownLineButton",Frame->szName);

+				_snprintf(req,sizeof(req),"Main,ID = ScrollBar,Frame = %s,Part = DownLineButton",Frame->szName);

 				SkinDrawGlyph(g_pCachedWindow->hImageDC,&rDnBtn,&rDnBtn,req);

 			}

 		}

@@ -3910,20 +3910,20 @@ static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting)
 

 int ske_BltBackImage (HWND destHWND, HDC destDC, RECT * BltClientRect)

 {

-	POINT ptMainWnd={0};

-	POINT ptChildWnd={0};

-	RECT from={0};

-	RECT w={0};

+	POINT ptMainWnd = {0};

+	POINT ptChildWnd = {0};

+	RECT from = {0};

+	RECT w = {0};

 	if (g_CluiData.fDisableSkinEngine)

 	{

 		FillRect(destDC,BltClientRect,GetSysColorBrush(COLOR_3DFACE));

 		return 0;

 	}

 	ske_ReCreateBackImage(FALSE,NULL);

-	if (BltClientRect) w=*BltClientRect;

+	if (BltClientRect) w = *BltClientRect;

 	else GetClientRect(destHWND,&w);

-	ptChildWnd.x=w.left;

-	ptChildWnd.y=w.top;

+	ptChildWnd.x = w.left;

+	ptChildWnd.y = w.top;

 	ClientToScreen(destHWND,&ptChildWnd);

 	ClientToScreen(pcli->hwndContactList,&ptMainWnd);

 	//TODO if main not relative to client area

@@ -3933,41 +3933,41 @@ int ske_BltBackImage (HWND destHWND, HDC destDC, RECT * BltClientRect)
 int ske_ReCreateBackImage(BOOL Erase,RECT *w)

 {

 	HBITMAP hb2;

-	RECT wnd={0};

-	BOOL IsNewCache=0;

+	RECT wnd = {0};

+	BOOL IsNewCache = 0;

 	if (g_CluiData.fDisableSkinEngine) return 0;

 	GetClientRect(pcli->hwndContactList,&wnd);

-	if (w) wnd=*w;

+	if (w) wnd = *w;

 	//-- Check cached.

-	if (g_pCachedWindow==NULL)

+	if (g_pCachedWindow == NULL)

 	{

 		//-- Create New Cache

 		{

-			g_pCachedWindow=(CURRWNDIMAGEDATA*)mir_calloc(sizeof(CURRWNDIMAGEDATA));

-			g_pCachedWindow->hScreenDC=GetDC(NULL);

-			g_pCachedWindow->hBackDC=CreateCompatibleDC(g_pCachedWindow->hScreenDC);

-			g_pCachedWindow->hImageDC=CreateCompatibleDC(g_pCachedWindow->hScreenDC);

-			g_pCachedWindow->Width=wnd.right-wnd.left;

-			g_pCachedWindow->Height=wnd.bottom-wnd.top;

-			if (g_pCachedWindow->Width!=0 && g_pCachedWindow->Height!=0)

+			g_pCachedWindow = (CURRWNDIMAGEDATA*)mir_calloc(sizeof(CURRWNDIMAGEDATA));

+			g_pCachedWindow->hScreenDC = GetDC(NULL);

+			g_pCachedWindow->hBackDC = CreateCompatibleDC(g_pCachedWindow->hScreenDC);

+			g_pCachedWindow->hImageDC = CreateCompatibleDC(g_pCachedWindow->hScreenDC);

+			g_pCachedWindow->Width = wnd.right-wnd.left;

+			g_pCachedWindow->Height = wnd.bottom-wnd.top;

+			if (g_pCachedWindow->Width != 0 && g_pCachedWindow->Height != 0)

 			{

-				g_pCachedWindow->hImageDIB=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

-				g_pCachedWindow->hBackDIB=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte));

-				g_pCachedWindow->hImageOld=(HBITMAP)SelectObject(g_pCachedWindow->hImageDC,g_pCachedWindow->hImageDIB);

-				g_pCachedWindow->hBackOld=(HBITMAP)SelectObject(g_pCachedWindow->hBackDC,g_pCachedWindow->hBackDIB);

+				g_pCachedWindow->hImageDIB = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

+				g_pCachedWindow->hBackDIB = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte));

+				g_pCachedWindow->hImageOld = (HBITMAP)SelectObject(g_pCachedWindow->hImageDC,g_pCachedWindow->hImageDIB);

+				g_pCachedWindow->hBackOld = (HBITMAP)SelectObject(g_pCachedWindow->hBackDC,g_pCachedWindow->hBackDIB);

 			}

 		}

-		IsNewCache=1;

+		IsNewCache = 1;

 	}   

-	if (g_pCachedWindow->Width!=wnd.right-wnd.left || g_pCachedWindow->Height!=wnd.bottom-wnd.top)		

+	if (g_pCachedWindow->Width != wnd.right-wnd.left || g_pCachedWindow->Height != wnd.bottom-wnd.top)		

 	{

-		HBITMAP hb1=NULL,hb2=NULL;

-		g_pCachedWindow->Width=wnd.right-wnd.left;

-		g_pCachedWindow->Height=wnd.bottom-wnd.top;

-		if (g_pCachedWindow->Width!=0 && g_pCachedWindow->Height!=0)

+		HBITMAP hb1 = NULL,hb2 = NULL;

+		g_pCachedWindow->Width = wnd.right-wnd.left;

+		g_pCachedWindow->Height = wnd.bottom-wnd.top;

+		if (g_pCachedWindow->Width != 0 && g_pCachedWindow->Height != 0)

 		{

-			hb1=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

-			hb2=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte)); 

+			hb1 = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

+			hb2 = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte)); 

 			SelectObject(g_pCachedWindow->hImageDC,hb1);

 			SelectObject(g_pCachedWindow->hBackDC,hb2);

 		}

@@ -3978,19 +3978,19 @@ int ske_ReCreateBackImage(BOOL Erase,RECT *w)
 		}

 		if (g_pCachedWindow->hImageDIB) DeleteObject(g_pCachedWindow->hImageDIB);

 		if (g_pCachedWindow->hBackDIB) DeleteObject(g_pCachedWindow->hBackDIB);

-		g_pCachedWindow->hImageDIB=hb1;

-		g_pCachedWindow->hBackDIB=hb2;

-		IsNewCache=1;

+		g_pCachedWindow->hImageDIB = hb1;

+		g_pCachedWindow->hBackDIB = hb2;

+		IsNewCache = 1;

 	}

-	if ((Erase || IsNewCache )&& (g_pCachedWindow->Width!=0 && g_pCachedWindow->Height!=0))

+	if ((Erase || IsNewCache )&& (g_pCachedWindow->Width != 0 && g_pCachedWindow->Height != 0))

 	{

 

-		hb2=ske_CreateDIB32(g_pCachedWindow->Width,g_pCachedWindow->Height); 

+		hb2 = ske_CreateDIB32(g_pCachedWindow->Width,g_pCachedWindow->Height); 

 		SelectObject(g_pCachedWindow->hBackDC,hb2);

 		DeleteObject(g_pCachedWindow->hBackDIB);

-		g_pCachedWindow->hBackDIB=hb2;

+		g_pCachedWindow->hBackDIB = hb2;

 		FillRect(g_pCachedWindow->hBackDC,&wnd,GetSysColorBrush(COLOR_BTNFACE));

-		SkinDrawGlyph(g_pCachedWindow->hBackDC,&wnd,&wnd,"Main,ID=Background,Opt=Non-Layered");

+		SkinDrawGlyph(g_pCachedWindow->hBackDC,&wnd,&wnd,"Main,ID = Background,Opt = Non-Layered");

 		ske_SetRectOpaque(g_pCachedWindow->hBackDC,&wnd);

 	}

 	return 1;

@@ -3998,28 +3998,28 @@ int ske_ReCreateBackImage(BOOL Erase,RECT *w)
 int ske_DrawNonFramedObjects(BOOL Erase,RECT *r)

 {

 	RECT w,wnd;

-	if (r) w=*r;

+	if (r) w = *r;

 	else CLUI_SizingGetWindowRect(pcli->hwndContactList,&w);

 	if (!g_CluiData.fLayered) return ske_ReCreateBackImage(FALSE,0);

-	if (g_pCachedWindow==NULL)

+	if (g_pCachedWindow == NULL)

 		return ske_ValidateFrameImageProc(&w);

 

-	wnd=w;

+	wnd = w;

 	OffsetRect(&w, -w.left, -w.top);

 	if (Erase)

 	{

 		HBITMAP hb2;

-		hb2=ske_CreateDIB32(g_pCachedWindow->Width,g_pCachedWindow->Height); 

+		hb2 = ske_CreateDIB32(g_pCachedWindow->Width,g_pCachedWindow->Height); 

 		SelectObject(g_pCachedWindow->hBackDC,hb2);

 		DeleteObject(g_pCachedWindow->hBackDIB);

-		g_pCachedWindow->hBackDIB=hb2;

+		g_pCachedWindow->hBackDIB = hb2;

 	}

 

-	SkinDrawGlyph(g_pCachedWindow->hBackDC,&w,&w,"Main,ID=Background");

+	SkinDrawGlyph(g_pCachedWindow->hBackDC,&w,&w,"Main,ID = Background");

 	//--Draw frames captions

 	{

 		int i;

-		for(i=0;i<g_nFramesCount;i++)

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

 			if (g_pfwFrames[i].TitleBar.ShowTitleBar && g_pfwFrames[i].visible && !g_pfwFrames[i].floating)

 			{

 				RECT rc;

@@ -4029,62 +4029,62 @@ int ske_DrawNonFramedObjects(BOOL Erase,RECT *r)
 				Sync( DrawTitleBar, g_pCachedWindow->hBackDC, &rc, g_pfwFrames[i].id );

 			}

 	}

-	g_mutex_bLockUpdating=1;

+	g_mutex_bLockUpdating = 1;

 

-	flag_bJustDrawNonFramedObjects=1;

+	flag_bJustDrawNonFramedObjects = 1;

 	return 0;

 }

 int ske_ValidateFrameImageProc(RECT * r)                                // Calling queued frame paint procs and refresh image

 {

-	RECT wnd={0};

-	BOOL IsNewCache=0;

-	BOOL IsForceAllPainting=0;

-	if (r) wnd=*r;

+	RECT wnd = {0};

+	BOOL IsNewCache = 0;

+	BOOL IsForceAllPainting = 0;

+	if (r) wnd = *r;

 	else GetWindowRect(pcli->hwndContactList,&wnd);

-	if (wnd.right-wnd.left==0 || wnd.bottom-wnd.top==0) return 0;

-	g_mutex_bLockUpdating=1;

+	if (wnd.right-wnd.left == 0 || wnd.bottom-wnd.top == 0) return 0;

+	g_mutex_bLockUpdating = 1;

 	//-- Check cached.

-	if (g_pCachedWindow==NULL)

+	if (g_pCachedWindow == NULL)

 	{

 		//-- Create New Cache

 		{

-			g_pCachedWindow=(CURRWNDIMAGEDATA*)mir_calloc(sizeof(CURRWNDIMAGEDATA));

-			g_pCachedWindow->hScreenDC=GetDC(NULL);

-			g_pCachedWindow->hBackDC=CreateCompatibleDC(g_pCachedWindow->hScreenDC);

-			g_pCachedWindow->hImageDC=CreateCompatibleDC(g_pCachedWindow->hScreenDC);

-			g_pCachedWindow->Width=wnd.right-wnd.left;

-			g_pCachedWindow->Height=wnd.bottom-wnd.top;

-			g_pCachedWindow->hImageDIB=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

-			g_pCachedWindow->hBackDIB=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte));

-			g_pCachedWindow->hImageOld=(HBITMAP)SelectObject(g_pCachedWindow->hImageDC,g_pCachedWindow->hImageDIB);

-			g_pCachedWindow->hBackOld=(HBITMAP)SelectObject(g_pCachedWindow->hBackDC,g_pCachedWindow->hBackDIB);

+			g_pCachedWindow = (CURRWNDIMAGEDATA*)mir_calloc(sizeof(CURRWNDIMAGEDATA));

+			g_pCachedWindow->hScreenDC = GetDC(NULL);

+			g_pCachedWindow->hBackDC = CreateCompatibleDC(g_pCachedWindow->hScreenDC);

+			g_pCachedWindow->hImageDC = CreateCompatibleDC(g_pCachedWindow->hScreenDC);

+			g_pCachedWindow->Width = wnd.right-wnd.left;

+			g_pCachedWindow->Height = wnd.bottom-wnd.top;

+			g_pCachedWindow->hImageDIB = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

+			g_pCachedWindow->hBackDIB = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte));

+			g_pCachedWindow->hImageOld = (HBITMAP)SelectObject(g_pCachedWindow->hImageDC,g_pCachedWindow->hImageDIB);

+			g_pCachedWindow->hBackOld = (HBITMAP)SelectObject(g_pCachedWindow->hBackDC,g_pCachedWindow->hBackDIB);

 		}

-		IsNewCache=1;

+		IsNewCache = 1;

 	}   

-	if (g_pCachedWindow->Width!=wnd.right-wnd.left || g_pCachedWindow->Height!=wnd.bottom-wnd.top)

+	if (g_pCachedWindow->Width != wnd.right-wnd.left || g_pCachedWindow->Height != wnd.bottom-wnd.top)

 	{

 		HBITMAP hb1,hb2;

-		g_pCachedWindow->Width=wnd.right-wnd.left;

-		g_pCachedWindow->Height=wnd.bottom-wnd.top;

-		hb1=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

-		hb2=ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte)); 

+		g_pCachedWindow->Width = wnd.right-wnd.left;

+		g_pCachedWindow->Height = wnd.bottom-wnd.top;

+		hb1 = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hImageDIBByte));

+		hb2 = ske_CreateDIB32Point(g_pCachedWindow->Width,g_pCachedWindow->Height,(void**)&(g_pCachedWindow->hBackDIBByte)); 

 		SelectObject(g_pCachedWindow->hImageDC,hb1);

 		SelectObject(g_pCachedWindow->hBackDC,hb2);

 		DeleteObject(g_pCachedWindow->hImageDIB);

 		DeleteObject(g_pCachedWindow->hBackDIB);

-		g_pCachedWindow->hImageDIB=hb1;

-		g_pCachedWindow->hBackDIB=hb2;

-		IsNewCache=1;

+		g_pCachedWindow->hImageDIB = hb1;

+		g_pCachedWindow->hBackDIB = hb2;

+		IsNewCache = 1;

 	}

 	if (IsNewCache)

 	{

 		ske_DrawNonFramedObjects(0,&wnd);       

-		IsForceAllPainting=1;

+		IsForceAllPainting = 1;

 	}

 	if (flag_bJustDrawNonFramedObjects)

 	{

-		IsForceAllPainting=1;

-		flag_bJustDrawNonFramedObjects=0;

+		IsForceAllPainting = 1;

+		flag_bJustDrawNonFramedObjects = 0;

 	}

 	if (IsForceAllPainting) 

 	{ 

@@ -4094,20 +4094,20 @@ int ske_ValidateFrameImageProc(RECT * r)                                // Calli
 	//-- Validating frames

 	{ 

 		int i;

-		for(i=0;i<g_nFramesCount;i++)

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

 			if (g_pfwFrames[i].PaintCallbackProc && g_pfwFrames[i].visible && !g_pfwFrames[i].floating )

 				if (g_pfwFrames[i].bQueued || IsForceAllPainting)

 					ske_ValidateSingleFrameImage(&g_pfwFrames[i],IsForceAllPainting);

 	}

-	g_mutex_bLockUpdating=1;

+	g_mutex_bLockUpdating = 1;

 	ModernSkinButtonRedrawAll(0);

-	g_mutex_bLockUpdating=0;

+	g_mutex_bLockUpdating = 0;

 	if (!mutex_bLockUpdate)  ske_UpdateWindowImageRect(&wnd);

 	//-- Clear queue

 	{

 		Sync( QueueAllFramesUpdating, (BYTE)0 );

-		flag_bUpdateQueued=0;

-		g_flag_bPostWasCanceled=0;

+		flag_bUpdateQueued = 0;

+		g_flag_bPostWasCanceled = 0;

 	}

 	return 1;

 }

@@ -4133,14 +4133,14 @@ int ske_UpdateWindowImageRect(RECT * r)                                     // U
 {

 	//if not validity -> ValidateImageProc

 	//else Update using current alpha

-	RECT wnd=*r;

+	RECT wnd = *r;

 

 	if (!g_CluiData.fLayered) return ske_ReCreateBackImage(FALSE,0);

-	if (g_pCachedWindow==NULL) return ske_ValidateFrameImageProc(&wnd); 

-	if (g_pCachedWindow->Width!=wnd.right-wnd.left || g_pCachedWindow->Height!=wnd.bottom-wnd.top) return ske_ValidateFrameImageProc(&wnd);

+	if (g_pCachedWindow == NULL) return ske_ValidateFrameImageProc(&wnd); 

+	if (g_pCachedWindow->Width != wnd.right-wnd.left || g_pCachedWindow->Height != wnd.bottom-wnd.top) return ske_ValidateFrameImageProc(&wnd);

 	if (g_flag_bFullRepaint) 

 	{

-		g_flag_bFullRepaint=0; 

+		g_flag_bFullRepaint = 0; 

 		return ske_ValidateFrameImageProc(&wnd);

 	}

 	ske_JustUpdateWindowImageRect(&wnd);

@@ -4150,13 +4150,13 @@ int ske_UpdateWindowImageRect(RECT * r)                                     // U
 void ske_ApplyTransluency()

 {

 	int IsTransparancy;

-	HWND hwnd=pcli->hwndContactList;

-	BOOL layered=(GetWindowLongPtr(hwnd, GWL_EXSTYLE) & WS_EX_LAYERED)?TRUE:FALSE;

+	HWND hwnd = pcli->hwndContactList;

+	BOOL layered = (GetWindowLongPtr(hwnd, GWL_EXSTYLE) & WS_EX_LAYERED)?TRUE:FALSE;

 

-	IsTransparancy=g_CluiData.fSmoothAnimation || g_bTransparentFlag;

-	if (!g_bTransparentFlag && !g_CluiData.fSmoothAnimation && g_CluiData.bCurrentAlpha!=0)

-		g_CluiData.bCurrentAlpha=255;

-	if (!g_CluiData.fLayered && (/*(g_CluiData.bCurrentAlpha==255)||*/(g_proc_SetLayeredWindowAttributesNew && IsTransparancy)))

+	IsTransparancy = g_CluiData.fSmoothAnimation || g_bTransparentFlag;

+	if (!g_bTransparentFlag && !g_CluiData.fSmoothAnimation && g_CluiData.bCurrentAlpha != 0)

+		g_CluiData.bCurrentAlpha = 255;

+	if (!g_CluiData.fLayered && (/*(g_CluiData.bCurrentAlpha == 255)||*/(g_proc_SetLayeredWindowAttributesNew && IsTransparancy)))

 	{

 		if (!layered) SetWindowLongPtr(hwnd, GWL_EXSTYLE, GetWindowLongPtr(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED);

 		if (g_proc_SetLayeredWindowAttributesNew) g_proc_SetLayeredWindowAttributesNew(hwnd, RGB(0,0,0), (BYTE)g_CluiData.bCurrentAlpha, LWA_ALPHA);

@@ -4180,13 +4180,13 @@ int ske_JustUpdateWindowImage()
 int ske_JustUpdateWindowImageRect(RECT * rty)

 //Update window image

 {

-	BLENDFUNCTION bf={AC_SRC_OVER, 0,g_CluiData.bCurrentAlpha, AC_SRC_ALPHA };

-	POINT dest={0}, src={0};

+	BLENDFUNCTION bf = {AC_SRC_OVER, 0,g_CluiData.bCurrentAlpha, AC_SRC_ALPHA };

+	POINT dest = {0}, src = {0};

 	int res;

-	RECT wnd=*rty;

+	RECT wnd = *rty;

 

 	RECT rect;

-	SIZE sz={0};

+	SIZE sz = {0};

 

 	if (!g_CluiData.fLayered)

 	{

@@ -4194,18 +4194,18 @@ int ske_JustUpdateWindowImageRect(RECT * rty)
 		return 0;

 	}

 	if (!pcli->hwndContactList) return 0;

-	rect=wnd;

-	dest.x=rect.left;

-	dest.y=rect.top;

-	sz.cx=rect.right-rect.left;

-	sz.cy=rect.bottom-rect.top;

+	rect = wnd;

+	dest.x = rect.left;

+	dest.y = rect.top;

+	sz.cx = rect.right-rect.left;

+	sz.cy = rect.bottom-rect.top;

 	if (g_proc_UpdateLayeredWindow && g_CluiData.fLayered)

 	{

 		if (!(GetWindowLongPtr(pcli->hwndContactList, GWL_EXSTYLE)&WS_EX_LAYERED))

 			SetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE, GetWindowLongPtr(pcli->hwndContactList, GWL_EXSTYLE) |WS_EX_LAYERED);

 		Sync( SetAlpha, g_CluiData.bCurrentAlpha );

 

-		res=g_proc_UpdateLayeredWindow(pcli->hwndContactList,g_pCachedWindow->hScreenDC,&dest,&sz,g_pCachedWindow->hImageDC,&src,RGB(1,1,1),&bf,ULW_ALPHA);

+		res = g_proc_UpdateLayeredWindow(pcli->hwndContactList,g_pCachedWindow->hScreenDC,&dest,&sz,g_pCachedWindow->hImageDC,&src,RGB(1,1,1),&bf,ULW_ALPHA);

 		g_CluiData.fAeroGlass = false;

 		CLUI_UpdateAeroGlass();

 	}

@@ -4215,7 +4215,7 @@ int ske_JustUpdateWindowImageRect(RECT * rty)
 

 int ske_DrawImageAt(HDC hdc, RECT *rc)

 {

-	BLENDFUNCTION bf={AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

+	BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

 	BitBlt(g_pCachedWindow->hImageDC,rc->left,rc->top,rc->right-rc->left,rc->bottom-rc->top,g_pCachedWindow->hBackDC,rc->left,rc->top,SRCCOPY);

 	ske_AlphaBlend(g_pCachedWindow->hImageDC,rc->left,rc->top,rc->right-rc->left,rc->bottom-rc->top,hdc,0,0,rc->right-rc->left,rc->bottom-rc->top,bf);    

 	if (!g_mutex_bLockUpdating)

@@ -4234,33 +4234,33 @@ HBITMAP ske_GetCurrentWindowImage()
 

 static DWORD ske_HexToARGB(char * Hex)

 {

-	char buf[10]={0};

-	char buf2[11]={0};

+	char buf[10] = {0};

+	char buf2[11] = {0};

 	char * st;

 	BYTE alpha;

-	DWORD AARRGGBB=0;

+	DWORD AARRGGBB = 0;

 	_snprintf(buf,10,"%s\n",Hex);

-	if (buf[1]=='x' || buf[1]=='X')

+	if (buf[1] == 'x' || buf[1] == 'X')

 		_snprintf(buf2,11,"0x%s\n",buf+2);

 	else

 		_snprintf(buf2,11,"0x%s\n",buf);

-	buf2[10]='\0';

-	AARRGGBB=strtoul(buf2,&st,16); 

-	alpha=(BYTE)((AARRGGBB&0xFF000000)>>24);

-	alpha=255-((alpha==0)?255:alpha); 

-	AARRGGBB=(alpha<<24)+((AARRGGBB&0x00FF0000)>>16)+((AARRGGBB&0x000000FF)<<16)+(AARRGGBB&0x0000FF00);

+	buf2[10] = '\0';

+	AARRGGBB = strtoul(buf2,&st,16); 

+	alpha = (BYTE)((AARRGGBB&0xFF000000)>>24);

+	alpha = 255-((alpha == 0)?255:alpha); 

+	AARRGGBB = (alpha << 24)+((AARRGGBB&0x00FF0000)>>16)+((AARRGGBB&0x000000FF) << 16)+(AARRGGBB&0x0000FF00);

 	return AARRGGBB;

 }

 

 static TCHAR *ske_ReAppend(TCHAR *lfirst, TCHAR * lsecond, int len)

 { 

-	int l1=lfirst?lstrlen(lfirst):0;

-	int l2=(len?len:(lstrlen(lsecond)+1));

-	TCHAR *buf=(TCHAR *)mir_alloc((l1+l2+1)*sizeof(TCHAR));

+	int l1 = lfirst?lstrlen(lfirst):0;

+	int l2 = (len?len:(lstrlen(lsecond)+1));

+	TCHAR *buf = (TCHAR *)mir_alloc((l1+l2+1)*sizeof(TCHAR));

 	if (lfirst) memmove(buf,lfirst,l1*sizeof(TCHAR));

 	memmove(buf+l1,lsecond,l2*sizeof(TCHAR));

 	if (lfirst) mir_free(lfirst);

-	if (len) buf[l1+l2]=_T('\0');

+	if (len) buf[l1+l2] = _T('\0');

 	return buf;

 }

 

@@ -4269,12 +4269,12 @@ TCHAR* ske_ReplaceVar(TCHAR *var)
 	if (!var) return mir_tstrdup(_T(""));

 	if (!lstrcmpi(var,TEXT("Profile")))

 	{

-		char buf[MAX_PATH]={0};

+		char buf[MAX_PATH] = {0};

 		CallService(MS_DB_GETPROFILENAME,(WPARAM)MAX_PATH,(LPARAM)buf);

 		{

-			int i=strlen(buf);

-			while (buf[i]!='.' && i>0) i--;

-			buf[i]='\0';

+			int i = strlen(buf);

+			while (buf[i] != '.' && i>0) i--;

+			buf[i] = '\0';

 		}

 		mir_free_and_nill(var);

 		return mir_a2u(buf);

@@ -4285,50 +4285,50 @@ TCHAR* ske_ReplaceVar(TCHAR *var)
 }

 TCHAR *ske_ParseText(TCHAR *stzText)

 {

-	int len=lstrlen(stzText);

-	TCHAR *result=NULL;

-	int stpos=0;

-	int curpos=0;  

+	int len = lstrlen(stzText);

+	TCHAR *result = NULL;

+	int stpos = 0;

+	int curpos = 0;  

 

-	while(curpos<len)

+	while(curpos < len)

 	{

 		//1 find first %

-		while(curpos<len && stzText[curpos]!=(TCHAR)'%') curpos++;

-		if (curpos<len) //% found

+		while(curpos < len && stzText[curpos] != (TCHAR)'%') curpos++;

+		if (curpos < len) //% found

 		{

 			if (curpos-stpos>0) 

-				result=ske_ReAppend(result,stzText+stpos,curpos-stpos);

-			stpos=curpos+1;

+				result = ske_ReAppend(result,stzText+stpos,curpos-stpos);

+			stpos = curpos+1;

 			curpos++;

 			//3 find second % 

-			while(curpos<len && stzText[curpos]!=(TCHAR)'%') curpos++;

-			if (curpos<len)

+			while(curpos < len && stzText[curpos] != (TCHAR)'%') curpos++;

+			if (curpos < len)

 			{

 				if (curpos-stpos>0) 

 				{

-					TCHAR *var=(TCHAR *)mir_alloc((curpos-stpos+1)*sizeof(TCHAR));

+					TCHAR *var = (TCHAR *)mir_alloc((curpos-stpos+1)*sizeof(TCHAR));

 					memmove(var,stzText+stpos,(curpos-stpos)*sizeof(TCHAR));

-					var[curpos-stpos]=(TCHAR)'\0';

-					var=ske_ReplaceVar(var);

-					result=ske_ReAppend(result,var,0);

+					var[curpos-stpos] = (TCHAR)'\0';

+					var = ske_ReplaceVar(var);

+					result = ske_ReAppend(result,var,0);

 					mir_free_and_nill(var);

 				}

 				else

-					result=ske_ReAppend(result,_T("%"),0);

+					result = ske_ReAppend(result,_T("%"),0);

 				curpos++;

-				stpos=curpos;

+				stpos = curpos;

 			}

 			else

 			{

 				//  if (curpos-stpos>0) 

-				//    result=ske_ReAppend(result,stzText+stpos,curpos-stpos);

+				//    result = ske_ReAppend(result,stzText+stpos,curpos-stpos);

 				break;

 			}

 		}

 		else

 		{

 			if (curpos-stpos>0) 

-				result=ske_ReAppend(result,stzText+stpos,curpos-stpos);

+				result = ske_ReAppend(result,stzText+stpos,curpos-stpos);

 			break;

 		}   

 	}

@@ -4337,21 +4337,21 @@ TCHAR *ske_ParseText(TCHAR *stzText)
 /*

 *   Parse text object string, find glyph object and add text to it.

 *   szGlyphTextID and Define string is:

-*   t[szGlyphTextID]=s[HostObjectID],[Left],[Top],[Right],[Bottom],[LTRBHV],[FontID],[Color1],[reservedforColor2],[Text]

+*   t[szGlyphTextID] = s[HostObjectID],[Left],[Top],[Right],[Bottom],[LTRBHV],[FontID],[Color1],[reservedforColor2],[Text]

 */

 static void OLDske_AddParseTextGlyphObject(char * szGlyphTextID,char * szDefineString,SKINOBJECTSLIST *Skin)

 {

 

-	GLYPHOBJECT *globj=NULL;

+	GLYPHOBJECT *globj = NULL;

 	{     

-		char buf[255]={0};

+		char buf[255] = {0};

 		GetParamN(szDefineString,buf,sizeof(buf),0,',',TRUE);

 		if (strlen(buf))

 		{

 			SKINOBJECTDESCRIPTOR * lpobj;

-			lpobj=ske_FindObjectByName(buf,OT_GLYPHOBJECT,Skin);

+			lpobj = ske_FindObjectByName(buf,OT_GLYPHOBJECT,Skin);

 			if (lpobj)

-				globj=(GLYPHOBJECT*)lpobj->Data;

+				globj = (GLYPHOBJECT*)lpobj->Data;

 		}

 		if (globj)

 		{

@@ -4359,34 +4359,34 @@ static void OLDske_AddParseTextGlyphObject(char * szGlyphTextID,char * szDefineS
 

 			if (!globj->plTextList)

 			{

-				globj->plTextList=List_Create(0,1);

-				globj->plTextList->sortFunc=ske_SortTextGlyphObjectFunc;

+				globj->plTextList = List_Create(0,1);

+				globj->plTextList->sortFunc = ske_SortTextGlyphObjectFunc;

 			}

-			glText=(GLYPHTEXT*)mir_calloc(sizeof(GLYPHTEXT));

-			glText->szGlyphTextID=mir_strdup(szGlyphTextID);

-			glText->szObjectName=mir_strdup(buf);

-			glText->iLeft=atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

-			glText->iTop=atoi(GetParamN(szDefineString,buf,sizeof(buf),2,',',TRUE));

-			glText->iRight=atoi(GetParamN(szDefineString,buf,sizeof(buf),3,',',TRUE));

-			glText->iBottom=atoi(GetParamN(szDefineString,buf,sizeof(buf),4,',',TRUE));

+			glText = (GLYPHTEXT*)mir_calloc(sizeof(GLYPHTEXT));

+			glText->szGlyphTextID = mir_strdup(szGlyphTextID);

+			glText->szObjectName = mir_strdup(buf);

+			glText->iLeft = atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

+			glText->iTop = atoi(GetParamN(szDefineString,buf,sizeof(buf),2,',',TRUE));

+			glText->iRight = atoi(GetParamN(szDefineString,buf,sizeof(buf),3,',',TRUE));

+			glText->iBottom = atoi(GetParamN(szDefineString,buf,sizeof(buf),4,',',TRUE));

 			{

 				memset(buf,0,6);

 				GetParamN(szDefineString,buf,sizeof(buf),5,',',TRUE);

-				buf[0]&=95; buf[1]&=95; buf[2]&=95; buf[3]&=95; buf[4]&=95; buf[5]&=95;   //to uppercase: &01011111 (0-95)

-				glText->RelativeFlags=

-					(buf[0]=='C'?1:((buf[0]=='R')?2:0))       //[BC][RC][BC][RC] --- Left relative

-					|(buf[1]=='C'?4:((buf[1]=='B')?8:0))       //  |   |   |--------- Top relative   

-					|(buf[2]=='C'?16:((buf[2]=='R')?32:0))     //  |   |--------------Right relative 

-					|(buf[3]=='C'?64:((buf[3]=='B')?128:0));   //  |------------------Bottom relative          

-				glText->dwFlags=(buf[4]=='C'?DT_CENTER:((buf[4]=='R')?DT_RIGHT:DT_LEFT))

-					|(buf[5]=='C'?DT_VCENTER:((buf[5]=='B')?DT_BOTTOM:DT_TOP));

+				buf[0] &= 95; buf[1] &= 95; buf[2] &= 95; buf[3] &= 95; buf[4] &= 95; buf[5] &= 95;   //to uppercase: &01011111 (0-95)

+				glText->RelativeFlags = 

+					(buf[0] == 'C'?1:((buf[0] == 'R')?2:0))       //[BC][RC][BC][RC] --- Left relative

+					|(buf[1] == 'C'?4:((buf[1] == 'B')?8:0))       //  |   |   |--------- Top relative   

+					|(buf[2] == 'C'?16:((buf[2] == 'R')?32:0))     //  |   |--------------Right relative 

+					|(buf[3] == 'C'?64:((buf[3] == 'B')?128:0));   //  |------------------Bottom relative          

+				glText->dwFlags = (buf[4] == 'C'?DT_CENTER:((buf[4] == 'R')?DT_RIGHT:DT_LEFT))

+					|(buf[5] == 'C'?DT_VCENTER:((buf[5] == 'B')?DT_BOTTOM:DT_TOP));

 			}

-			glText->szFontID=mir_strdup(GetParamN(szDefineString,buf,sizeof(buf),6,',',TRUE));

+			glText->szFontID = mir_strdup(GetParamN(szDefineString,buf,sizeof(buf),6,',',TRUE));

 

-			glText->dwColor=ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),7,',',TRUE));

-			glText->dwShadow=ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),8,',',TRUE));

-			glText->stValueText=mir_a2u(GetParamN(szDefineString,buf,sizeof(buf),9,',',TRUE));

-			glText->stText=ske_ParseText(glText->stValueText);

+			glText->dwColor = ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),7,',',TRUE));

+			glText->dwShadow = ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),8,',',TRUE));

+			glText->stValueText = mir_a2u(GetParamN(szDefineString,buf,sizeof(buf),9,',',TRUE));

+			glText->stText = ske_ParseText(glText->stValueText);

 			List_Insert(globj->plTextList,(void*)glText,globj->plTextList->realCount);     

 			qsort(globj->plTextList->items,globj->plTextList->realCount,sizeof(void*),(int(*)(const void*, const void*))globj->plTextList->sortFunc);

 		}

@@ -4396,39 +4396,39 @@ static void OLDske_AddParseTextGlyphObject(char * szGlyphTextID,char * szDefineS
 

 static void ske_AddParseTextGlyphObject(char * szGlyphTextID,char * szDefineString,SKINOBJECTSLIST *Skin)

 {

-	char buf[255]={0};

+	char buf[255] = {0};

 	GetParamN(szDefineString,buf,sizeof(buf),0,',',TRUE);

 	if (strlen(buf))

 	{

 		GLYPHTEXT * glText;

-		glText=(GLYPHTEXT*)mir_calloc(sizeof(GLYPHTEXT));

-		glText->szGlyphTextID=mir_strdup(szGlyphTextID);

-		glText->szObjectName=mir_strdup(buf);

-		glText->iLeft=atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

-		glText->iTop=atoi(GetParamN(szDefineString,buf,sizeof(buf),2,',',TRUE));

-		glText->iRight=atoi(GetParamN(szDefineString,buf,sizeof(buf),3,',',TRUE));

-		glText->iBottom=atoi(GetParamN(szDefineString,buf,sizeof(buf),4,',',TRUE));

+		glText = (GLYPHTEXT*)mir_calloc(sizeof(GLYPHTEXT));

+		glText->szGlyphTextID = mir_strdup(szGlyphTextID);

+		glText->szObjectName = mir_strdup(buf);

+		glText->iLeft = atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

+		glText->iTop = atoi(GetParamN(szDefineString,buf,sizeof(buf),2,',',TRUE));

+		glText->iRight = atoi(GetParamN(szDefineString,buf,sizeof(buf),3,',',TRUE));

+		glText->iBottom = atoi(GetParamN(szDefineString,buf,sizeof(buf),4,',',TRUE));

 		{

 			memset(buf,0,6);

 			GetParamN(szDefineString,buf,sizeof(buf),5,',',TRUE);

-			buf[0]&=95; buf[1]&=95; buf[2]&=95; buf[3]&=95; buf[4]&=95; buf[5]&=95;   //to uppercase: &01011111 (0-95)

-			glText->RelativeFlags=

-				(buf[0]=='C'?1:((buf[0]=='R')?2:0))       //[BC][RC][BC][RC] --- Left relative

-				|(buf[1]=='C'?4:((buf[1]=='B')?8:0))       //  |   |   |--------- Top relative   

-				|(buf[2]=='C'?16:((buf[2]=='R')?32:0))     //  |   |--------------Right relative 

-				|(buf[3]=='C'?64:((buf[3]=='B')?128:0));   //  |------------------Bottom relative          

-			glText->dwFlags=(buf[4]=='C'?DT_CENTER:((buf[4]=='R')?DT_RIGHT:DT_LEFT))

-				|(buf[5]=='C'?DT_VCENTER:((buf[5]=='B')?DT_BOTTOM:DT_TOP));

+			buf[0] &= 95; buf[1] &= 95; buf[2] &= 95; buf[3] &= 95; buf[4] &= 95; buf[5] &= 95;   //to uppercase: &01011111 (0-95)

+			glText->RelativeFlags = 

+				(buf[0] == 'C'?1:((buf[0] == 'R')?2:0))       //[BC][RC][BC][RC] --- Left relative

+				|(buf[1] == 'C'?4:((buf[1] == 'B')?8:0))       //  |   |   |--------- Top relative   

+				|(buf[2] == 'C'?16:((buf[2] == 'R')?32:0))     //  |   |--------------Right relative 

+				|(buf[3] == 'C'?64:((buf[3] == 'B')?128:0));   //  |------------------Bottom relative          

+			glText->dwFlags = (buf[4] == 'C'?DT_CENTER:((buf[4] == 'R')?DT_RIGHT:DT_LEFT))

+				|(buf[5] == 'C'?DT_VCENTER:((buf[5] == 'B')?DT_BOTTOM:DT_TOP));

 		}

-		glText->szFontID=mir_strdup(GetParamN(szDefineString,buf,sizeof(buf),6,',',TRUE));

+		glText->szFontID = mir_strdup(GetParamN(szDefineString,buf,sizeof(buf),6,',',TRUE));

 

-		glText->dwColor=ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),7,',',TRUE));

-		glText->dwShadow=ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),8,',',TRUE));

-		glText->stValueText=mir_a2u(GetParamN(szDefineString,buf,sizeof(buf),9,',',TRUE));

-		glText->stText=ske_ParseText(glText->stValueText);

+		glText->dwColor = ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),7,',',TRUE));

+		glText->dwShadow = ske_HexToARGB(GetParamN(szDefineString,buf,sizeof(buf),8,',',TRUE));

+		glText->stValueText = mir_a2u(GetParamN(szDefineString,buf,sizeof(buf),9,',',TRUE));

+		glText->stText = ske_ParseText(glText->stValueText);

 		

 		if (!Skin->pTextList)

-			Skin->pTextList=List_Create(0,1);

+			Skin->pTextList = List_Create(0,1);

 		List_InsertPtr(Skin->pTextList,glText);

 	}

 }

@@ -4437,47 +4437,47 @@ static void ske_AddParseTextGlyphObject(char * szGlyphTextID,char * szDefineStri
 /*

 *   Parse font definition string.

 *   szGlyphTextID and Define string is:

-*   f[szFontID]=s[FontTypefaceName],[size],[BIU]

+*   f[szFontID] = s[FontTypefaceName],[size],[BIU]

 */

 static void ske_AddParseSkinFont(char * szFontID,char * szDefineString,SKINOBJECTSLIST *Skin)

 {

-	//SortedList * gl_plSkinFonts=NULL;

-	SKINFONT * sf =NULL;

-	sf=(SKINFONT*)mir_calloc(sizeof(SKINFONT));

+	//SortedList * gl_plSkinFonts = NULL;

+	SKINFONT * sf  = NULL;

+	sf = (SKINFONT*)mir_calloc(sizeof(SKINFONT));

 	if (sf)

 	{

 		{

 			char buf[255];    

-			int fntSize=0;

-			BOOL fntBold=FALSE, fntItalic=FALSE, fntUnderline=FALSE;

-			LOGFONTA logfont={0};    

-			logfont.lfCharSet=DEFAULT_CHARSET;

-			logfont.lfOutPrecision=OUT_DEFAULT_PRECIS;

-			logfont.lfClipPrecision=CLIP_DEFAULT_PRECIS;

-			logfont.lfQuality=DEFAULT_QUALITY;

-			logfont.lfPitchAndFamily=DEFAULT_PITCH|FF_DONTCARE;    

+			int fntSize = 0;

+			BOOL fntBold = FALSE, fntItalic = FALSE, fntUnderline = FALSE;

+			LOGFONTA logfont = {0};    

+			logfont.lfCharSet = DEFAULT_CHARSET;

+			logfont.lfOutPrecision = OUT_DEFAULT_PRECIS;

+			logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;

+			logfont.lfQuality = DEFAULT_QUALITY;

+			logfont.lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE;    

 

 			strncpy(logfont.lfFaceName,GetParamN(szDefineString,buf,sizeof(buf),0,',',TRUE),32);

-			logfont.lfHeight=atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

-			if (logfont.lfHeight<0)

+			logfont.lfHeight = atoi(GetParamN(szDefineString,buf,sizeof(buf),1,',',TRUE));

+			if (logfont.lfHeight < 0)

 			{

-				HDC hdc=CreateCompatibleDC(NULL);        

-				logfont.lfHeight=(long)-MulDiv(logfont.lfHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72);

+				HDC hdc = CreateCompatibleDC(NULL);        

+				logfont.lfHeight = (long)-MulDiv(logfont.lfHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72);

 				mod_DeleteDC(hdc);

 			}

-			logfont.lfHeight=-logfont.lfHeight;

+			logfont.lfHeight = -logfont.lfHeight;

 			GetParamN(szDefineString,buf,sizeof(buf),2,',',TRUE);

-			buf[0]&=95; buf[1]&=95; buf[2]&=95;

-			logfont.lfWeight=(buf[0]=='B')?FW_BOLD:FW_NORMAL;

-			logfont.lfItalic=(buf[1]=='I')?1:0;

-			logfont.lfUnderline=(buf[2]=='U')?1:0;

+			buf[0] &= 95; buf[1] &= 95; buf[2] &= 95;

+			logfont.lfWeight = (buf[0] == 'B')?FW_BOLD:FW_NORMAL;

+			logfont.lfItalic = (buf[1] == 'I')?1:0;

+			logfont.lfUnderline = (buf[2] == 'U')?1:0;

 

-			sf->hFont=CreateFontIndirectA(&logfont);

+			sf->hFont = CreateFontIndirectA(&logfont);

 			if (sf->hFont)

 			{

-				sf->szFontID=mir_strdup(szFontID);

+				sf->szFontID = mir_strdup(szFontID);

 				if (!gl_plSkinFonts)

-					gl_plSkinFonts=List_Create(0,1);

+					gl_plSkinFonts = List_Create(0,1);

 				if (gl_plSkinFonts)

 				{

 					List_Insert(gl_plSkinFonts,(void*)sf,gl_plSkinFonts->realCount);

@@ -4493,36 +4493,36 @@ static void ske_AddParseSkinFont(char * szFontID,char * szDefineString,SKINOBJEC
 HICON ske_CreateJoinedIcon_Old(HICON hBottom, HICON hTop,BYTE alpha)

 {

 HDC tempDC;

-HICON res=NULL;

+HICON res = NULL;

 HBITMAP oImage,nImage;

 HBITMAP nMask;

-ICONINFO iNew={0};

-ICONINFO iciBottom={0};

-ICONINFO iciTop={0};

-BITMAP bmp={0};

-SIZE sz={0};

+ICONINFO iNew = {0};

+ICONINFO iciBottom = {0};

+ICONINFO iciTop = {0};

+BITMAP bmp = {0};

+SIZE sz = {0};

 {

 if (!GetIconInfo(hBottom,&iciBottom)) return NULL;

 GetObject(iciBottom.hbmColor,sizeof(BITMAP),&bmp);

-sz.cx=bmp.bmWidth; sz.cy=bmp.bmHeight;

-if(iciBottom.hbmColor) DeleteObject(iciBottom.hbmColor);

-if(iciBottom.hbmMask) DeleteObject(iciBottom.hbmMask);

+sz.cx = bmp.bmWidth; sz.cy = bmp.bmHeight;

+if (iciBottom.hbmColor) DeleteObject(iciBottom.hbmColor);

+if (iciBottom.hbmMask) DeleteObject(iciBottom.hbmMask);

 }

-if (sz.cx==0 || sz.cy==0) return NULL;

-tempDC=CreateCompatibleDC(NULL);

-nImage=ske_CreateDIB32(sz.cx,sz.cy);

-oImage=SelectObject(tempDC,nImage);

+if (sz.cx == 0 || sz.cy == 0) return NULL;

+tempDC = CreateCompatibleDC(NULL);

+nImage = ske_CreateDIB32(sz.cx,sz.cy);

+oImage = SelectObject(tempDC,nImage);

 ske_DrawIconEx(tempDC,0,0,hBottom,sz.cx,sz.cy,0,NULL,DI_NORMAL);

-ske_DrawIconEx(tempDC,0,0,hTop,sz.cx,sz.cy,0,NULL,DI_NORMAL|(alpha<<24));

+ske_DrawIconEx(tempDC,0,0,hTop,sz.cx,sz.cy,0,NULL,DI_NORMAL|(alpha << 24));

 SelectObject(tempDC,oImage);

 DeleteDC(tempDC);

 {

-BYTE * p=malloc(sz.cx*sz.cy/8+10);

-nMask=CreateBitmap(sz.cx,sz.cy,1,1,(void*)p);

-iNew.fIcon=TRUE;

-iNew.hbmColor=nImage;

-iNew.hbmMask=nMask;

-res=CreateIconIndirect(&iNew);

+BYTE * p = malloc(sz.cx*sz.cy/8+10);

+nMask = CreateBitmap(sz.cx,sz.cy,1,1,(void*)p);

+iNew.fIcon = TRUE;

+iNew.hbmColor = nImage;

+iNew.hbmMask = nMask;

+res = CreateIconIndirect(&iNew);

 if (!res) 

 TRACE_ERROR();

 DeleteObject(nImage);

@@ -4540,17 +4540,17 @@ return res;
 */

 static BOOL ske_CheckHasAlfaChannel(BYTE * from, int widthByte, int height)

 {

-	int i=0,j=0;

-	DWORD * pt=(DWORD*)from;

-	while (j<height)

+	int i = 0,j = 0;

+	DWORD * pt = (DWORD*)from;

+	while (j < height)

 	{

-		BYTE * add=(BYTE*)pt+widthByte;

-		while (pt<(DWORD*)add)

+		BYTE * add = (BYTE*)pt+widthByte;

+		while (pt < (DWORD*)add)

 		{

-			if ((*pt&0xFF000000)!=0) return TRUE;

+			if ((*pt&0xFF000000) != 0) return TRUE;

 			pt++;

 		}

-		pt=(DWORD*)(from+widthByte*j);

+		pt = (DWORD*)(from+widthByte*j);

 		j++;

 	}

 	return FALSE;

@@ -4562,10 +4562,10 @@ static BOOL ske_CheckHasAlfaChannel(BYTE * from, int widthByte, int height)
 */

 static BOOL ske_CheckIconHasMask(BYTE * from)

 {

-	int i=0;

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

+	int i = 0;

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

 	{

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

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

 	}

 	return FALSE;

 }

@@ -4575,7 +4575,7 @@ static BOOL ske_CheckIconHasMask(BYTE * from)
 */

 static BOOL ske_GetMaskBit(BYTE *line, int x)

 {

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

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

 }

 /*

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

@@ -4584,38 +4584,38 @@ static BOOL ske_GetMaskBit(BYTE *line, int x)
 

 static DWORD ske_Blend(DWORD X1,DWORD X2, BYTE alpha)

 {

-	BYTE a1=(BYTE)(X1>>24);

-	BYTE a2=(BYTE)(((X2>>24)*alpha)>>8);

-	BYTE r1=(BYTE)(X1>>16);

-	BYTE r2=(BYTE)(X2>>16);

-	BYTE g1=(BYTE)(X1>>8);

-	BYTE g2=(BYTE)(X2>>8);

-	BYTE b1=(BYTE)(X1);

-	BYTE b2=(BYTE)(X2);

-

-	BYTE a_1=~a1;

-	BYTE a_2=~a2;

-	WORD am=(WORD)a1*a_2;

+	BYTE a1 = (BYTE)(X1>>24);

+	BYTE a2 = (BYTE)(((X2>>24)*alpha)>>8);

+	BYTE r1 = (BYTE)(X1>>16);

+	BYTE r2 = (BYTE)(X2>>16);

+	BYTE g1 = (BYTE)(X1>>8);

+	BYTE g2 = (BYTE)(X2>>8);

+	BYTE b1 = (BYTE)(X1);

+	BYTE b2 = (BYTE)(X2);

+

+	BYTE a_1 = ~a1;

+	BYTE a_2 = ~a2;

+	WORD am = (WORD)a1*a_2;

 

 	/*  it is possible to use >>8 instead of /255 but it is require additional

 	*   checking of alphavalues

 	*/

-	WORD ar=a1+(((WORD)a_1*a2)/255);

+	WORD ar = a1+(((WORD)a_1*a2)/255);

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

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

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

 	// with mask we can get here black points

 

-	ar=(a2>ar)?a2:ar;

+	ar = (a2>ar)?a2:ar;

 

-	if (ar==0) return 0;

+	if (ar == 0) return 0;

 

 	//else

 	{

-		WORD arm=ar*255;

-		WORD rr=(((WORD)r1*am+(WORD)r2*a2*255))/arm;

-		WORD gr=(((WORD)g1*am+(WORD)g2*a2*255))/arm;

-		WORD br=(((WORD)b1*am+(WORD)b2*a2*255))/arm;

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

+		WORD arm = ar*255;

+		WORD rr = (((WORD)r1*am+(WORD)r2*a2*255))/arm;

+		WORD gr = (((WORD)g1*am+(WORD)g2*a2*255))/arm;

+		WORD br = (((WORD)b1*am+(WORD)b2*a2*255))/arm;

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

 	}

 

 }

@@ -4625,24 +4625,24 @@ static DWORD ske_Blend(DWORD X1,DWORD X2, BYTE alpha)
 HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)

 {

 	HDC tempDC;

-	HICON res=NULL;

+	HICON res = NULL;

 	HBITMAP oImage,nImage;

 	HBITMAP nMask;

-	BITMAP bmp={0};

+	BITMAP bmp = {0};

 	BYTE *ptPixels;

-	ICONINFO iNew={0};

-	ICONINFO iciBottom={0};

-	ICONINFO iciTop={0};

+	ICONINFO iNew = {0};

+	ICONINFO iciBottom = {0};

+	ICONINFO iciTop = {0};

 

-	BITMAP bmp_top={0};

-	BITMAP bmp_top_mask={0};

+	BITMAP bmp_top = {0};

+	BITMAP bmp_top_mask = {0};

 

-	BITMAP bmp_bottom={0};

-	BITMAP bmp_bottom_mask={0};

+	BITMAP bmp_bottom = {0};

+	BITMAP bmp_bottom_mask = {0};

 

-	tempDC=CreateCompatibleDC(NULL);

-	nImage=ske_CreateDIB32Point(16,16,(void**)&ptPixels);

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

+	tempDC = CreateCompatibleDC(NULL);

+	nImage = ske_CreateDIB32Point(16,16,(void**)&ptPixels);

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

 

 	GetIconInfo(hBottom,&iciBottom);

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

@@ -4652,90 +4652,90 @@ HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)
 	GetObject(iciTop.hbmColor,sizeof(BITMAP),&bmp_top);

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

 

-	if (bmp_bottom.bmBitsPixel==32 &&bmp_top.bmBitsPixel==32 && IsWinVerXPPlus())

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

 	{

 		BYTE * BottomBuffer, * TopBuffer, * BottomMaskBuffer, * TopMaskBuffer;

 		BYTE * bb, * tb, * bmb, * tmb;

-		BYTE * 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;

-		alpha=alpha?alpha:255;

-		if (bmp_bottom.bmBits) bb=BottomBuffer=(BYTE*)bmp_bottom.bmBits;

+		BYTE * 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;

+		alpha = alpha?alpha:255;

+		if (bmp_bottom.bmBits) bb = BottomBuffer = (BYTE*)bmp_bottom.bmBits;

 		else

 		{

-			BottomBuffer=(BYTE*)malloc(bmp_bottom.bmHeight*bmp_bottom.bmWidthBytes);

+			BottomBuffer = (BYTE*)malloc(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;

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

+			vstep_b = -vstep_b;

 		}

-		if (bmp_top.bmBits) tb=TopBuffer=(BYTE*)bmp_top.bmBits;

+		if (bmp_top.bmBits) tb = TopBuffer = (BYTE*)bmp_top.bmBits;

 		else

 		{

-			TopBuffer=(BYTE*)malloc(bmp_top.bmHeight*bmp_top.bmWidthBytes);

+			TopBuffer = (BYTE*)malloc(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;

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

+			vstep_t = -vstep_t;

 		}

 		if (bmp_bottom_mask.bmBits)

 		{

-			BottomMaskBuffer=(BYTE*)bmp_bottom_mask.bmBits;

-			bmb=BottomMaskBuffer;         

+			BottomMaskBuffer = (BYTE*)bmp_bottom_mask.bmBits;

+			bmb = BottomMaskBuffer;         

 		}

 		else

 		{

-			BottomMaskBuffer=(BYTE*)malloc(bmp_bottom_mask.bmHeight*bmp_bottom_mask.bmWidthBytes);            

+			BottomMaskBuffer = (BYTE*)malloc(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;

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

+			vstep_bm = -vstep_bm;

 

 		}

 		if (bmp_top_mask.bmBits)

 		{

-			TopMaskBuffer=(BYTE*)bmp_top_mask.bmBits;

-			tmb=TopMaskBuffer;

+			TopMaskBuffer = (BYTE*)bmp_top_mask.bmBits;

+			tmb = TopMaskBuffer;

 

 		}

 		else

 		{

-			TopMaskBuffer=(BYTE*)malloc(bmp_top_mask.bmHeight*bmp_top_mask.bmWidthBytes);

+			TopMaskBuffer = (BYTE*)malloc(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;

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

+			vstep_tm = -vstep_tm;

 		}

 		{

-			int x=0; int y=0;

-			BOOL topHasAlpha=ske_CheckHasAlfaChannel(TopBuffer,bmp_top.bmWidthBytes,bmp_top.bmHeight);

-			BOOL bottomHasAlpha=ske_CheckHasAlfaChannel(BottomBuffer,bmp_bottom.bmWidthBytes,bmp_bottom.bmHeight);

-			BOOL topHasMask=ske_CheckIconHasMask(TopMaskBuffer);

-			BOOL bottomHasMask=ske_CheckIconHasMask(BottomMaskBuffer);

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

+			int x = 0; int y = 0;

+			BOOL topHasAlpha = ske_CheckHasAlfaChannel(TopBuffer,bmp_top.bmWidthBytes,bmp_top.bmHeight);

+			BOOL bottomHasAlpha = ske_CheckHasAlfaChannel(BottomBuffer,bmp_bottom.bmWidthBytes,bmp_bottom.bmHeight);

+			BOOL topHasMask = ske_CheckIconHasMask(TopMaskBuffer);

+			BOOL bottomHasMask = ske_CheckIconHasMask(BottomMaskBuffer);

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

 			{

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

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

 				{

-					BOOL mask_b=ske_GetMaskBit(bmb,x);

-					BOOL mask_t=ske_GetMaskBit(tmb,x);

-					DWORD bottom_d=((DWORD*)bb)[x];

-					DWORD top_d=((DWORD*)tb)[x];

+					BOOL mask_b = ske_GetMaskBit(bmb,x);

+					BOOL mask_t = ske_GetMaskBit(tmb,x);

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

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

 					if (topHasMask)

 					{

-						if (mask_t==1 && !topHasAlpha )  top_d&=0xFFFFFF;

-						else if (!topHasAlpha) top_d|=0xFF000000;

+						if (mask_t == 1 && !topHasAlpha )  top_d &= 0xFFFFFF;

+						else if (!topHasAlpha) top_d |= 0xFF000000;

 					}

 					if (bottomHasMask)

 					{

-						if (mask_b==1 && !bottomHasAlpha) bottom_d&=0xFFFFFF;

-						else if (!bottomHasAlpha) bottom_d|=0xFF000000;

+						if (mask_b == 1 && !bottomHasAlpha) bottom_d &= 0xFFFFFF;

+						else if (!bottomHasAlpha) bottom_d |= 0xFF000000;

 					}

-					((DWORD*)db)[x]=ske_Blend(bottom_d,top_d,alpha);

+					((DWORD*)db)[x] = ske_Blend(bottom_d,top_d,alpha);

 				}

-				bb+=vstep_b;

-				tb+=vstep_t;

-				bmb+=vstep_bm;

-				tmb+=vstep_tm;

-				db+=vstep_d;

+				bb += vstep_b;

+				tb += vstep_t;

+				bmb += vstep_bm;

+				tmb += vstep_tm;

+				db += vstep_d;

 			}

 		}

 		if (!bmp_bottom.bmBits) free(BottomBuffer);

@@ -4746,7 +4746,7 @@ HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)
 	else

 	{

 		ske_DrawIconEx(tempDC,0,0,hBottom,16,16,0,NULL,DI_NORMAL);

-		ske_DrawIconEx(tempDC,0,0,hTop,16,16,0,NULL,DI_NORMAL|(alpha<<24));

+		ske_DrawIconEx(tempDC,0,0,hTop,16,16,0,NULL,DI_NORMAL|(alpha << 24));

 	}

 	DeleteObject(iciBottom.hbmColor);

 	DeleteObject(iciTop.hbmColor);

@@ -4756,16 +4756,16 @@ HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)
 	SelectObject(tempDC,oImage);

 	DeleteDC(tempDC);

 	{

-		//BYTE *p=malloc(32);

+		//BYTE *p = malloc(32);

 		//memset(p,0,32);

 		BYTE p[32] = {0};

-		nMask=CreateBitmap(16,16,1,1,(void*)&p);

+		nMask = CreateBitmap(16,16,1,1,(void*)&p);

 		{

-			HDC tempDC2=CreateCompatibleDC(NULL);

-			HDC tempDC3=CreateCompatibleDC(NULL);

-			HBITMAP hbm=CreateCompatibleBitmap(tempDC3,16,16);

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

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

+			HDC tempDC2 = CreateCompatibleDC(NULL);

+			HDC tempDC3 = CreateCompatibleDC(NULL);

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

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

+			HBITMAP 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);

@@ -4775,10 +4775,10 @@ HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)
 			DeleteDC(tempDC2);

 			DeleteDC(tempDC3);

 		}

-		iNew.fIcon=TRUE;

-		iNew.hbmColor=nImage;

-		iNew.hbmMask=nMask;

-		res=CreateIconIndirect(&iNew);

+		iNew.fIcon = TRUE;

+		iNew.hbmColor = nImage;

+		iNew.hbmMask = nMask;

+		res = CreateIconIndirect(&iNew);

 		DeleteObject(nImage);

 		DeleteObject(nMask);

 	}

@@ -4786,9 +4786,9 @@ HICON ske_CreateJoinedIcon(HICON hBottom, HICON hTop, BYTE alpha)
 }

 

 #define NEWJOINEDSTR( destination, first, separator, last)						\

-	destination=(char*)alloca(strlen(first)+strlen(separator)+strlen(last)+1);	\

+	destination = (char*)alloca(strlen(first)+strlen(separator)+strlen(last)+1);	\

 	if (destination) {													\

-	*destination='\0';												\

+	*destination = '\0';												\

 	strcat(destination,first);										\

 	strcat(destination,separator);									\

 	strcat(destination,last);										\

@@ -4802,22 +4802,22 @@ BOOL SkinDBGetContactSetting(HANDLE hContact, const char* szSection, const char*
 		char * szSkinKey;

 		NEWJOINEDSTR(szSkinKey,szSection,"@",szKey);

 		if ( !db_get(hContact, SKINSETSECTION, szSkinKey, retdbv))	{

-			if (bSkined) *bSkined=TRUE;

+			if (bSkined) *bSkined = TRUE;

 			return FALSE;

 	}	}

 	// not skinned

-	if (bSkined) bSkined=FALSE;

+	if (bSkined) bSkined = FALSE;

 	return db_get(hContact, szSection, szKey, retdbv);

 }

 

 BYTE SkinDBGetContactSettingByte(HANDLE hContact, const char* szSection, const char*szKey, BYTE bDefault)

 {

-	DBVARIANT dbv={0};

-	BOOL bSkined=FALSE;

+	DBVARIANT dbv = {0};

+	BOOL bSkined = FALSE;

 	if ( !SkinDBGetContactSetting(hContact, szSection, szKey, &dbv, &bSkined)) {

-		if (dbv.type==DBVT_BYTE)

+		if (dbv.type == DBVT_BYTE)

 		{

-			BYTE retVal=dbv.bVal;

+			BYTE retVal = dbv.bVal;

 			db_free(&dbv);

 			return retVal;

 		} else {

@@ -4830,11 +4830,11 @@ BYTE SkinDBGetContactSettingByte(HANDLE hContact, const char* szSection, const c
 

 WORD SkinDBGetContactSettingWord(HANDLE hContact, const char* szSection, const char*szKey, WORD wDefault)

 {

-	BOOL bSkined=FALSE;

-	DBVARIANT dbv={0};

+	BOOL bSkined = FALSE;

+	DBVARIANT dbv = {0};

 	if ( !SkinDBGetContactSetting(hContact, szSection, szKey, &dbv, &bSkined)) {

-		if (dbv.type==DBVT_WORD)	{

-			WORD retVal=dbv.wVal;

+		if (dbv.type == DBVT_WORD)	{

+			WORD retVal = dbv.wVal;

 			db_free(&dbv);

 			return retVal;

 		} else {

@@ -4847,11 +4847,11 @@ WORD SkinDBGetContactSettingWord(HANDLE hContact, const char* szSection, const c
 

 DWORD SkinDBGetContactSettingDword(HANDLE hContact, const char* szSection, const char*szKey, DWORD dwDefault)

 {

-	DBVARIANT dbv={0};

-	BOOL bSkined=FALSE;

+	DBVARIANT dbv = {0};

+	BOOL bSkined = FALSE;

 	if ( !SkinDBGetContactSetting(hContact, szSection, szKey, &dbv, &bSkined)) {

-		if (dbv.type==DBVT_DWORD)	{

-			DWORD retVal=dbv.dVal;

+		if (dbv.type == DBVT_DWORD)	{

+			DWORD retVal = dbv.dVal;

 			db_free(&dbv);

 			return retVal;

 		} else {