Clist_mw & Clist_modern renamed

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

1 files changed, 3117 insertions, 0 deletions

diff --git a/plugins/Clist_modern/modern_clui.cpp b/plugins/Clist_modern/modern_clui.cpp
new file mode 100644
index 0000000000..8830f119d6
--- /dev/null
+++ b/plugins/Clist_modern/modern_clui.cpp
@@ -0,0 +1,3117 @@
+/*

+

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

+

+Copyright 2000-2008 Miranda ICQ/IM project, 

+all portions of this codebase are copyrighted to the people 

+

+listed in contributors.txt.

+

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public License

+as published by the Free Software Foundation; either version 2

+of the License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program; if not, write to the Free Software

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

+*/

+

+#include "hdr/modern_commonheaders.h"

+

+#include "m_clc.h"

+#include "m_clui.h"

+#include "m_skin.h"

+#include "m_api/m_skinbutton.h"

+#include "hdr/modern_skinengine.h"

+#include "hdr/modern_statusbar.h"

+

+#include "hdr/modern_static_clui.h"

+#include <locale.h>

+#include "hdr/modern_clcpaint.h"

+#include "hdr/modern_sync.h"

+

+

+

+HRESULT (WINAPI *g_proc_DWMEnableBlurBehindWindow)(HWND hWnd, DWM_BLURBEHIND *pBlurBehind);

+BOOL CALLBACK ProcessCLUIFrameInternalMsg(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT& result );

+void DestroyTrayMenu(HMENU hMenu);

+

+// new sources

+#ifdef _MSC_VER

+#include <crtdbg.h>

+#endif

+

+//////////////// CLUI CLASS IMPLEMENTATION /////////////////////////////////

+#include "hdr/modern_clui.h"

+

+#define STATIC_METHOD

+

+CLUI* CLUI::m_pCLUI = NULL;

+BOOL CLUI::m_fMainMenuInited = FALSE;

+HWND CLUI::m_hWnd = NULL;

+

+void CLUI::cliOnCreateClc(void)

+{  

+	STATIC_METHOD;

+	_ASSERT( m_pCLUI );

+	m_pCLUI->CreateCluiFrames();

+}

+

+int CLUI::OnEvent_ModulesLoaded(WPARAM wParam,LPARAM lParam)

+{

+	STATIC_METHOD;

+

+	g_CluiData.bMetaAvail = ServiceExists(MS_MC_GETDEFAULTCONTACT) ? TRUE : FALSE;

+	setlocale(LC_ALL, "");  //fix for case insensitive comparing

+

+	if (ServiceExists(MS_MC_DISABLEHIDDENGROUP))

+		CallService(MS_MC_DISABLEHIDDENGROUP, (WPARAM)TRUE, (LPARAM)0);

+

+	if (ServiceExists(MS_MC_GETPROTOCOLNAME))

+		g_szMetaModuleName = (char *)CallService(MS_MC_GETPROTOCOLNAME, 0, 0);

+

+	CLUIServices_ProtocolStatusChanged(0,0);

+	SleepEx(0,TRUE);

+	g_flag_bOnModulesLoadedCalled=TRUE;	

+	///pcli->pfnInvalidateDisplayNameCacheEntry(INVALID_HANDLE_VALUE);   

+	SendMessage(pcli->hwndContactList,UM_CREATECLC,0,0); //$$$

+	InitSkinHotKeys();

+	g_CluiData.bSTATE = STATE_NORMAL;

+	ske_RedrawCompleteWindow();

+

+	return 0;

+}

+

+int CLUI::OnEvent_FontReload(WPARAM wParam,LPARAM lParam)

+{

+    STATIC_METHOD;

+    

+    pcli->pfnClcBroadcast( INTM_RELOADOPTIONS, wParam, lParam );

+

+	g_CluiData.dwKeyColor=ModernGetSettingDword(NULL,"ModernSettings","KeyColor",(DWORD)SETTING_KEYCOLOR_DEFAULT);

+

+	CLUI__cliInvalidateRect( pcli->hwndContactList, 0, 0 );

+	

+    return 0;

+}

+

+int CLUI::OnEvent_ContactMenuPreBuild(WPARAM wParam, LPARAM lParam) 

+{

+	TCHAR cls[128];

+	HANDLE hItem;

+	HWND hwndClist = GetFocus();

+	CLISTMENUITEM mi;

+	if (MirandaExiting()) return 0;

+	ZeroMemory(&mi,sizeof(mi));

+	mi.cbSize = sizeof(mi);

+	mi.flags = CMIM_FLAGS;

+	GetClassName(hwndClist,cls,SIZEOF(cls));

+	hwndClist = (!lstrcmp(CLISTCONTROL_CLASS,cls))?hwndClist:pcli->hwndContactList;

+	hItem = (HANDLE)SendMessage(hwndClist,CLM_GETSELECTION,0,0);

+	if (!hItem) {

+		mi.flags = CMIM_FLAGS | CMIF_HIDDEN;

+	}

+	CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hRenameMenuItem, (LPARAM)&mi);

+

+	if (!hItem || !IsHContactContact(hItem) || !ModernGetSettingByte(NULL,"CList","AvatarsShow",SETTINGS_SHOWAVATARS_DEFAULT))

+	{

+		mi.flags = CMIM_FLAGS | CMIF_HIDDEN;

+		CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hShowAvatarMenuItem, (LPARAM)&mi);

+		CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hHideAvatarMenuItem, (LPARAM)&mi);

+	}

+	else

+	{

+		int has_avatar;

+

+		if (ServiceExists(MS_AV_GETAVATARBITMAP))

+		{

+			has_avatar = CallService(MS_AV_GETAVATARBITMAP, (WPARAM)hItem, 0);

+		}

+		else

+		{

+			DBVARIANT dbv={0};

+			if (ModernGetSettingString(hItem, "ContactPhoto", "File", &dbv))

+			{

+				has_avatar = 0;

+			}

+			else

+			{

+				has_avatar = 1;

+				ModernDBFreeVariant(&dbv);

+			}

+		}

+

+		if (ModernGetSettingByte(hItem, "CList", "HideContactAvatar", 0))

+		{

+			mi.flags = CMIM_FLAGS | (has_avatar ? 0 : CMIF_GRAYED);

+			CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hShowAvatarMenuItem, (LPARAM)&mi);

+			mi.flags = CMIM_FLAGS | CMIF_HIDDEN;

+			CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hHideAvatarMenuItem, (LPARAM)&mi);

+		}

+		else

+		{

+			mi.flags = CMIM_FLAGS | CMIF_HIDDEN;

+			CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hShowAvatarMenuItem, (LPARAM)&mi);

+			mi.flags = CMIM_FLAGS | (has_avatar ? 0 : CMIF_GRAYED);

+			CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM)hHideAvatarMenuItem, (LPARAM)&mi);

+		}

+	}

+

+	return 0;

+}

+int CLUI::OnEvent_DBSettingChanging(WPARAM wParam,LPARAM lParam)

+{

+	if (ServiceExists("ExtraIcon/Register"))

+		return 0;

+

+	DBCONTACTWRITESETTING *dbcws=(DBCONTACTWRITESETTING *)lParam;

+	if (wParam==0) return 0;  

+	if (dbcws==NULL) return(0);

+	if (MirandaExiting()) return 0;

+

+	if ( ( dbcws->value.type==DBVT_WORD && !mir_strcmp(dbcws->szSetting,"ApparentMode") ) ||

+		( dbcws->value.type==DBVT_ASCIIZ && 

+		( ( !mir_strcmp(dbcws->szSetting,"e-mail") ||

+		!mir_strcmp(dbcws->szSetting,"Mye-mail0") ||

+		!mir_strcmp(dbcws->szSetting,"Cellular") )  ||

+		( !mir_strcmp(dbcws->szModule,"UserInfo") &&

+		( !mir_strcmp(dbcws->szSetting,"MyPhone0") || 

+		!mir_strcmp(dbcws->szSetting,"Mye-mail0") ) ) ) ) )

+		ExtraImage_SetAllExtraIcons(pcli->hwndContactTree,(HANDLE)wParam);

+	return(0);

+};

+INT_PTR CLUI::Service_ShowMainMenu(WPARAM wParam,LPARAM lParam)

+{

+	HMENU hMenu;

+	POINT pt;

+	hMenu=(HMENU)CallService(MS_CLIST_MENUGETMAIN,0,0);

+	GetCursorPos(&pt);

+	TrackPopupMenu(hMenu,TPM_TOPALIGN|TPM_LEFTALIGN|TPM_LEFTBUTTON,pt.x,pt.y,0,pcli->hwndContactList,NULL);				

+	return 0;

+}

+INT_PTR CLUI::Service_ShowStatusMenu(WPARAM wParam,LPARAM lParam)

+{

+	HMENU hMenu;

+	POINT pt;

+	hMenu=(HMENU)CallService(MS_CLIST_MENUGETSTATUS,0,0);

+	GetCursorPos(&pt);

+	TrackPopupMenu(hMenu,TPM_TOPALIGN|TPM_LEFTALIGN|TPM_LEFTBUTTON,pt.x,pt.y,0,pcli->hwndContactList,NULL);				

+	return 0;

+}

+

+INT_PTR CLUI::Service_Menu_ShowContactAvatar(WPARAM wParam,LPARAM lParam)

+{

+	HANDLE hContact = (HANDLE) wParam;

+

+	ModernWriteSettingByte(hContact, "CList", "HideContactAvatar", 0);

+

+	pcli->pfnClcBroadcast( INTM_AVATARCHANGED,wParam,0);

+	return 0;

+}

+

+INT_PTR CLUI::Service_Menu_HideContactAvatar(WPARAM wParam,LPARAM lParam)

+{

+	HANDLE hContact = (HANDLE) wParam;

+

+	ModernWriteSettingByte(hContact, "CList", "HideContactAvatar", 1);

+

+	pcli->pfnClcBroadcast( INTM_AVATARCHANGED,wParam,0);

+	return 0;

+}

+

+

+

+HRESULT CLUI::CreateCluiFrames()

+{

+	g_hMenuMain=GetMenu(pcli->hwndContactList);

+	MENUITEMINFO mii;

+	ZeroMemory(&mii,sizeof(mii));

+	mii.cbSize=MENUITEMINFO_V4_SIZE;

+	mii.fMask=MIIM_SUBMENU;

+	mii.hSubMenu=(HMENU)CallService(MS_CLIST_MENUGETMAIN,0,0);

+	SetMenuItemInfo(g_hMenuMain,0,TRUE,&mii);

+	mii.hSubMenu=(HMENU)CallService(MS_CLIST_MENUGETSTATUS,0,0);

+	SetMenuItemInfo(g_hMenuMain,1,TRUE,&mii);

+

+	CreateCLCWindow(CluiWnd());

+

+	CLUI_ChangeWindowMode();

+

+	RegisterAvatarMenu(); 

+

+	CLUI_ReloadCLUIOptions();	

+

+	CreateUIFrames();

+

+	ModernHookEvent(ME_SYSTEM_MODULESLOADED,CLUI::OnEvent_ModulesLoaded);

+	ModernHookEvent(ME_SKIN2_ICONSCHANGED,CLUI_IconsChanged);

+    ModernHookEvent(ME_FONT_RELOAD, CLUI::OnEvent_FontReload);

+	return S_OK;

+}

+CLUI::CLUI() :

+m_hUserDll( NULL ),

+m_hDwmapiDll( NULL )

+{

+	m_pCLUI = this;

+	g_CluiData.bSTATE = STATE_CLUI_LOADING;

+	LoadDllsRuntime();

+	hFrameContactTree=NULL;

+

+	CLUIServices_LoadModule();

+

+	// Call InitGroup menus before

+	GroupMenus_Init();

+

+	CreateServiceFunction(MS_CLUI_SHOWMAINMENU,Service_ShowMainMenu);

+	CreateServiceFunction(MS_CLUI_SHOWSTATUSMENU,Service_ShowStatusMenu);

+

+

+	//TODO Add Row template loading here.

+

+	RowHeight_InitModernRow();

+	nLastRequiredHeight=0;

+

+	LoadCLUIFramesModule();

+	ExtraImage_LoadModule();	

+

+	g_CluiData.boldHideOffline=-1;

+	bOldHideOffline=ModernGetSettingByte(NULL,"CList","HideOffline",SETTING_HIDEOFFLINE_DEFAULT);

+

+	g_CluiData.bOldUseGroups=-1;

+	bOldUseGroups = ModernGetSettingByte( NULL,"CList","UseGroups", SETTING_USEGROUPS_DEFAULT );

+}

+

+CLUI::~CLUI()

+{

+	FreeLibrary(m_hUserDll);

+	FreeLibrary(m_hDwmapiDll);

+	m_pCLUI = NULL;

+}

+

+HRESULT CLUI::LoadDllsRuntime()

+{

+	m_hUserDll = LoadLibrary(TEXT("user32.dll"));

+	if (m_hUserDll)

+	{

+		g_proc_UpdateLayeredWindow = (BOOL (WINAPI *)(HWND,HDC,POINT*,SIZE*,HDC,POINT*,COLORREF,BLENDFUNCTION*,DWORD))GetProcAddress(m_hUserDll, "UpdateLayeredWindow");

+		g_proc_SetLayeredWindowAttributesNew = (BOOL (WINAPI *)(HWND,COLORREF,BYTE,DWORD))GetProcAddress(m_hUserDll, "SetLayeredWindowAttributes");

+		g_proc_AnimateWindow=(BOOL (WINAPI*)(HWND,DWORD,DWORD))GetProcAddress(m_hUserDll,"AnimateWindow");

+

+		g_CluiData.fLayered=(g_proc_UpdateLayeredWindow!=NULL) && !ModernGetSettingByte(NULL,"ModernData","DisableEngine", SETTING_DISABLESKIN_DEFAULT);

+		g_CluiData.fSmoothAnimation=IsWinVer2000Plus()&&ModernGetSettingByte(NULL, "CLUI", "FadeInOut", SETTING_FADEIN_DEFAULT);

+		g_CluiData.fLayered=(g_CluiData.fLayered*ModernGetSettingByte(NULL, "ModernData", "EnableLayering", g_CluiData.fLayered))&&!ModernGetSettingByte(NULL,"ModernData","DisableEngine", SETTING_DISABLESKIN_DEFAULT);

+	}

+

+    if (IsWinVerVistaPlus())

+    {

+	    m_hDwmapiDll = LoadLibrary(TEXT("dwmapi.dll"));

+	    if (m_hDwmapiDll)

+	    {

+		    g_proc_DWMEnableBlurBehindWindow = (HRESULT (WINAPI *)(HWND, DWM_BLURBEHIND *))GetProcAddress(m_hDwmapiDll, "DwmEnableBlurBehindWindow");

+	    }

+    }

+	g_CluiData.fAeroGlass = FALSE;

+

+	return S_OK;

+}

+HRESULT CLUI::RegisterAvatarMenu()

+{

+	CLISTMENUITEM mi;

+

+	ZeroMemory(&mi,sizeof(mi));

+	mi.cbSize=sizeof(mi);

+	mi.flags=0;

+	mi.pszContactOwner=NULL;    //on every contact

+	CreateServiceFunction("CList/ShowContactAvatar",CLUI::Service_Menu_ShowContactAvatar);

+	mi.position=2000150000;

+	mi.hIcon=LoadSmallIcon(g_hInst,MAKEINTRESOURCE(IDI_SHOW_AVATAR));

+	mi.pszName=LPGEN("Show Contact &Avatar");

+	mi.pszService="CList/ShowContactAvatar";

+	hShowAvatarMenuItem = Menu_AddContactMenuItem(&mi);

+	DestroyIcon_protect(mi.hIcon);

+

+	CreateServiceFunction("CList/HideContactAvatar",CLUI::Service_Menu_HideContactAvatar);

+	mi.position=2000150001;

+	mi.hIcon=LoadSmallIcon(g_hInst,MAKEINTRESOURCE(IDI_HIDE_AVATAR));

+	mi.pszName=LPGEN("Hide Contact &Avatar");

+	mi.pszService="CList/HideContactAvatar";

+	hHideAvatarMenuItem = Menu_AddContactMenuItem(&mi);

+	DestroyIcon_protect(mi.hIcon);

+

+	ModernHookEvent(ME_CLIST_PREBUILDCONTACTMENU, CLUI::OnEvent_ContactMenuPreBuild);

+

+	return S_OK;

+}

+HRESULT CLUI::CreateCLCWindow(const HWND hwndClui)

+{    

+	ClcWnd() = CreateWindow(CLISTCONTROL_CLASS,TEXT(""),

+		WS_CHILD|WS_CLIPCHILDREN|CLS_CONTACTLIST

+		|(ModernGetSettingByte(NULL,"CList","UseGroups",SETTING_USEGROUPS_DEFAULT)?CLS_USEGROUPS:0)

+		|(ModernGetSettingByte(NULL,"CList","HideOffline",SETTING_HIDEOFFLINE_DEFAULT)?CLS_HIDEOFFLINE:0)

+		|(ModernGetSettingByte(NULL,"CList","HideEmptyGroups",SETTING_HIDEEMPTYGROUPS_DEFAULT)?CLS_HIDEEMPTYGROUPS:0

+		|CLS_MULTICOLUMN

+		),

+		0,0,0,0,hwndClui,NULL,g_hInst,NULL);

+

+	return S_OK;

+}

+

+HRESULT CLUI::CreateUIFrames()

+{

+	EventArea_Create(pcli->hwndContactList);

+	CreateViewModeFrame();

+	pcli->hwndStatus = StatusBar_Create(pcli->hwndContactList);    

+

+	return S_OK;

+}

+

+

+

+HRESULT CLUI::FillAlphaChannel( HDC hDC, RECT * prcParent, BYTE bAlpha)

+{

+

+	RECT rcWindow;

+	GetWindowRect( m_hWnd, &rcWindow );

+

+	HRGN hRgn = CreateRectRgn(0,0,0,0);

+

+	if ( GetWindowRgn(m_hWnd,hRgn)==ERROR )

+	{

+		DeleteObject(hRgn);

+		hRgn=CreateRectRgn(rcWindow.left ,rcWindow.top ,rcWindow.right,rcWindow.bottom);

+	}

+

+	OffsetRgn(hRgn,-prcParent->left,-prcParent->top);

+

+	RECT rcBounds;

+	GetRgnBox(hRgn,&rcBounds);

+

+	if ( IsRectEmpty(&rcBounds) ) 

+	{

+		DeleteObject(hRgn);

+		return S_FALSE;

+	}

+

+	DWORD dwRgnSize = GetRegionData( hRgn, 0, NULL );

+	RGNDATA * rgnData=(RGNDATA *)malloc(dwRgnSize);

+	GetRegionData(hRgn,dwRgnSize,rgnData);

+

+	RECT * pRect=(RECT *)rgnData->Buffer;

+

+	for (DWORD i=0; i<rgnData->rdh.nCount; i++)

+		ske_SetRectOpaque( hDC, &pRect[i] );

+

+	free(rgnData);

+	DeleteObject(hRgn);

+

+	return S_OK;

+}

+

+HRESULT CLUI::CreateCLC()

+{

+

+	INIT<CLISTFrame> Frame;

+

+	Frame.hWnd=ClcWnd();

+	Frame.align=alClient;

+	Frame.hIcon=LoadSkinnedIcon(SKINICON_OTHER_MIRANDA);

+	Frame.Flags=F_VISIBLE|/*F_SHOWTB|*/F_SHOWTBTIP|F_NO_SUBCONTAINER|F_TCHAR;

+	Frame.tname=LPGENT("My Contacts");

+	Frame.TBtname=TranslateT("My Contacts");

+	hFrameContactTree=(HWND)CallService(MS_CLIST_FRAMES_ADDFRAME,(WPARAM)&Frame,(LPARAM)0);

+

+	CallService(MS_SKINENG_REGISTERPAINTSUB,(WPARAM)Frame.hWnd,(LPARAM)CLCPaint::PaintCallbackProc);

+	CallService(MS_CLIST_FRAMES_SETFRAMEOPTIONS,MAKEWPARAM(FO_TBTIPNAME,hFrameContactTree),(LPARAM)Translate("My Contacts"));	

+

+	ExtraImage_ReloadExtraIcons();

+

+	nLastRequiredHeight=0;

+	if ( g_CluiData.current_viewmode[0] == '\0' )

+	{

+		if (bOldHideOffline != (BYTE)-1) 

+			CallService( MS_CLIST_SETHIDEOFFLINE,(WPARAM)bOldHideOffline, 0);

+		else

+			CallService( MS_CLIST_SETHIDEOFFLINE,(WPARAM)0, 0);

+		if (bOldUseGroups !=(BYTE)-1)  

+			CallService( MS_CLIST_SETUSEGROUPS ,(WPARAM)bOldUseGroups, 0);

+		else

+			CallService( MS_CLIST_SETUSEGROUPS ,(WPARAM)bOldUseGroups, 0);

+	}

+	nLastRequiredHeight=0;

+	mutex_bDisableAutoUpdate=0;

+

+	hSettingChangedHook=ModernHookEvent(ME_DB_CONTACT_SETTINGCHANGED,CLUI::OnEvent_DBSettingChanging);

+

+	return S_OK;

+

+};

+HRESULT CLUI::SnappingToEdge( WINDOWPOS * lpWindowPos )

+{ 

+	//by ZORG

+	if ( MyMonitorFromWindow == NULL || MyGetMonitorInfo == NULL )

+		return S_FALSE;

+

+	if (ModernGetSettingByte(NULL,"CLUI","SnapToEdges",SETTING_SNAPTOEDGES_DEFAULT))

+	{

+		RECT* dr;

+		MONITORINFO monInfo;

+		HMONITOR curMonitor = MyMonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);

+

+		monInfo.cbSize = sizeof(monInfo);

+		MyGetMonitorInfo(curMonitor, &monInfo);

+

+		dr = &(monInfo.rcWork);

+

+		// Left side

+		if ( lpWindowPos->x < dr->left + SNAPTOEDGESENSIVITY && lpWindowPos->x > dr->left - SNAPTOEDGESENSIVITY && g_CluiData.bBehindEdgeSettings!=1)

+			lpWindowPos->x = dr->left;

+

+		// Right side

+		if ( dr->right - lpWindowPos->x - lpWindowPos->cx <SNAPTOEDGESENSIVITY && dr->right - lpWindowPos->x - lpWindowPos->cx > -SNAPTOEDGESENSIVITY && g_CluiData.bBehindEdgeSettings!=2)

+			lpWindowPos->x = dr->right - lpWindowPos->cx;

+

+		// Top side

+		if ( lpWindowPos->y < dr->top + SNAPTOEDGESENSIVITY && lpWindowPos->y > dr->top - SNAPTOEDGESENSIVITY)

+			lpWindowPos->y = dr->top;

+

+		// Bottom side

+		if ( dr->bottom - lpWindowPos->y - lpWindowPos->cy <SNAPTOEDGESENSIVITY && dr->bottom - lpWindowPos->y - lpWindowPos->cy > -SNAPTOEDGESENSIVITY)

+			lpWindowPos->y = dr->bottom - lpWindowPos->cy;

+	}

+	return S_OK;

+}

+

+

+HICON GetMainStatusOverlay(int STATUS)

+{

+	return ImageList_GetIcon(hAvatarOverlays,g_pStatusOverlayIcons[STATUS-ID_STATUS_OFFLINE].listID,ILD_NORMAL);

+}

+

+void UnloadAvatarOverlayIcon()

+{

+	int i;

+	for (i = 0 ; i < MAX_REGS(g_pAvatarOverlayIcons) ; i++)

+	{

+		g_pAvatarOverlayIcons[i].listID=-1;

+		g_pStatusOverlayIcons[i].listID=-1;

+	}

+	ImageList_Destroy(hAvatarOverlays);

+	hAvatarOverlays=NULL;

+	DestroyIcon_protect(g_hListeningToIcon);

+	g_hListeningToIcon=NULL;

+}

+

+

+BOOL CLUI_CheckOwnedByClui(HWND hWnd)

+{

+	HWND hWndMid, hWndClui;

+	if (!hWnd) return FALSE;

+	hWndClui=pcli->hwndContactList;

+	hWndMid=fnGetAncestor(hWnd,GA_ROOTOWNER);

+	if(hWndMid==hWndClui) return TRUE;

+	{

+		TCHAR buf[255];

+		GetClassName(hWndMid,buf,254);

+		if (!mir_tstrcmpi(buf,CLUIFrameSubContainerClassName)) return TRUE;

+	}

+	return FALSE;

+}

+

+int CLUI_ShowWindowMod(HWND hWnd, int nCmd) 

+{

+	int res=0;

+

+	if (hWnd==pcli->hwndContactList && (nCmd==SW_HIDE || nCmd==SW_MINIMIZE) )

+	{	

+		AniAva_InvalidateAvatarPositions(NULL);

+		AniAva_RemoveInvalidatedAvatars();

+	}

+

+	if (hWnd==pcli->hwndContactList 

+		&& !g_mutex_bChangingMode

+		&& nCmd==SW_HIDE 

+		&& !g_CluiData.fLayered 

+		&& IsWinVerXPPlus()

+		&& ModernGetSettingByte(NULL,"CList","WindowShadow",SETTING_WINDOWSHADOW_DEFAULT))

+	{

+		ShowWindow(hWnd,SW_MINIMIZE); //removing of shadow

+		return ShowWindow(hWnd,nCmd);

+	}

+	if (hWnd==pcli->hwndContactList

+		&& !g_mutex_bChangingMode

+		&& nCmd==SW_RESTORE

+		&& !g_CluiData.fLayered 

+		&& IsWinVerXPPlus()		

+		&& g_CluiData.fSmoothAnimation

+		&& !g_bTransparentFlag 

+		)	

+	{	

+		if(ModernGetSettingByte(NULL,"CList","WindowShadow",SETTING_WINDOWSHADOW_DEFAULT))

+		{

+			CLUI_SmoothAlphaTransition(hWnd, 255, 1);

+		}

+		else

+		{

+

+			int ret=ShowWindow(hWnd,nCmd);

+			CLUI_SmoothAlphaTransition(hWnd, 255, 1);

+			return ret;

+		}

+	}

+	return ShowWindow(hWnd,nCmd);

+}

+

+static BOOL CLUI_WaitThreadsCompletion(HWND hwnd)

+{

+	static BYTE bEntersCount=0;

+	static const BYTE bcMAX_AWAITING_RETRY = 10; //repeat awaiting only 10 times

+	TRACE("CLUI_WaitThreadsCompletion Enter");

+	if (bEntersCount<bcMAX_AWAITING_RETRY

+		&&( g_mutex_nCalcRowHeightLock ||

+		g_CluiData.mutexPaintLock || 

+		g_dwAwayMsgThreadID || 

+		g_dwGetTextAsyncThreadID || 

+		g_dwSmoothAnimationThreadID || 

+		g_dwFillFontListThreadID) 

+		&&!Miranda_Terminated())

+	{

+		TRACE("Waiting threads");

+		TRACEVAR("g_mutex_nCalcRowHeightLock: %x",g_mutex_nCalcRowHeightLock);

+		TRACEVAR("g_CluiData.mutexPaintLock: %x",g_CluiData.mutexPaintLock);

+		TRACEVAR("g_dwAwayMsgThreadID: %x",g_dwAwayMsgThreadID);

+		TRACEVAR("g_dwGetTextAsyncThreadID: %x",g_dwGetTextAsyncThreadID);

+		TRACEVAR("g_dwSmoothAnimationThreadID: %x",g_dwSmoothAnimationThreadID);

+		TRACEVAR("g_dwFillFontListThreadID: %x",g_dwFillFontListThreadID);

+		bEntersCount++;

+		SleepEx(10,TRUE);

+		return TRUE;

+	}

+

+	return FALSE;

+}

+

+void CLUI_UpdateLayeredMode()

+{	

+	g_CluiData.fDisableSkinEngine=ModernGetSettingByte(NULL,"ModernData","DisableEngine", SETTING_DISABLESKIN_DEFAULT);

+	if (IsWinVer2000Plus())

+	{

+		BOOL tLayeredFlag=TRUE;

+		tLayeredFlag&=(ModernGetSettingByte(NULL, "ModernData", "EnableLayering", tLayeredFlag) && !g_CluiData.fDisableSkinEngine);

+

+		if (g_CluiData.fLayered != tLayeredFlag)

+		{

+			LONG exStyle;

+			BOOL fWasVisible=IsWindowVisible(pcli->hwndContactList);

+			if (fWasVisible) ShowWindow(pcli->hwndContactList,SW_HIDE);

+			//change layered mode

+			exStyle=GetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE);

+			if (tLayeredFlag) 

+				exStyle|=WS_EX_LAYERED;

+			else

+				exStyle&=~WS_EX_LAYERED;

+			SetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE,exStyle&~WS_EX_LAYERED);

+			SetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE,exStyle);

+			g_CluiData.fLayered = tLayeredFlag;

+			Sync(CLUIFrames_SetLayeredMode, tLayeredFlag,pcli->hwndContactList);			

+			CLUI_ChangeWindowMode();

+			Sync(CLUIFrames_OnClistResize_mod, (WPARAM)0, (LPARAM)0 );

+			if (fWasVisible) ShowWindow(pcli->hwndContactList,SW_SHOW);

+		}

+	}

+}

+

+void CLUI_UpdateAeroGlass()

+{

+	BOOL tAeroGlass = ModernGetSettingByte(NULL, "ModernData", "AeroGlass", SETTING_AEROGLASS_DEFAULT) && (g_CluiData.fLayered);

+	if (g_proc_DWMEnableBlurBehindWindow && (tAeroGlass != g_CluiData.fAeroGlass))

+	{			

+		if (g_CluiData.hAeroGlassRgn)

+		{

+			DeleteObject(g_CluiData.hAeroGlassRgn);

+			g_CluiData.hAeroGlassRgn = 0;

+		}

+

+		DWM_BLURBEHIND bb = {0};

+		bb.dwFlags = DWM_BB_ENABLE;

+		bb.fEnable = tAeroGlass;

+

+		if (tAeroGlass)

+		{

+			g_CluiData.hAeroGlassRgn = ske_CreateOpaqueRgn(AEROGLASS_MINALPHA, true);

+			bb.hRgnBlur = g_CluiData.hAeroGlassRgn;

+			bb.dwFlags |= DWM_BB_BLURREGION;

+		}

+

+		g_proc_DWMEnableBlurBehindWindow(pcli->hwndContactList, &bb);

+		g_CluiData.fAeroGlass = tAeroGlass;

+	}

+}

+

+extern int CLUIFrames_UpdateBorders();

+

+void CLUI_ChangeWindowMode()

+{

+	BOOL storedVisMode=FALSE;

+	LONG style,styleEx;

+	LONG oldStyle,oldStyleEx;

+	LONG styleMask=WS_CLIPCHILDREN|WS_BORDER|WS_CAPTION|WS_MINIMIZEBOX|WS_POPUPWINDOW|WS_CLIPCHILDREN|WS_THICKFRAME|WS_SYSMENU;

+	LONG styleMaskEx=WS_EX_TOOLWINDOW|WS_EX_LAYERED;

+	LONG curStyle,curStyleEx;

+	if (!pcli->hwndContactList) return;

+

+	g_mutex_bChangingMode=TRUE;

+	g_bTransparentFlag=IsWinVer2000Plus()&&ModernGetSettingByte( NULL,"CList","Transparent",SETTING_TRANSPARENT_DEFAULT);

+	g_CluiData.fSmoothAnimation=IsWinVer2000Plus()&&ModernGetSettingByte(NULL, "CLUI", "FadeInOut", SETTING_FADEIN_DEFAULT);

+	if (g_bTransparentFlag==0 && g_CluiData.bCurrentAlpha!=0)

+		g_CluiData.bCurrentAlpha=255;

+	//2- Calculate STYLES and STYLESEX

+	if (!g_CluiData.fLayered)

+	{

+		style=0;

+		styleEx=0;

+		if (ModernGetSettingByte(NULL,"CList","ThinBorder",SETTING_THINBORDER_DEFAULT) || (ModernGetSettingByte(NULL,"CList","NoBorder",SETTING_NOBORDER_DEFAULT)))

+		{

+			style=WS_CLIPCHILDREN| (ModernGetSettingByte(NULL,"CList","ThinBorder",SETTING_THINBORDER_DEFAULT)?WS_BORDER:0);

+			styleEx=WS_EX_TOOLWINDOW;

+			styleMaskEx |= WS_EX_APPWINDOW;

+		} 

+		else if (ModernGetSettingByte(NULL,"CLUI","ShowCaption",SETTING_SHOWCAPTION_DEFAULT) && ModernGetSettingByte(NULL,"CList","ToolWindow",SETTING_TOOLWINDOW_DEFAULT))

+		{

+			styleEx=WS_EX_TOOLWINDOW/*|WS_EX_WINDOWEDGE*/;

+			style=WS_CAPTION|WS_POPUPWINDOW|WS_CLIPCHILDREN|WS_THICKFRAME;

+			styleMaskEx |= WS_EX_APPWINDOW;

+		}

+		else if (ModernGetSettingByte(NULL,"CLUI","ShowCaption",SETTING_SHOWCAPTION_DEFAULT))

+		{

+			style=WS_CAPTION|WS_SYSMENU|WS_POPUPWINDOW|WS_CLIPCHILDREN|WS_THICKFRAME|WS_MINIMIZEBOX;

+		}

+		else 

+		{

+			style=WS_POPUPWINDOW|WS_CLIPCHILDREN|WS_THICKFRAME;

+			styleEx=WS_EX_TOOLWINDOW/*|WS_EX_WINDOWEDGE*/;

+			styleMaskEx |= WS_EX_APPWINDOW;

+		}

+	}

+	else 

+	{

+		style=WS_CLIPCHILDREN;

+		styleEx=WS_EX_TOOLWINDOW;

+		styleMaskEx |= WS_EX_APPWINDOW;

+	}

+	//3- TODO Update Layered mode

+	if(g_bTransparentFlag&&g_CluiData.fLayered)

+		styleEx|=WS_EX_LAYERED;

+

+	//4- Set Title

+	{

+		TCHAR titleText[255]={0};

+		DBVARIANT dbv={0};

+		if(ModernGetSettingTString(NULL,"CList","TitleText",&dbv))

+			lstrcpyn(titleText,TEXT(MIRANDANAME),SIZEOF(titleText));

+		else 

+		{

+			lstrcpyn(titleText,dbv.ptszVal,SIZEOF(titleText));

+			ModernDBFreeVariant(&dbv);

+		}

+		SetWindowText(pcli->hwndContactList,titleText);

+	}

+	//<->

+	//1- If visible store it and hide

+

+	if (g_CluiData.fLayered && (ModernGetSettingByte(NULL,"CList","OnDesktop", SETTING_ONDESKTOP_DEFAULT)))// && !flag_bFirstTimeCall))

+	{

+		SetParent(pcli->hwndContactList,NULL);

+		Sync( CLUIFrames_SetParentForContainers, (HWND) NULL );

+		UpdateWindow(pcli->hwndContactList);

+		g_CluiData.fOnDesktop=0;

+	}

+	//5- TODO Apply Style

+	oldStyleEx = curStyleEx = GetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE);

+	oldStyle = curStyle = GetWindowLongPtr(pcli->hwndContactList,GWL_STYLE);	

+

+	curStyleEx = (curStyleEx & ~styleMaskEx) | styleEx;

+	curStyle = (curStyle & ~styleMask) | style;

+	if (oldStyleEx != curStyleEx || oldStyle != curStyle)

+	{

+		if (IsWindowVisible(pcli->hwndContactList)) 

+		{

+			storedVisMode=TRUE;

+			mutex_bShowHideCalledFromAnimation=TRUE;

+			ShowWindow(pcli->hwndContactList,SW_HIDE);

+			Sync(CLUIFrames_OnShowHide, pcli->hwndContactList,0);

+		}

+		SetWindowLongPtr(pcli->hwndContactList,GWL_EXSTYLE,curStyleEx);

+		SetWindowLongPtr(pcli->hwndContactList,GWL_STYLE,curStyle);

+	}

+

+	CLUI_UpdateAeroGlass();

+

+	if(g_CluiData.fLayered || !ModernGetSettingByte(NULL,"CLUI","ShowMainMenu",SETTING_SHOWMAINMENU_DEFAULT)) 

+    {

+        HMENU m = GetMenu(pcli->hwndContactList);

+		SetMenu(pcli->hwndContactList,NULL);

+    }

+	else

+		SetMenu(pcli->hwndContactList,g_hMenuMain);

+

+	if (g_CluiData.fLayered&&(ModernGetSettingByte(NULL,"CList","OnDesktop", SETTING_ONDESKTOP_DEFAULT)))

+		ske_UpdateWindowImage();

+

+

+	//6- Pin to desktop mode

+	if (ModernGetSettingByte(NULL,"CList","OnDesktop", SETTING_ONDESKTOP_DEFAULT))

+	{

+		HWND hProgMan=FindWindow(TEXT("Progman"),NULL);

+		if (IsWindow(hProgMan)) 

+		{

+			SetParent(pcli->hwndContactList,hProgMan);

+			Sync( CLUIFrames_SetParentForContainers, (HWND) hProgMan );

+			g_CluiData.fOnDesktop=1;

+		}

+	} 

+	else 

+	{

+		//	HWND parent=GetParent(pcli->hwndContactList);

+		//	HWND progman=FindWindow(TEXT("Progman"),NULL);

+		//	if (parent==progman)

+		{

+			SetParent(pcli->hwndContactList,NULL);

+			Sync(CLUIFrames_SetParentForContainers, (HWND) NULL);

+		}

+		g_CluiData.fOnDesktop=0;

+	}

+

+	//7- if it was visible - show

+	if (storedVisMode) 

+	{

+		ShowWindow(pcli->hwndContactList,SW_SHOW);

+		Sync(CLUIFrames_OnShowHide, pcli->hwndContactList,1);

+	}

+	mutex_bShowHideCalledFromAnimation=FALSE;

+

+	CLUIFrames_UpdateBorders();

+

+	if (!g_CluiData.fLayered)

+	{

+		HRGN hRgn1;

+		RECT r;

+		int v,h;

+		int w=10;

+		GetWindowRect(pcli->hwndContactList,&r);

+		h=(r.right-r.left)>(w*2)?w:(r.right-r.left);

+		v=(r.bottom-r.top)>(w*2)?w:(r.bottom-r.top);

+		h=(h<v)?h:v;

+		hRgn1=CreateRoundRectRgn(0,0,(r.right-r.left+1),(r.bottom-r.top+1),h,h);

+		if ((ModernGetSettingByte(NULL,"CLC","RoundCorners",SETTING_ROUNDCORNERS_DEFAULT)) && (!CallService(MS_CLIST_DOCKINGISDOCKED,0,0)))

+			SetWindowRgn(pcli->hwndContactList,hRgn1,1); 

+		else 

+		{

+			DeleteObject(hRgn1);

+			SetWindowRgn(pcli->hwndContactList,NULL,1);

+		}

+

+		RedrawWindow(pcli->hwndContactList,NULL,NULL,RDW_INVALIDATE|RDW_ERASE|RDW_FRAME|RDW_UPDATENOW|RDW_ALLCHILDREN);   

+	} 			

+	g_mutex_bChangingMode=FALSE;

+	flag_bFirstTimeCall=TRUE;

+	AniAva_UpdateParent();

+}

+struct  _tagTimerAsync

+{

+	HWND hwnd;

+	int ID; 

+	int Timeout; 

+	TIMERPROC proc;

+};

+static UINT_PTR SetTimerSync(WPARAM wParam , LPARAM lParam)

+{

+	struct  _tagTimerAsync * call=(struct  _tagTimerAsync *) wParam;

+	return SetTimer(call->hwnd, call->ID ,call->Timeout, call->proc);

+}

+

+UINT_PTR CLUI_SafeSetTimer(HWND hwnd, int ID, int Timeout, TIMERPROC proc)

+{

+	struct  _tagTimerAsync param={  hwnd, ID, Timeout, proc };

+	return Sync(SetTimerSync, (WPARAM) &param, (LPARAM) 0);		

+}

+

+int CLUI_UpdateTimer(BYTE BringIn)

+{  

+	if (g_CluiData.nBehindEdgeState==0)

+	{

+		KillTimer(pcli->hwndContactList,TM_BRINGOUTTIMEOUT);

+		CLUI_SafeSetTimer(pcli->hwndContactList,TM_BRINGOUTTIMEOUT,wBehindEdgeHideDelay*100,NULL);

+	}

+	if (bShowEventStarted==0 && g_CluiData.nBehindEdgeState>0 ) 

+	{

+		KillTimer(pcli->hwndContactList,TM_BRINGINTIMEOUT);

+		bShowEventStarted=(BOOL)CLUI_SafeSetTimer(pcli->hwndContactList,TM_BRINGINTIMEOUT,wBehindEdgeShowDelay*100,NULL);

+	}

+	return 0;

+}

+

+int CLUI_HideBehindEdge()

+{

+	int method=g_CluiData.bBehindEdgeSettings;

+	if (method)

+	{

+		// if (DBGetContactSettingByte(NULL, "ModernData", "BehindEdge", SETTING_BEHINDEDGE_DEFAULT)==0)

+		{

+			RECT rcScreen;

+			RECT rcWindow;

+			int bordersize=0;

+			//Need to be moved out of screen

+			bShowEventStarted=0;

+			//1. get work area rectangle 

+			Docking_GetMonitorRectFromWindow(pcli->hwndContactList,&rcScreen);

+			//SystemParametersInfo(SPI_GETWORKAREA,0,&rcScreen,FALSE);

+			//2. move out

+			bordersize=wBehindEdgeBorderSize;

+			GetWindowRect(pcli->hwndContactList,&rcWindow);

+			switch (method)

+			{

+			case 1: //left

+				rcWindow.left=rcScreen.left-(rcWindow.right-rcWindow.left)+bordersize;

+				break;

+			case 2: //right

+				rcWindow.left=rcScreen.right-bordersize;

+				break;

+			}

+			g_CluiData.mutexPreventDockMoving=0;

+			SetWindowPos(pcli->hwndContactList,NULL,rcWindow.left,rcWindow.top,0,0,SWP_NOZORDER|SWP_NOSIZE|SWP_NOACTIVATE);

+			Sync(CLUIFrames_OnMoving,pcli->hwndContactList,&rcWindow);

+			g_CluiData.mutexPreventDockMoving=1;

+

+			//3. store setting

+			ModernWriteSettingByte(NULL, "ModernData", "BehindEdge",method);

+			g_CluiData.nBehindEdgeState=method;

+			return 1;

+		}

+		return 2;

+	}

+	return 0;

+}

+

+

+int CLUI_ShowFromBehindEdge()

+{

+	int method=g_CluiData.bBehindEdgeSettings;

+	bShowEventStarted=0;

+	if (g_mutex_bOnTrayRightClick) 

+	{

+		g_mutex_bOnTrayRightClick=0;

+		return 0;

+	}

+	if (method)// && (DBGetContactSettingByte(NULL, "ModernData", "BehindEdge", SETTING_BEHINDEDGE_DEFAULT)==0))

+	{

+		RECT rcScreen;

+		RECT rcWindow;

+		int bordersize=0;

+		//Need to be moved out of screen

+

+		//1. get work area rectangle 

+		//SystemParametersInfo(SPI_GETWORKAREA,0,&rcScreen,FALSE);

+		Docking_GetMonitorRectFromWindow(pcli->hwndContactList,&rcScreen);

+		//2. move out

+		bordersize=wBehindEdgeBorderSize;

+		GetWindowRect(pcli->hwndContactList,&rcWindow);

+		switch (method)

+		{

+		case 1: //left

+			rcWindow.left=rcScreen.left;

+			break;

+		case 2: //right

+			rcWindow.left=rcScreen.right-(rcWindow.right-rcWindow.left);

+			break;

+		}

+		g_CluiData.mutexPreventDockMoving=0;

+		SetWindowPos(pcli->hwndContactList,NULL,rcWindow.left,rcWindow.top,0,0,SWP_NOZORDER|SWP_NOSIZE);

+		Sync(CLUIFrames_OnMoving,pcli->hwndContactList,&rcWindow);

+		g_CluiData.mutexPreventDockMoving=1;

+

+		//3. store setting

+		ModernWriteSettingByte(NULL, "ModernData", "BehindEdge",0);

+		g_CluiData.nBehindEdgeState=0;

+	}

+	return 0;

+}

+

+

+int CLUI_IsInMainWindow(HWND hwnd)

+{

+	if (hwnd==pcli->hwndContactList) return 1;

+	if (GetParent(hwnd)==pcli->hwndContactList) return 2;

+	return 0;

+}

+

+int CLUI_OnSkinLoad(WPARAM wParam, LPARAM lParam)

+{

+	ske_LoadSkinFromDB();

+

+	return 0;

+}

+

+

+

+

+static LPPROTOTICKS CLUI_GetProtoTicksByProto(char * szProto)

+{

+	int i;

+

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

+	{

+		if (CycleStartTick[i].szProto==NULL) break;

+		if (mir_strcmp(CycleStartTick[i].szProto,szProto)) continue;

+		return(&CycleStartTick[i]);

+	}

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

+	{

+		if (CycleStartTick[i].szProto==NULL)

+		{

+			CycleStartTick[i].szProto=mir_strdup(szProto);

+			CycleStartTick[i].nCycleStartTick=0;

+			CycleStartTick[i].nIndex=i;			

+			CycleStartTick[i].bGlobal=( szProto[0]==0 );

+			CycleStartTick[i].himlIconList=NULL;

+			return(&CycleStartTick[i]);

+		}

+	}

+	return (NULL);

+}

+

+static int CLUI_GetConnectingIconForProtoCount(char *szAccoName)

+{

+	char fileFull[MAX_PATH];

+	static char szFolderPath[MAX_PATH] = "";

+

+	int count = 8;

+

+	if ( !szFolderPath[0] )

+	{

+		char szRelativePath[MAX_PATH];

+		GetModuleFileNameA(GetModuleHandle(NULL), szRelativePath, MAX_PATH);

+		char *str = strrchr( szRelativePath, '\\' ); 

+		if ( str != NULL ) *str=0;

+		CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)szRelativePath, (LPARAM)szFolderPath);

+	}

+

+	if ( szAccoName )

+	{

+		// first of all try to find by account name( or empty - global )

+		mir_snprintf( fileFull, SIZEOF(fileFull), "%s\\Icons\\proto_conn_%s.dll", szFolderPath, szAccoName );

+		count = ExtractIconExA(fileFull,-1,NULL,NULL,1);

+		if ( count ) return count;

+

+		if ( szAccoName[0] )

+		{

+			// second try to find by protocol name

+			PROTOACCOUNT * acc = ProtoGetAccount( szAccoName );

+			if ( acc && !acc->bOldProto )

+			{

+				mir_snprintf( fileFull, SIZEOF(fileFull), "%s\\Icons\\proto_conn_%s.dll", szFolderPath, acc->szProtoName );

+				count = ExtractIconExA(fileFull,-1,NULL,NULL,1);

+				if ( count ) return count;

+			}

+		}

+	}

+	// third try global

+	mir_snprintf( fileFull, SIZEOF(fileFull), "%s\\Icons\\proto_conn.dll", szFolderPath );

+	count = ExtractIconExA(fileFull,-1,NULL,NULL,1);

+	if ( count ) return count;

+

+	return 8;

+}

+

+static HICON CLUI_ExtractIconFromPath(const char *path, BOOL * needFree)

+{

+	char *comma;

+	char file[MAX_PATH],fileFull[MAX_PATH];

+	int n;

+	HICON hIcon;

+	lstrcpynA(file,path,sizeof(file));

+	comma=strrchr(file,',');

+	if(comma==NULL) n=0;

+	else {n=atoi(comma+1); *comma=0;}

+	CallService(MS_UTILS_PATHTOABSOLUTE, (WPARAM)file, (LPARAM)fileFull);

+	hIcon=NULL;

+	ExtractIconExA(fileFull,n,NULL,&hIcon,1);

+	if (needFree)

+	{

+		*needFree=(hIcon!=NULL);

+	}

+	return hIcon;

+}

+

+HICON CLUI_LoadIconFromExternalFile(char *filename,int i,boolean UseLibrary,boolean registerit,char *IconName,char *SectName,char *Description,int internalidx, BOOL * needFree)

+{

+	char szPath[MAX_PATH],szMyPath[MAX_PATH], szFullPath[MAX_PATH],*str;

+	HICON hIcon=NULL;

+	BOOL has_proto_icon=FALSE;

+	SKINICONDESC sid={0};

+	if (needFree) *needFree=FALSE;

+	GetModuleFileNameA(GetModuleHandle(NULL), szPath, MAX_PATH);

+	GetModuleFileNameA(g_hInst, szMyPath, MAX_PATH);

+	str=strrchr(szPath,'\\');

+	if(str!=NULL) *str=0;

+	if (UseLibrary&2) 

+		mir_snprintf(szMyPath, SIZEOF(szMyPath), "%s\\Icons\\%s", szPath, filename);

+	mir_snprintf(szFullPath, SIZEOF(szFullPath), "%s\\Icons\\%s,%d", szPath, filename, i);

+	if(str!=NULL) *str='\\';

+	if (UseLibrary&2)

+	{

+		BOOL nf;

+		HICON hi=CLUI_ExtractIconFromPath(szFullPath,&nf);

+		if (hi) has_proto_icon=TRUE;

+		if (hi && nf) DestroyIcon(hi);

+	}

+	if (!UseLibrary||!ServiceExists(MS_SKIN2_ADDICON))

+	{		

+		hIcon=CLUI_ExtractIconFromPath(szFullPath,needFree);

+		if (hIcon) return hIcon;

+		if (UseLibrary)

+		{

+			mir_snprintf(szFullPath, SIZEOF(szFullPath), "%s,%d", szMyPath, internalidx);

+			hIcon=CLUI_ExtractIconFromPath(szFullPath,needFree);

+			if (hIcon) return hIcon;		

+		}

+	}

+	else

+	{

+		if (registerit&&IconName!=NULL&&SectName!=NULL)	

+		{

+			sid.cbSize = sizeof(sid);

+			sid.cx=16;

+			sid.cy=16;

+			sid.hDefaultIcon = (has_proto_icon||!(UseLibrary&2))?NULL:(HICON)CallService(MS_SKIN_LOADPROTOICON,(WPARAM)NULL,(LPARAM)(-internalidx));

+			sid.pszSection=SectName;

+			sid.pszName=IconName;

+			sid.pszDescription=Description;

+			sid.pszDefaultFile=internalidx<0?szMyPath:szPath;

+

+			sid.iDefaultIndex=(UseLibrary&2)?i:(internalidx<0)?internalidx:-internalidx;

+			CallService(MS_SKIN2_ADDICON, 0, (LPARAM)&sid);

+		}

+		return ((HICON)CallService(MS_SKIN2_GETICON, 0, (LPARAM)IconName));

+	}

+

+

+

+

+	return (HICON)0;

+}

+

+static HICON CLUI_GetConnectingIconForProto(char *szAccoName, int b)

+{

+	char szFullPath[MAX_PATH];

+	HICON hIcon=NULL;

+	BOOL needFree;

+	b=b-1;

+	

+	if ( szAccoName )

+	{

+		mir_snprintf(szFullPath, SIZEOF(szFullPath), "proto_conn_%s.dll",szAccoName);

+		hIcon = CLUI_LoadIconFromExternalFile(szFullPath,b+1,FALSE,FALSE,NULL,NULL,NULL,0,&needFree);

+		if (hIcon) return hIcon;

+

+		if ( szAccoName[0] )

+		{

+			// second try to find by protocol name

+			PROTOACCOUNT * acc = ProtoGetAccount( szAccoName );

+			if ( acc && !acc->bOldProto )

+			{

+				mir_snprintf( szFullPath, SIZEOF(szFullPath), "proto_conn_%s.dll", acc->szProtoName );

+				hIcon = CLUI_LoadIconFromExternalFile(szFullPath,b+1,FALSE,FALSE,NULL,NULL,NULL,0,&needFree);

+				if ( hIcon ) return hIcon;

+			}

+		}

+	}

+	// third try global

+	mir_snprintf( szFullPath, SIZEOF(szFullPath), "proto_conn.dll" );

+	hIcon = CLUI_LoadIconFromExternalFile(szFullPath,b+1,FALSE,FALSE,NULL,NULL,NULL,0,&needFree);

+	if ( hIcon ) return hIcon;

+

+	hIcon=LoadSmallIcon(g_hInst,(TCHAR *)(IDI_ICQC1+b+1));

+	return(hIcon);

+}

+

+

+INT_PTR CLUI_GetConnectingIconService(WPARAM wParam,LPARAM lParam)

+{

+	int b;						

+	PROTOTICKS *pt=NULL;

+	HICON hIcon=NULL;

+

+	char *szProto=(char *)wParam;

+	if (!szProto) return 0;

+

+	pt=CLUI_GetProtoTicksByProto(szProto);

+

+	if (pt!=NULL)

+	{

+		if (pt->nCycleStartTick==0)

+		{

+			CLUI_CreateTimerForConnectingIcon(ID_STATUS_CONNECTING,wParam);

+			pt=CLUI_GetProtoTicksByProto(szProto);

+		}

+	}

+	if (pt!=NULL)

+	{

+		if (pt->nCycleStartTick!=0&&pt->nIconsCount!=0) 

+		{					

+			b=((GetTickCount()-pt->nCycleStartTick)/(nAnimatedIconStep))%(pt->nIconsCount);

+			//	if (lParam)

+			//		hIcon=CLUI_GetConnectingIconForProto("Global",b);

+			//	else

+			if (pt->himlIconList)

+				hIcon=ske_ImageList_GetIcon(pt->himlIconList,b,ILD_NORMAL);

+			else

+				hIcon=NULL;

+			//hIcon=CLUI_GetConnectingIconForProto(szProto,b);

+		};

+	}

+

+

+	return (INT_PTR)hIcon;

+};

+

+

+static int CLUI_CreateTimerForConnectingIcon(WPARAM wParam,LPARAM lParam)

+{

+

+	int status=(int)wParam;

+	char *szProto=(char *)lParam;					

+	if (!szProto) return (0);

+	if (!status) return (0);

+

+	if ((g_StatusBarData.connectingIcon==1)&&status>=ID_STATUS_CONNECTING&&status<=ID_STATUS_CONNECTING+MAX_CONNECT_RETRIES)

+	{

+

+		PROTOTICKS *pt=NULL;

+		int cnt;

+

+		pt=CLUI_GetProtoTicksByProto(szProto);

+		if (pt!=NULL)

+		{

+			if (pt->nCycleStartTick==0) 

+			{					

+				KillTimer(pcli->hwndContactList,TM_STATUSBARUPDATE+pt->nIndex);

+				cnt=CLUI_GetConnectingIconForProtoCount(szProto);

+				if (cnt!=0)

+				{

+					int i=0;

+					nAnimatedIconStep=100;/*DBGetContactSettingWord(NULL,"CLUI","DefaultStepConnectingIcon",100);*/

+					pt->nIconsCount=cnt;

+					if (pt->himlIconList) ImageList_Destroy(pt->himlIconList);

+					pt->himlIconList=ImageList_Create(16,16,ILC_MASK|ILC_COLOR32,cnt,1);

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

+					{

+						HICON ic=CLUI_GetConnectingIconForProto(szProto,i);

+						if (ic) ImageList_AddIcon(pt->himlIconList,ic);

+						DestroyIcon_protect(ic);

+					}

+					CLUI_SafeSetTimer(pcli->hwndContactList,TM_STATUSBARUPDATE+pt->nIndex,(int)(nAnimatedIconStep)/1,0);

+					pt->bTimerCreated=1;

+					pt->nCycleStartTick=GetTickCount();

+				}

+

+			};

+		};

+	}

+	return 0;

+}

+

+static BOOL CALLBACK BroadcastEnumChildProc(HWND hwndChild, LPARAM lParam) 

+{

+	MSG * pMsg=(MSG*)lParam;

+	SendNotifyMessage( hwndChild, pMsg->message, pMsg->wParam, pMsg->lParam );

+	EnumChildWindows( hwndChild, BroadcastEnumChildProc, lParam );

+	return TRUE;

+}

+

+static LRESULT BroadCastMessageToChild(HWND hwnd, int message, WPARAM wParam, LPARAM lParam )

+{

+	MSG msg={0};

+	msg.hwnd=hwnd;

+	msg.lParam=lParam;

+	msg.wParam=wParam;

+	msg.message=message;

+	EnumChildWindows(hwnd, BroadcastEnumChildProc, (LPARAM) &msg);

+	return 1;

+}

+

+int CLUI_ReloadCLUIOptions()

+{

+	KillTimer(pcli->hwndContactList,TM_UPDATEBRINGTIMER);

+	g_CluiData.bBehindEdgeSettings=ModernGetSettingByte(NULL, "ModernData", "HideBehind", SETTING_HIDEBEHIND_DEFAULT);

+	wBehindEdgeShowDelay=ModernGetSettingWord(NULL,"ModernData","ShowDelay",SETTING_SHOWDELAY_DEFAULT);

+	wBehindEdgeHideDelay=ModernGetSettingWord(NULL,"ModernData","HideDelay",SETTING_HIDEDELAY_DEFAULT);

+	wBehindEdgeBorderSize=ModernGetSettingWord(NULL,"ModernData","HideBehindBorderSize",SETTING_HIDEBEHINDBORDERSIZE_DEFAULT);

+

+	g_CluiData.fAutoSize=ModernGetSettingByte(NULL,"CLUI","AutoSize",SETTING_AUTOSIZE_DEFAULT);

+	g_CluiData.bInternalAwayMsgDiscovery = ModernGetSettingByte(NULL,"ModernData","InternalAwayMsgDiscovery",SETTING_INTERNALAWAYMSGREQUEST_DEFAULT);

+	g_CluiData.bRemoveAwayMessageForOffline =   ModernGetSettingByte(NULL,"ModernData","RemoveAwayMessageForOffline",SETTING_REMOVEAWAYMSGFOROFFLINE_DEFAULT);

+	//window borders

+	if (g_CluiData.fDisableSkinEngine) {

+		g_CluiData.LeftClientMargin=0;

+		g_CluiData.RightClientMargin=0; 

+		g_CluiData.TopClientMargin=0;

+		g_CluiData.BottomClientMargin=0;

+	} else {

+		//window borders

+		g_CluiData.LeftClientMargin=(int)ModernGetSettingByte(NULL,"CLUI","LeftClientMargin",SETTING_LEFTCLIENTMARIGN_DEFAULT);

+		g_CluiData.RightClientMargin=(int)ModernGetSettingByte(NULL,"CLUI","RightClientMargin",SETTING_RIGHTCLIENTMARIGN_DEFAULT); 

+		g_CluiData.TopClientMargin=(int)ModernGetSettingByte(NULL,"CLUI","TopClientMargin",SETTING_TOPCLIENTMARIGN_DEFAULT);

+		g_CluiData.BottomClientMargin=(int)ModernGetSettingByte(NULL,"CLUI","BottomClientMargin",SETTING_BOTTOMCLIENTMARIGN_DEFAULT);

+	}			

+	BroadCastMessageToChild(pcli->hwndContactList, WM_THEMECHANGED, 0, 0);

+

+	NotifyEventHooks(g_CluiData.hEventBkgrChanged, 0, 0);

+	return 0;

+}

+

+void CLUI_DisconnectAll()

+{

+	PROTOACCOUNT **accs;

+	int nProtoCount;

+	int nProto;

+

+	ProtoEnumAccounts( &nProtoCount, &accs );

+	for (nProto = 0; nProto < nProtoCount; nProto++)

+        if ( IsAccountEnabled( accs[nProto] ))

+		    CallProtoService( accs[nProto]->szModuleName, PS_SETSTATUS, ID_STATUS_OFFLINE, 0 );

+}

+

+static int CLUI_DrawMenuBackGround(HWND hwnd, HDC hdc, int item, int state)

+{

+	RECT ra,r1;

+	//    HBRUSH hbr;

+	HRGN treg,treg2;

+	struct ClcData * dat;

+

+	if ( !fnGetMenuBarInfo )

+		return 1;

+

+	dat=(struct ClcData*)GetWindowLongPtr(pcli->hwndContactTree,0);

+	if (!dat) return 1;

+	GetWindowRect(hwnd,&ra);

+	{

+		MENUBARINFO mbi={0};

+		mbi.cbSize=sizeof(MENUBARINFO);

+		fnGetMenuBarInfo(hwnd,OBJID_MENU, 0, &mbi);

+		if (!(mbi.rcBar.right-mbi.rcBar.left>0 && mbi.rcBar.bottom-mbi.rcBar.top>0)) return 1;

+		r1=mbi.rcBar;  

+		r1.bottom+= !ModernGetSettingByte(NULL,"CLUI","LineUnderMenu",SETTING_LINEUNDERMENU_DEFAULT);

+		if (item<1)

+		{           

+			treg=CreateRectRgn(mbi.rcBar.left,mbi.rcBar.top,mbi.rcBar.right,r1.bottom);

+			if (item==0)  //should remove item clips

+			{

+				int t;

+				for (t=1; t<=2; t++)

+				{

+					fnGetMenuBarInfo(hwnd,OBJID_MENU, t, &mbi);

+					treg2=CreateRectRgn(mbi.rcBar.left,mbi.rcBar.top,mbi.rcBar.right,mbi.rcBar.bottom);

+					CombineRgn(treg,treg,treg2,RGN_DIFF);

+					DeleteObject(treg2);  

+				}

+

+			}

+		}

+		else

+		{

+			fnGetMenuBarInfo(hwnd,OBJID_MENU, item, &mbi);

+			treg=CreateRectRgn(mbi.rcBar.left,mbi.rcBar.top,mbi.rcBar.right,mbi.rcBar.bottom+!ModernGetSettingByte(NULL,"CLUI","LineUnderMenu",SETTING_LINEUNDERMENU_DEFAULT));

+		}

+		OffsetRgn(treg,-ra.left,-ra.top);

+		r1.left-=ra.left;

+		r1.top-=ra.top;

+		r1.bottom-=ra.top;

+		r1.right-=ra.left;

+	}   

+	//SelectClipRgn(hdc,NULL);

+	SelectClipRgn(hdc,treg);

+	DeleteObject(treg); 

+	{

+		RECT rc;

+		HWND hwnd=pcli->hwndContactList;

+		GetWindowRect(hwnd,&rc);

+		OffsetRect(&rc,-rc.left, -rc.top);

+		FillRect(hdc,&r1,GetSysColorBrush(COLOR_MENU));

+		ske_SetRectOpaque(hdc,&r1);

+		//ske_BltBackImage(hwnd,hdc,&r1);

+	}

+	if (!g_CluiData.fDisableSkinEngine)

+		SkinDrawGlyph(hdc,&r1,&r1,"Main,ID=MenuBar");

+	else

+	{

+		HBRUSH hbr=NULL;

+		if (dat->hMenuBackground)

+		{

+			BITMAP bmp;

+			HBITMAP oldbm;

+			HDC hdcBmp;

+			int x,y;

+			int maxx,maxy;

+			int destw,desth;

+			RECT clRect=r1;

+

+

+			// XXX: Halftone isnt supported on 9x, however the scretch problems dont happen on 98.

+			SetStretchBltMode(hdc, HALFTONE);

+

+			GetObject(dat->hMenuBackground,sizeof(bmp),&bmp);

+			hdcBmp=CreateCompatibleDC(hdc);

+			oldbm=(HBITMAP)SelectObject(hdcBmp,dat->hMenuBackground);

+			y=clRect.top;

+			x=clRect.left;

+			maxx=dat->MenuBmpUse&CLBF_TILEH?maxx=r1.right:x+1;

+			maxy=dat->MenuBmpUse&CLBF_TILEV?maxy=r1.bottom:y+1;

+			switch(dat->MenuBmpUse&CLBM_TYPE) {

+	case CLB_STRETCH:

+		if(dat->MenuBmpUse&CLBF_PROPORTIONAL) {

+			if(clRect.right-clRect.left*bmp.bmHeight<clRect.bottom-clRect.top*bmp.bmWidth) 

+			{

+				desth=clRect.bottom-clRect.top;

+				destw=desth*bmp.bmWidth/bmp.bmHeight;

+			}

+			else 

+			{

+				destw=clRect.right-clRect.left;

+				desth=destw*bmp.bmHeight/bmp.bmWidth;

+			}

+		}

+		else {

+			destw=clRect.right-clRect.left;

+			desth=clRect.bottom-clRect.top;

+		}

+		break;

+	case CLB_STRETCHH:

+		if(dat->MenuBmpUse&CLBF_PROPORTIONAL) {

+			destw=clRect.right-clRect.left;

+			desth=destw*bmp.bmHeight/bmp.bmWidth;

+		}

+		else {

+			destw=clRect.right-clRect.left;

+			desth=bmp.bmHeight;

+		}

+		break;

+	case CLB_STRETCHV:

+		if(dat->MenuBmpUse&CLBF_PROPORTIONAL) {

+			desth=clRect.bottom-clRect.top;

+			destw=desth*bmp.bmWidth/bmp.bmHeight;

+		}

+		else {

+			destw=bmp.bmWidth;

+			desth=clRect.bottom-clRect.top;

+		}

+		break;

+	default:    //clb_topleft

+		destw=bmp.bmWidth;

+		desth=bmp.bmHeight;					

+		break;

+			}

+			if (desth && destw)

+				for(y=clRect.top;y<maxy;y+=desth) {

+					for(x=clRect.left;x<maxx;x+=destw)

+						StretchBlt(hdc,x,y,destw,desth,hdcBmp,0,0,bmp.bmWidth,bmp.bmHeight,SRCCOPY);

+				}

+				SelectObject(hdcBmp,oldbm);

+				DeleteDC(hdcBmp);

+

+		}                  

+

+		else

+		{

+			hbr=CreateSolidBrush(dat->MenuBkColor);

+			FillRect(hdc,&r1,hbr);

+			DeleteObject(hbr);    

+		}

+		if (item!=0 && state&(ODS_SELECTED)) 

+		{

+			hbr=CreateSolidBrush(dat->MenuBkHiColor);

+			FillRect(hdc,&r1,hbr);

+			DeleteObject(hbr);

+		}

+	}

+	SelectClipRgn(hdc,NULL);

+	return 0;

+}

+

+int CLUI_SizingGetWindowRect(HWND hwnd,RECT * rc)

+{

+	if (mutex_bDuringSizing && hwnd==pcli->hwndContactList)

+		*rc=rcSizingRect;

+	else

+		GetWindowRect(hwnd,rc);

+	return 1;

+}

+

+

+int CLUI_SyncGetPDNCE(WPARAM wParam, LPARAM lParam)

+{

+	//log0("CLUI_SyncGetPDNCE");

+	return CListSettings_GetCopyFromCache((pdisplayNameCacheEntry)lParam, wParam ? (DWORD) wParam : CCI_ALL );

+}

+

+int CLUI_SyncSetPDNCE(WPARAM wParam, LPARAM lParam)

+{

+	//log0("CLUI_SyncSetPDNCE");

+	return CListSettings_SetToCache((pdisplayNameCacheEntry)lParam, wParam ?  (DWORD) wParam : CCI_ALL );

+}

+

+int CLUI_SyncGetShortData(WPARAM wParam, LPARAM lParam)

+{

+	HWND hwnd=(HWND) wParam;

+	struct ClcData * dat=(struct ClcData * )GetWindowLongPtr(hwnd,0);

+	//log0("CLUI_SyncGetShortData");

+	return ClcGetShortData(dat,(struct SHORTDATA *)lParam);

+}

+

+int CLUI_SyncSmoothAnimation(WPARAM wParam, LPARAM lParam)

+{

+	return CLUI_SmoothAlphaThreadTransition((HWND)lParam);

+}

+

+

+

+int CLUI_IconsChanged(WPARAM wParam,LPARAM lParam)

+{

+	if (MirandaExiting()) return 0;

+	DrawMenuBar(pcli->hwndContactList);

+	ExtraImage_ReloadExtraIcons();

+	ExtraImage_SetAllExtraIcons(pcli->hwndContactTree,0);

+	// need to update tray cause it use combined icons

+	pcli->pfnTrayIconIconsChanged();  //TODO: remove as soon as core will include icolib

+	ske_RedrawCompleteWindow();

+	//	pcli->pfnClcBroadcast( INTM_INVALIDATE,0,0);

+	return 0;

+}

+

+

+

+

+

+

+

+

+

+void CLUI_cli_LoadCluiGlobalOpts()

+{

+	BOOL tLayeredFlag=FALSE;

+	tLayeredFlag=IsWinVer2000Plus();

+	tLayeredFlag&=ModernGetSettingByte(NULL, "ModernData", "EnableLayering", tLayeredFlag);

+

+	if(tLayeredFlag)

+	{

+		if (ModernGetSettingByte(NULL,"CList","WindowShadow",SETTING_WINDOWSHADOW_DEFAULT)==1)

+			ModernWriteSettingByte(NULL,"CList","WindowShadow",2);    

+	}

+	else

+	{

+		if (ModernGetSettingByte(NULL,"CList","WindowShadow",SETTING_WINDOWSHADOW_DEFAULT)==2)

+			ModernWriteSettingByte(NULL,"CList","WindowShadow",1); 

+	}

+	corecli.pfnLoadCluiGlobalOpts();

+}

+

+

+int CLUI_TestCursorOnBorders()

+{

+	HWND hwnd=pcli->hwndContactList;

+	HCURSOR hCurs1=NULL;

+	RECT r;  

+	POINT pt;

+	int k=0, t=0, fx,fy;

+	HWND hAux;

+	BOOL mouse_in_window=0;

+	HWND gf=GetForegroundWindow();

+	GetCursorPos(&pt);

+	hAux = WindowFromPoint(pt);	

+	if (CLUI_CheckOwnedByClui(hAux))

+	{

+		if(g_bTransparentFlag) {

+			if (!bTransparentFocus && gf!=hwnd) {

+				CLUI_SmoothAlphaTransition(hwnd, ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), 1);

+				//g_proc_SetLayeredWindowAttributes(hwnd, RGB(0,0,0), (BYTE)DBGetContactSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), LWA_ALPHA);

+				bTransparentFocus=1;

+				CLUI_SafeSetTimer(hwnd, TM_AUTOALPHA,250,NULL);

+			}

+		}

+	}

+

+	mutex_bIgnoreActivation=0;

+	GetWindowRect(hwnd,&r);

+	/*

+	*  Size borders offset (contract)

+	*/

+	r.top+=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Top",SKIN_OFFSET_TOP_DEFAULT);

+	r.bottom-=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Bottom",SKIN_OFFSET_BOTTOM_DEFAULT);

+	r.left+=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Left",SKIN_OFFSET_LEFT_DEFAULT);

+	r.right-=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Right",SKIN_OFFSET_RIGHT_DEFAULT);

+

+	if (r.right<r.left) r.right=r.left;

+	if (r.bottom<r.top) r.bottom=r.top;

+

+	/*

+	*  End of size borders offset (contract)

+	*/

+

+	hAux = WindowFromPoint(pt);

+	while(hAux != NULL) 

+	{

+		if (hAux == hwnd) {mouse_in_window=1; break;}

+		hAux = GetParent(hAux);

+	}

+	fx=GetSystemMetrics(SM_CXFULLSCREEN);

+	fy=GetSystemMetrics(SM_CYFULLSCREEN);

+	if (g_CluiData.fDocked || g_CluiData.nBehindEdgeState==0)

+		//if (g_CluiData.fDocked) || ((pt.x<fx-1) && (pt.y<fy-1) && pt.x>1 && pt.y>1)) // workarounds for behind the edge.

+	{

+		//ScreenToClient(hwnd,&pt);

+		//GetClientRect(hwnd,&r);

+		if (pt.y<=r.bottom && pt.y>=r.bottom-SIZING_MARGIN && !g_CluiData.fAutoSize) k=6;

+		else if (pt.y>=r.top && pt.y<=r.top+SIZING_MARGIN && !g_CluiData.fAutoSize) k=3;

+		if (pt.x<=r.right && pt.x>=r.right-SIZING_MARGIN && g_CluiData.bBehindEdgeSettings!=2) k+=2;

+		else if (pt.x>=r.left && pt.x<=r.left+SIZING_MARGIN && g_CluiData.bBehindEdgeSettings!=1) k+=1;

+		if (!(pt.x>=r.left && pt.x<=r.right && pt.y>=r.top && pt.y<=r.bottom)) k=0;

+		k*=mouse_in_window;

+		hCurs1 = LoadCursor(NULL, IDC_ARROW);

+		if(g_CluiData.nBehindEdgeState<=0 && (!(ModernGetSettingByte(NULL,"CLUI","LockSize",SETTING_LOCKSIZE_DEFAULT))))

+			switch(k)

+		{

+			case 1: 

+			case 2:

+				if (!g_CluiData.fDocked||(g_CluiData.fDocked==2 && k==1)||(g_CluiData.fDocked==1 && k==2)){hCurs1 = LoadCursor(NULL, IDC_SIZEWE); break;}

+			case 3: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENS); break;}

+			case 4: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENWSE); break;}

+			case 5: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENESW); break;}

+			case 6: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENS); break;}

+			case 7: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENESW); break;}

+			case 8: if (!g_CluiData.fDocked) {hCurs1 = LoadCursor(NULL, IDC_SIZENWSE); break;}

+		}

+		if (hCurs1) SetCursor(hCurs1);

+		return k;

+	}

+

+	return 0;

+}

+

+int CLUI_SizingOnBorder(POINT pt, int PerformSize)

+{

+	if (!(ModernGetSettingByte(NULL,"CLUI","LockSize",SETTING_LOCKSIZE_DEFAULT)))

+	{

+		RECT r;

+		HWND hwnd=pcli->hwndContactList;

+		int sizeOnBorderFlag=0;

+		GetWindowRect(hwnd,&r);

+		/*

+		*  Size borders offset (contract)

+		*/

+		r.top+=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Top",SKIN_OFFSET_TOP_DEFAULT);

+		r.bottom-=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Bottom",SKIN_OFFSET_BOTTOM_DEFAULT);

+		r.left+=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Left",SKIN_OFFSET_LEFT_DEFAULT);

+		r.right-=ModernGetSettingDword(NULL,"ModernSkin","SizeMarginOffset_Right",SKIN_OFFSET_RIGHT_DEFAULT);

+

+		if (r.right<r.left) r.right=r.left;

+		if (r.bottom<r.top) r.bottom=r.top;

+

+		/*

+		*  End of size borders offset (contract)

+		*/

+		if ( !g_CluiData.fAutoSize )

+		{

+			if      ( pt.y <= r.bottom && pt.y >= r.bottom - SIZING_MARGIN )    sizeOnBorderFlag  = SCF_BOTTOM;

+			else if ( pt.y >= r.top    && pt.y <= r.top + SIZING_MARGIN )       sizeOnBorderFlag  = SCF_TOP;

+		}

+

+		if ( pt.x <= r.right && pt.x >= r.right - SIZING_MARGIN )               sizeOnBorderFlag += SCF_RIGHT;

+		else if ( pt.x >= r.left && pt.x <= r.left + SIZING_MARGIN )            sizeOnBorderFlag += SCF_LEFT;

+

+		if (!(pt.x>=r.left && pt.x<=r.right && pt.y>=r.top && pt.y<=r.bottom))  sizeOnBorderFlag  = SCF_NONE;

+

+		if (sizeOnBorderFlag && PerformSize) 

+		{ 

+			ReleaseCapture();

+			SendMessage(hwnd, WM_SYSCOMMAND, SC_SIZE + sizeOnBorderFlag,MAKELPARAM(pt.x,pt.y));					

+			return sizeOnBorderFlag;

+		}

+		else return sizeOnBorderFlag;

+	}

+	return SCF_NONE;

+}

+int CLUI_SyncSmoothAnimation(WPARAM wParam, LPARAM lParam);

+static void CLUI_SmoothAnimationThreadProc(HWND hwnd)

+{

+	//  return;

+	if (!mutex_bAnimationInProgress) 

+	{

+		g_dwSmoothAnimationThreadID=0;

+		return;  /// Should be some locked to avoid painting against contact deletion.

+	}

+	do

+	{

+		if (!g_mutex_bLockUpdating)

+		{

+			if (!MirandaExiting())

+				Sync(CLUI_SyncSmoothAnimation, (WPARAM)0, (LPARAM)hwnd );

+			SleepEx(20,TRUE);

+			if (MirandaExiting()) 

+			{

+				g_dwSmoothAnimationThreadID=0;

+				return;

+			}

+		}

+		else SleepEx(0,TRUE);

+

+	} while (mutex_bAnimationInProgress);

+	g_dwSmoothAnimationThreadID=0;

+	return;

+}

+

+static int CLUI_SmoothAlphaThreadTransition(HWND hwnd)

+{

+	int step;

+	int a;

+

+	step=(g_CluiData.bCurrentAlpha>bAlphaEnd)?-1*ANIMATION_STEP:ANIMATION_STEP;

+	a=g_CluiData.bCurrentAlpha+step;

+	if ((step>=0 && a>=bAlphaEnd) || (step<=0 && a<=bAlphaEnd))

+	{

+		mutex_bAnimationInProgress=0;

+		g_CluiData.bCurrentAlpha=bAlphaEnd;

+		if (g_CluiData.bCurrentAlpha==0)

+		{			

+			g_CluiData.bCurrentAlpha=1;

+			ske_JustUpdateWindowImage();

+			mutex_bShowHideCalledFromAnimation=1;             

+			CLUI_ShowWindowMod(pcli->hwndContactList,0);

+			Sync(CLUIFrames_OnShowHide, hwnd,0);

+			mutex_bShowHideCalledFromAnimation=0;

+			g_CluiData.bCurrentAlpha=0;

+			if (!g_CluiData.fLayered) RedrawWindow(pcli->hwndContactList,NULL,NULL,RDW_ERASE|RDW_FRAME);

+			return 0;			

+		}

+	}

+	else   g_CluiData.bCurrentAlpha=a;   

+	ske_JustUpdateWindowImage();     

+	return 1;

+}

+

+int CLUI_SmoothAlphaTransition(HWND hwnd, BYTE GoalAlpha, BOOL wParam)

+{ 

+

+	if ((!g_CluiData.fLayered

+		&& (!g_CluiData.fSmoothAnimation && !g_bTransparentFlag))||!g_proc_SetLayeredWindowAttributesNew)

+	{

+		if (GoalAlpha>0 && wParam!=2)

+		{

+			if (!IsWindowVisible(hwnd))

+			{

+				mutex_bShowHideCalledFromAnimation=1;

+				CLUI_ShowWindowMod(pcli->hwndContactList,SW_RESTORE);

+				Sync(CLUIFrames_OnShowHide, hwnd,1);

+				mutex_bShowHideCalledFromAnimation=0;

+				g_CluiData.bCurrentAlpha=GoalAlpha;

+				ske_UpdateWindowImage();

+

+			}

+		}

+		else if (GoalAlpha==0 && wParam!=2)

+		{

+			if (IsWindowVisible(hwnd))

+			{

+				mutex_bShowHideCalledFromAnimation=1;

+				CLUI_ShowWindowMod(pcli->hwndContactList,0);

+				Sync(CLUIFrames_OnShowHide, hwnd,0);

+				g_CluiData.bCurrentAlpha=GoalAlpha;

+				mutex_bShowHideCalledFromAnimation=0;

+

+			}

+		}

+		return 0;

+	}

+	if (g_CluiData.bCurrentAlpha==GoalAlpha &&0)

+	{

+		if (mutex_bAnimationInProgress)

+		{

+			KillTimer(hwnd,TM_SMOTHALPHATRANSITION);

+			mutex_bAnimationInProgress=0;

+		}

+		return 0;

+	}

+	if (mutex_bShowHideCalledFromAnimation) return 0;

+	if (wParam!=2)  //not from timer

+	{   

+		bAlphaEnd=GoalAlpha;

+		if (!mutex_bAnimationInProgress)

+		{

+			if ((!IsWindowVisible(hwnd)||g_CluiData.bCurrentAlpha==0) && bAlphaEnd>0 )

+			{

+				mutex_bShowHideCalledFromAnimation=1;            

+				CLUI_ShowWindowMod(pcli->hwndContactList,SW_SHOWNA);			 

+				Sync(CLUIFrames_OnShowHide, hwnd,SW_SHOW);

+				mutex_bShowHideCalledFromAnimation=0;

+				g_CluiData.bCurrentAlpha=1;

+				ske_UpdateWindowImage();

+			}

+			if (IsWindowVisible(hwnd) && !g_dwSmoothAnimationThreadID)

+			{

+				mutex_bAnimationInProgress=1;

+				if (g_CluiData.fSmoothAnimation)

+					g_dwSmoothAnimationThreadID=(DWORD)mir_forkthread((pThreadFunc)CLUI_SmoothAnimationThreadProc,pcli->hwndContactList);	

+

+			}

+		}

+	}

+

+	{

+		int step;

+		int a;

+		step=(g_CluiData.bCurrentAlpha>bAlphaEnd)?-1*ANIMATION_STEP:ANIMATION_STEP;

+		a=g_CluiData.bCurrentAlpha+step;

+		if ((step>=0 && a>=bAlphaEnd) || (step<=0 && a<=bAlphaEnd) || g_CluiData.bCurrentAlpha==bAlphaEnd || !g_CluiData.fSmoothAnimation) //stop animation;

+		{

+			KillTimer(hwnd,TM_SMOTHALPHATRANSITION);

+			mutex_bAnimationInProgress=0;

+			if (bAlphaEnd==0) 

+			{

+				g_CluiData.bCurrentAlpha=1;

+				ske_UpdateWindowImage();

+				mutex_bShowHideCalledFromAnimation=1;             

+				CLUI_ShowWindowMod(pcli->hwndContactList,0);

+				Sync(CLUIFrames_OnShowHide, pcli->hwndContactList,0);

+				mutex_bShowHideCalledFromAnimation=0;

+				g_CluiData.bCurrentAlpha=0;

+			}

+			else

+			{

+				g_CluiData.bCurrentAlpha=bAlphaEnd;

+				ske_UpdateWindowImage();

+			}

+		}

+		else

+		{

+			g_CluiData.bCurrentAlpha=a;

+			ske_UpdateWindowImage();

+		}

+	}

+

+	return 0;

+}

+

+BOOL CLUI__cliInvalidateRect(HWND hWnd, CONST RECT* lpRect,BOOL bErase )

+{

+	if (g_mutex_bSetAllExtraIconsCycle)

+		return FALSE;

+	if (CLUI_IsInMainWindow(hWnd) && g_CluiData.fLayered)// && IsWindowVisible(hWnd))

+	{

+		if (IsWindowVisible(hWnd))

+			return SkinInvalidateFrame( hWnd, lpRect );

+		else

+		{

+			g_flag_bFullRepaint=1;

+			return 0;

+		}

+	}

+	else 

+		return InvalidateRect(hWnd,lpRect,bErase);

+	return 1;

+}

+

+static BOOL FileExists(TCHAR * tszFilename)

+{

+	BOOL result=FALSE;

+	FILE * f=_tfopen(tszFilename,_T("r"));

+	if (f==NULL) return FALSE;

+	fclose(f);

+	return TRUE;

+}

+

+HANDLE RegisterIcolibIconHandle(char * szIcoID, char *szSectionName,  char * szDescription, TCHAR * tszDefaultFile, int iDefaultIndex, HINSTANCE hDefaultModuleInst, int iDefaultResource )

+{

+	TCHAR fileFull[MAX_PATH]={0};

+	SKINICONDESC sid={0};

+	HANDLE hIcolibItem=NULL;

+	sid.cbSize = sizeof(sid);

+	sid.cx = 16;

+	sid.cy = 16;

+	sid.pszSection = szSectionName;

+	sid.pszName = szIcoID;

+	sid.flags|=SIDF_PATH_TCHAR;

+	sid.pszDescription = szDescription;

+

+	if (tszDefaultFile)

+	{

+		CallService( MS_UTILS_PATHTOABSOLUTET, ( WPARAM )tszDefaultFile, ( LPARAM )fileFull );

+		if (!FileExists(fileFull)) fileFull[0]=_T('\0'); 

+	}

+	if (fileFull[0]!=_T('\0'))

+	{

+		sid.ptszDefaultFile = fileFull;

+		sid.iDefaultIndex = iDefaultIndex;

+		sid.hDefaultIcon = NULL;

+	}

+	else

+	{

+		sid.pszDefaultFile = NULL;

+		sid.iDefaultIndex = 0;

+		sid.hDefaultIcon = LoadSmallIcon( hDefaultModuleInst, MAKEINTRESOURCE(iDefaultResource) );

+	}

+	hIcolibItem = ( HANDLE )CallService(MS_SKIN2_ADDICON, 0, (LPARAM)&sid);

+	if ( sid.hDefaultIcon )	DestroyIcon(sid.hDefaultIcon);

+	return hIcolibItem; 

+}

+

+// MAIN WINPROC MESSAGE HANDLERS

+LRESULT CLUI::PreProcessWndProc( UINT msg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )

+{

+	// proxy CLUI Messages

+	LRESULT result = 0;

+	if ( ProcessCLUIFrameInternalMsg( m_hWnd, msg, wParam, lParam, result ) )

+	{

+		bHandled = TRUE;

+		return result;

+	}

+

+	/*

+	This registers a window message with RegisterWindowMessage() and then waits for such a message,

+	if it gets it, it tries to open a file mapping object and then maps it to this process space,

+	it expects 256 bytes of data (incl. NULL) it will then write back the profile it is using the DB to fill in the answer.

+

+	The caller is expected to create this mapping object and tell us the ID we need to open ours.	

+	*/

+	if (g_CluiData.bSTATE==STATE_EXITING && msg!=WM_DESTROY)

+	{

+		bHandled = TRUE;

+		return 0;

+	}

+	if (msg == uMsgGetProfile && wParam != 0) /* got IPC message */

+	{ 

+		HANDLE hMap;

+		char szName[MAX_PATH];

+		int rc = 0;

+		mir_snprintf( szName, SIZEOF(szName), "Miranda::%u", wParam ); // caller will tell us the ID of the map

+		hMap = OpenFileMappingA( FILE_MAP_ALL_ACCESS,FALSE, szName );

+		if ( hMap != NULL ) 

+		{

+			void *hView = NULL;

+			hView  =MapViewOfFile( hMap, FILE_MAP_ALL_ACCESS, 0, 0, MAX_PATH );

+			if (hView) 

+			{

+				char szFilePath[MAX_PATH], szProfile[MAX_PATH];

+				CallService( MS_DB_GETPROFILEPATH,MAX_PATH,(LPARAM)&szFilePath );

+				CallService( MS_DB_GETPROFILENAME,MAX_PATH,(LPARAM)&szProfile );

+				_snprintf( (char*)hView, MAX_PATH, "%s\\%s", szFilePath, szProfile );

+				UnmapViewOfFile( hView );

+				rc = 1;

+			}

+			CloseHandle( hMap );

+		}

+		bHandled = TRUE;

+		return rc;

+	}

+	return FALSE;

+}

+

+

+LRESULT CLUI::OnSizingMoving( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if (g_CluiData.fLayered)

+	{

+		if (msg==WM_SIZING)

+		{

+			static int a=0;

+			RECT* wp=(RECT*)lParam;

+			if (bNeedFixSizingRect && (rcCorrectSizeRect.bottom!=0||rcCorrectSizeRect.top!=0))

+			{

+				if(wParam!=WMSZ_BOTTOM) wp->bottom=rcCorrectSizeRect.bottom;

+				if(wParam!=WMSZ_TOP) wp->top=rcCorrectSizeRect.top;       

+			}

+			bNeedFixSizingRect=0;

+			rcSizingRect=*wp;

+			mutex_bDuringSizing=1;

+			return 1;

+		}

+

+		if (msg==WM_WINDOWPOSCHANGING)

+		{

+

+

+			WINDOWPOS * wp;

+			HDWP PosBatch;

+			RECT work_rect={0};

+			RECT temp_rect={0};

+			wp=(WINDOWPOS *)lParam;

+			GetWindowRect(m_hWnd,&rcOldWindowRect);

+

+			// Прилипание к краям by ZorG	

+			CLUI::SnappingToEdge(wp);

+

+			if ((rcOldWindowRect.bottom-rcOldWindowRect.top!=wp->cy || rcOldWindowRect.right-rcOldWindowRect.left !=wp->cx)&&!(wp->flags&SWP_NOSIZE))

+			{

+				{         

+					if (!(wp->flags&SWP_NOMOVE)) 

+					{

+						rcNewWindowRect.left=wp->x;

+						rcNewWindowRect.top=wp->y;

+					}

+					else

+					{

+						rcNewWindowRect.left=rcOldWindowRect.left;

+						rcNewWindowRect.top=rcOldWindowRect.top;

+					}

+					rcNewWindowRect.right=rcNewWindowRect.left+wp->cx;  

+					rcNewWindowRect.bottom=rcNewWindowRect.top+wp->cy;

+					work_rect=rcNewWindowRect;

+				}

+				//resize frames (batch)

+				{

+					PosBatch=BeginDeferWindowPos(1);

+					SizeFramesByWindowRect(&work_rect,&PosBatch,0);

+				}

+				//Check rect after frames resize

+				{

+					GetWindowRect(m_hWnd,&temp_rect);

+				}

+				//Here work_rect should be changed to fit possible changes in cln_listsizechange

+				if(bNeedFixSizingRect)

+				{

+					work_rect=rcSizingRect;

+					wp->x=work_rect.left;

+					wp->y=work_rect.top;

+					wp->cx=work_rect.right-work_rect.left;

+					wp->cy=work_rect.bottom-work_rect.top;

+					wp->flags&=~(SWP_NOMOVE);

+				}

+				//reposition buttons and new size applying

+				{

+					ModernSkinButton_ReposButtons( m_hWnd, SBRF_DO_NOT_DRAW, &work_rect );

+					ske_PrepeareImageButDontUpdateIt(&work_rect);

+					g_CluiData.mutexPreventDockMoving=0;			

+					ske_UpdateWindowImageRect(&work_rect);        

+					EndDeferWindowPos(PosBatch);

+					g_CluiData.mutexPreventDockMoving=1;

+				}       

+				Sleep(0);               

+				mutex_bDuringSizing=0; 

+				DefWindowProc(m_hWnd,msg,wParam,lParam);

+				return SendMessage(m_hWnd,WM_WINDOWPOSCHANGED,wParam,lParam);

+			}

+			else

+			{

+				SetRect(&rcCorrectSizeRect,0,0,0,0);

+				// bNeedFixSizingRect=0;

+			}

+			return DefWindowProc(m_hWnd,msg,wParam,lParam); 

+		}	

+	}

+

+	else if (msg==WM_WINDOWPOSCHANGING)

+	{

+		// Snaping if it is not in LayeredMode	

+		WINDOWPOS * wp;

+		wp=(WINDOWPOS *)lParam;

+		CLUI::SnappingToEdge( wp );

+		return DefWindowProc(m_hWnd,msg,wParam,lParam); 

+	}

+	switch (msg)

+	{

+	case WM_DISPLAYCHANGE:

+		SendMessage(pcli->hwndContactTree, WM_SIZE, 0, 0);

+		return TRUE;

+

+	case WM_EXITSIZEMOVE:

+		{

+			int res=DefWindowProc(m_hWnd, msg, wParam, lParam);

+			ReleaseCapture();

+			TRACE("WM_EXITSIZEMOVE\n");

+			SendMessage(m_hWnd, WM_ACTIVATE, (WPARAM)WA_ACTIVE, (LPARAM)m_hWnd);

+			return res;

+		}

+

+	case WM_SIZING:

+		return DefWindowProc(m_hWnd, msg, wParam, lParam);;

+	case WM_MOVE:

+		{

+			RECT rc;

+			CallWindowProc(DefWindowProc, m_hWnd, msg, wParam, lParam);

+			mutex_bDuringSizing=0;      

+			GetWindowRect(m_hWnd, &rc);

+			CheckFramesPos(&rc);

+			Sync(CLUIFrames_OnMoving,m_hWnd,&rc);

+			if (!IsIconic(m_hWnd)) {

+				if (!CallService(MS_CLIST_DOCKINGISDOCKED,0,0))

+				{ //if g_CluiData.fDocked, dont remember pos (except for width)

+					ModernWriteSettingDword(NULL,"CList","Height",(DWORD)(rc.bottom - rc.top));

+					ModernWriteSettingDword(NULL,"CList","x",(DWORD)rc.left);

+					ModernWriteSettingDword(NULL,"CList","y",(DWORD)rc.top);

+				}

+				ModernWriteSettingDword(NULL,"CList","Width",(DWORD)(rc.right - rc.left));

+			}

+			return TRUE;

+		}

+	case WM_SIZE:    

+		{   

+			RECT rc;

+			if (g_mutex_bSizing) return 0;

+			if(wParam!=SIZE_MINIMIZED /*&& IsWindowVisible(m_hWnd)*/) 

+			{

+				if ( pcli->hwndContactList == NULL )

+					return 0;

+

+				if (!g_CluiData.fLayered && !g_CluiData.fDisableSkinEngine)

+					ske_ReCreateBackImage(TRUE,NULL);

+

+				GetWindowRect(m_hWnd, &rc);

+				CheckFramesPos(&rc);

+				ModernSkinButton_ReposButtons( m_hWnd, SBRF_DO_NOT_DRAW, &rc);

+				ModernSkinButton_ReposButtons( m_hWnd, SBRF_REDRAW, NULL);

+				if (g_CluiData.fLayered)

+					CallService(MS_SKINENG_UPTATEFRAMEIMAGE,(WPARAM)m_hWnd,0);

+

+				if (!g_CluiData.fLayered)

+				{

+					g_mutex_bSizing=1;

+					Sync(CLUIFrames_OnClistResize_mod,(WPARAM)m_hWnd,(LPARAM)1);

+					CLUIFrames_ApplyNewSizes(2);

+					CLUIFrames_ApplyNewSizes(1);

+					SendMessage(m_hWnd,CLN_LISTSIZECHANGE,0,0);				  

+					g_mutex_bSizing=0;

+				}

+

+				//       ske_RedrawCompleteWindow();

+				if (!CallService(MS_CLIST_DOCKINGISDOCKED,0,0))

+				{ //if g_CluiData.fDocked, dont remember pos (except for width)

+					ModernWriteSettingDword(NULL,"CList","Height",(DWORD)(rc.bottom - rc.top));

+					ModernWriteSettingDword(NULL,"CList","x",(DWORD)rc.left);

+					ModernWriteSettingDword(NULL,"CList","y",(DWORD)rc.top);

+				}

+				else SetWindowRgn(m_hWnd,NULL,0);

+				ModernWriteSettingDword(NULL,"CList","Width",(DWORD)(rc.right - rc.left));	                               

+

+				if (!g_CluiData.fLayered)

+				{

+					HRGN hRgn1;

+					RECT r;

+					int v,h;

+					int w=10;

+					GetWindowRect(m_hWnd,&r);

+					h=(r.right-r.left)>(w*2)?w:(r.right-r.left);

+					v=(r.bottom-r.top)>(w*2)?w:(r.bottom-r.top);

+					h=(h<v)?h:v;

+					hRgn1=CreateRoundRectRgn(0,0,(r.right-r.left+1),(r.bottom-r.top+1),h,h);

+					if ((ModernGetSettingByte(NULL,"CLC","RoundCorners",SETTING_ROUNDCORNERS_DEFAULT)) && (!CallService(MS_CLIST_DOCKINGISDOCKED,0,0)))

+						SetWindowRgn(m_hWnd,hRgn1,FALSE); 

+					else

+					{

+						DeleteObject(hRgn1);

+						SetWindowRgn(m_hWnd,NULL,FALSE);

+					}

+					RedrawWindow(m_hWnd,NULL,NULL,RDW_INVALIDATE|RDW_ERASE|RDW_FRAME|RDW_UPDATENOW|RDW_ALLCHILDREN);   

+				} 			

+			}

+			else {

+				if(ModernGetSettingByte(NULL,"CList","Min2Tray",SETTING_MIN2TRAY_DEFAULT)) {

+					CLUI_ShowWindowMod(m_hWnd, SW_HIDE);

+					ModernWriteSettingByte(NULL,"CList","State",SETTING_STATE_HIDDEN);

+				}

+				else ModernWriteSettingByte(NULL,"CList","State",SETTING_STATE_MINIMIZED);

+				if (MySetProcessWorkingSetSize != NULL) 

+					MySetProcessWorkingSetSize(GetCurrentProcess(),-1,-1);

+			}

+

+			return TRUE;

+		}

+	case WM_WINDOWPOSCHANGING:

+		{

+			WINDOWPOS * wp;

+			wp=(WINDOWPOS *)lParam; 

+			if (wp->flags&SWP_HIDEWINDOW && mutex_bAnimationInProgress) 

+				return 0;               

+			if (g_CluiData.fOnDesktop)

+				wp->flags|=SWP_NOACTIVATE|SWP_NOZORDER;

+			return DefWindowProc(m_hWnd, msg, wParam, lParam);

+		}

+	}

+	return 0;

+}

+

+LRESULT CLUI::OnThemeChanged( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	xpt_OnWM_THEMECHANGED();

+	return FALSE;

+}

+

+LRESULT CLUI::OnDwmCompositionChanged( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	g_CluiData.fAeroGlass = false;

+	CLUI_UpdateAeroGlass();

+	return FALSE;

+}

+

+LRESULT CLUI::OnSyncCall( UINT /*msg*/, WPARAM wParam, LPARAM /*lParam*/ )

+{

+	return SyncOnWndProcCall( wParam );

+}

+

+LRESULT CLUI::OnUpdate( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	if ( g_flag_bPostWasCanceled ) return FALSE;

+	return ske_ValidateFrameImageProc( NULL );

+}

+LRESULT CLUI::OnInitMenu( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	if ( !CLUI::IsMainMenuInited() )

+	{

+		if ( ServiceExists( MS_CLIST_MENUBUILDMAIN ) ) CallService( MS_CLIST_MENUBUILDMAIN, 0, 0 );

+		CLUI::m_fMainMenuInited = TRUE;

+	}

+	return FALSE;

+}

+LRESULT CLUI::OnNcPaint( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	int lRes = DefWindowProc( m_hWnd, msg, wParam, lParam );

+	if ( !g_CluiData.fLayered && ModernGetSettingByte( NULL,"CLUI","ShowMainMenu",SETTING_SHOWMAINMENU_DEFAULT ) )

+	{

+		HDC hdc = NULL;

+		if ( msg == WM_PRINT ) hdc=(HDC)wParam;

+		if ( !hdc ) hdc = GetWindowDC( m_hWnd );

+		CLUI_DrawMenuBackGround( m_hWnd, hdc, 0, 0 );

+		if ( msg != WM_PRINT ) ReleaseDC( m_hWnd, hdc );

+	}

+	return lRes;

+}

+LRESULT CLUI::OnEraseBkgnd( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	return TRUE;

+}

+LRESULT CLUI::OnNcCreate( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	( (LPCREATESTRUCT)lParam )->style &= ~(CS_HREDRAW | CS_VREDRAW);

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnPaint( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if (!g_CluiData.fLayered && IsWindowVisible(m_hWnd))

+	{

+		RECT w={0};

+		RECT w2={0};

+		PAINTSTRUCT ps={0};

+		HDC hdc;

+		HBITMAP hbmp,oldbmp;

+		HDC paintDC;

+

+		GetClientRect(m_hWnd,&w);

+		if (!(w.right>0 && w.bottom>0)) return DefWindowProc(m_hWnd, msg, wParam, lParam); 

+

+		if (!g_CluiData.fDisableSkinEngine)

+		{ 

+			paintDC = GetDC(m_hWnd);

+			w2=w;

+			hdc=CreateCompatibleDC(paintDC);

+			hbmp=ske_CreateDIB32(w.right,w.bottom);

+			oldbmp=(HBITMAP)SelectObject(hdc,hbmp);

+			ske_ReCreateBackImage(FALSE,NULL);

+			BitBlt(paintDC,w2.left,w2.top,w2.right-w2.left,w2.bottom-w2.top,g_pCachedWindow->hBackDC,w2.left,w2.top,SRCCOPY);

+			SelectObject(hdc,oldbmp);

+			DeleteObject(hbmp);

+			mod_DeleteDC(hdc);

+			ReleaseDC(m_hWnd,paintDC);

+		}

+		else

+		{

+			HDC hdc=BeginPaint(m_hWnd,&ps);

+			ske_BltBackImage(m_hWnd,hdc,&ps.rcPaint);

+			ps.fErase=FALSE;

+			EndPaint(m_hWnd,&ps); 

+		}

+

+		ValidateRect(m_hWnd,NULL);

+

+	}

+	if (0&&(ModernGetSettingDword(NULL,"CLUIFrames","GapBetweenFrames",SETTING_GAPFRAMES_DEFAULT) || ModernGetSettingDword(NULL,"CLUIFrames","GapBetweenTitleBar",SETTING_GAPTITLEBAR_DEFAULT)))

+	{

+		if (IsWindowVisible(m_hWnd))

+			if (g_CluiData.fLayered)

+				SkinInvalidateFrame(m_hWnd,NULL);

+			else 

+			{

+				RECT w={0};

+				RECT w2={0};

+				PAINTSTRUCT ps={0};

+				GetWindowRect(m_hWnd,&w);

+				OffsetRect(&w,-w.left,-w.top);

+				BeginPaint(m_hWnd,&ps);

+				if ((ps.rcPaint.bottom-ps.rcPaint.top)*(ps.rcPaint.right-ps.rcPaint.left)==0)

+					w2=w;

+				else

+					w2=ps.rcPaint;

+				SkinDrawGlyph(ps.hdc,&w,&w2,"Main,ID=Background,Opt=Non-Layered");

+				ps.fErase=FALSE;

+				EndPaint(m_hWnd,&ps); 

+			}

+	}

+	return DefWindowProc(m_hWnd, msg, wParam, lParam);

+}

+

+LRESULT CLUI::OnCreate( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	CallService(MS_LANGPACK_TRANSLATEMENU,(WPARAM)GetMenu(m_hWnd),0);

+	DrawMenuBar(m_hWnd);       

+	CLUIServices_ProtocolStatusChanged(0,0);

+

+	{	MENUITEMINFO mii;

+	ZeroMemory(&mii,sizeof(mii));

+	mii.cbSize=MENUITEMINFO_V4_SIZE;

+	mii.fMask=MIIM_TYPE|MIIM_DATA;

+	mii.dwItemData=MENU_MIRANDAMENU;

+	mii.fType=MFT_OWNERDRAW;

+	mii.dwTypeData=NULL;

+	SetMenuItemInfo(GetMenu(m_hWnd),0,TRUE,&mii);

+

+	// mii.fMask=MIIM_TYPE;

+	mii.fType=MFT_OWNERDRAW;

+	mii.dwItemData=MENU_STATUSMENU;

+	SetMenuItemInfo(GetMenu(m_hWnd),1,TRUE,&mii);

+

+	// mii.fMask=MIIM_TYPE;

+	mii.fType=MFT_OWNERDRAW;

+	mii.dwItemData=MENU_MINIMIZE;

+	SetMenuItemInfo(GetMenu(m_hWnd),2,TRUE,&mii);		

+	}

+	//PostMessage(m_hWnd, M_CREATECLC, 0, 0);

+	//pcli->hwndContactList=m_hWnd;

+	uMsgGetProfile=RegisterWindowMessage(TEXT("Miranda::GetProfile")); // don't localise

+	bTransparentFocus=1;

+	return FALSE;

+}

+LRESULT CLUI::OnSetAllExtraIcons( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	return FALSE;

+}

+LRESULT CLUI::OnCreateClc( UINT /*msg*/, WPARAM /*wParam*/, LPARAM /*lParam*/ )

+{

+	CreateCLC();

+	if ( ModernGetSettingByte( NULL, "CList", "ShowOnStart", SETTING_SHOWONSTART_DEFAULT ) ) 

+		cliShowHide( (WPARAM) m_hWnd, (LPARAM)TRUE );

+	PostMessage( pcli->hwndContactTree, CLM_AUTOREBUILD, 0, 0 );

+

+	return FALSE;

+}

+LRESULT CLUI::OnLButtonDown( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	POINT pt;

+	pt.x = (short)LOWORD(lParam);

+	pt.y = (short)HIWORD(lParam);

+	ClientToScreen( m_hWnd, &pt );

+

+	if ( CLUI_SizingOnBorder( pt, 1 ) )

+	{

+		mutex_bIgnoreActivation = TRUE;

+		return FALSE;

+	}

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+LRESULT CLUI::OnParentNotify( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	switch ( wParam )

+	{

+	case WM_LBUTTONDOWN:

+		{

+			POINT pt;

+

+			pt.x = (short)LOWORD(lParam); 

+			pt.y = (short)HIWORD(lParam); 

+			ClientToScreen( m_hWnd, &pt );

+			wParam = 0;

+			lParam = 0;

+

+			if ( CLUI_SizingOnBorder( pt,1 ) ) 

+			{

+				mutex_bIgnoreActivation = TRUE;

+				return 0;

+			}

+		}

+	}

+	return DefWindowProc(m_hWnd, msg, wParam, lParam);;

+}

+

+LRESULT CLUI::OnSetFocus( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if ( hFrameContactTree && ( !CallService( MS_CLIST_FRAMES_GETFRAMEOPTIONS, MAKEWPARAM( FO_FLOATING, hFrameContactTree ), 0 ) ) )

+	{

+		SetFocus(pcli->hwndContactTree);

+	}

+

+	return FALSE;

+}

+

+LRESULT CLUI::OnStatusBarUpdateTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	int status,i;

+	PROTOTICKS *pt=NULL;

+

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

+	{

+

+		pt=&CycleStartTick[i];

+

+		if (pt->szProto!=NULL&&pt->bTimerCreated==1)

+		{

+			if (pt->bGlobal)

+				status=g_bMultiConnectionMode?ID_STATUS_CONNECTING:0;

+			else

+				status=CallProtoService(pt->szProto,PS_GETSTATUS,0,0);

+

+			if (!(status>=ID_STATUS_CONNECTING&&status<=ID_STATUS_CONNECTING+MAX_CONNECT_RETRIES))

+			{													

+				pt->nCycleStartTick=0;

+				ImageList_Destroy(pt->himlIconList);

+				pt->himlIconList=NULL;

+				KillTimer(m_hWnd,TM_STATUSBARUPDATE+pt->nIndex);

+				pt->bTimerCreated=0;

+			}

+		}

+

+	};

+

+	pt=&CycleStartTick[wParam-TM_STATUSBARUPDATE];

+	{

+		if(IsWindowVisible(pcli->hwndStatus)) pcli->pfnInvalidateRect(pcli->hwndStatus,NULL,0);//InvalidateRectZ(pcli->hwndStatus,NULL,TRUE);

+		//if (DBGetContactSettingByte(NULL,"CList","TrayIcon",SETTING_TRAYICON_DEFAULT)!=SETTING_TRAYICON_CYCLE) 

+		if (pt->bGlobal) 

+			cliTrayIconUpdateBase(g_szConnectingProto);

+		else

+			cliTrayIconUpdateBase(pt->szProto);

+

+	}

+	pcli->pfnInvalidateRect(pcli->hwndStatus,NULL,TRUE);

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnAutoAlphaTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	int inwnd;

+

+	if (GetForegroundWindow()==m_hWnd)

+	{

+		KillTimer(m_hWnd,TM_AUTOALPHA);

+		inwnd=1;

+	}

+	else 

+	{

+		POINT pt;

+		HWND hwndPt;

+		pt.x=(short)LOWORD(GetMessagePos());

+		pt.y=(short)HIWORD(GetMessagePos());

+		hwndPt=WindowFromPoint(pt);

+

+		inwnd=FALSE;

+		inwnd = CLUI_CheckOwnedByClui(hwndPt);

+		if (! inwnd )

+			inwnd = ( GetCapture()==pcli->hwndContactList );

+

+	}

+	if (inwnd!=bTransparentFocus)

+	{ //change

+		HWND hwn=GetCapture();

+		hwn=hwn;

+		bTransparentFocus=inwnd;

+		if(bTransparentFocus) CLUI_SmoothAlphaTransition(m_hWnd, (BYTE)ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), 1);

+		else  

+		{

+			CLUI_SmoothAlphaTransition(m_hWnd, (BYTE)(g_bTransparentFlag?ModernGetSettingByte(NULL,"CList","AutoAlpha",SETTING_AUTOALPHA_DEFAULT):255), 1);

+		}

+	}

+	if (!bTransparentFocus) KillTimer(m_hWnd,TM_AUTOALPHA);

+	return TRUE;

+}

+LRESULT CLUI::OnSmoothAlphaTransitionTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	CLUI_SmoothAlphaTransition(m_hWnd, 0, 2);

+	return TRUE;

+}

+LRESULT CLUI::OnDelayedSizingTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if ( mutex_bDelayedSizing && !mutex_bDuringSizing )

+	{

+		mutex_bDelayedSizing = 0;

+		KillTimer( m_hWnd,TM_DELAYEDSIZING );

+		pcli->pfnClcBroadcast( INTM_SCROLLBARCHANGED, 0, 0 );

+	}

+	return TRUE;

+}

+LRESULT CLUI::OnBringOutTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	//hide

+	KillTimer(m_hWnd,TM_BRINGINTIMEOUT);

+	KillTimer(m_hWnd,TM_BRINGOUTTIMEOUT);

+	bShowEventStarted=0;

+	POINT pt; GetCursorPos(&pt);

+	HWND hAux = WindowFromPoint(pt);

+	BOOL mouse_in_window = CLUI_CheckOwnedByClui(hAux);

+	if ( !mouse_in_window && GetForegroundWindow() != m_hWnd ) 

+		CLUI_HideBehindEdge(); 

+	return TRUE;

+}

+LRESULT CLUI::OnBringInTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	//show	

+	KillTimer(m_hWnd,TM_BRINGINTIMEOUT);

+	bShowEventStarted=0;

+	KillTimer(m_hWnd,TM_BRINGOUTTIMEOUT);

+	POINT pt; GetCursorPos(&pt);

+	HWND hAux = WindowFromPoint(pt);

+	BOOL mouse_in_window = FALSE;

+	while(hAux != NULL) 

+	{

+		if (hAux == m_hWnd) { mouse_in_window = TRUE; break;}

+		hAux = GetParent(hAux);

+	}

+	if ( mouse_in_window )

+		CLUI_ShowFromBehindEdge();

+	return TRUE;

+}

+LRESULT CLUI::OnUpdateBringTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	CLUI_UpdateTimer( 0 );

+	return TRUE;

+}

+

+LRESULT CLUI::OnTimer( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if ( MirandaExiting() ) return FALSE;

+

+	if ( (int)wParam >= TM_STATUSBARUPDATE && (int)wParam<=TM_STATUSBARUPDATE+64 )

+	{

+		if ( !pcli->hwndStatus ) return FALSE;

+		else return OnStatusBarUpdateTimer( msg, wParam, lParam );

+	}

+

+	switch ( wParam )

+	{

+	case TM_AUTOALPHA:				return OnAutoAlphaTimer( msg, wParam, lParam );

+	case TM_SMOTHALPHATRANSITION:	return OnSmoothAlphaTransitionTimer( msg, wParam, lParam );

+	case TM_DELAYEDSIZING:			return OnDelayedSizingTimer( msg, wParam, lParam );

+	case TM_BRINGOUTTIMEOUT:		return OnBringOutTimer( msg, wParam, lParam );

+	case TM_BRINGINTIMEOUT:			return OnBringInTimer( msg, wParam, lParam );

+	case TM_UPDATEBRINGTIMER:		return OnUpdateBringTimer( msg, wParam, lParam );

+	default:						return DefCluiWndProc( msg, wParam, lParam );

+	}

+	return TRUE;

+}

+

+

+LRESULT CLUI::OnActivate( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	BOOL IsOption=FALSE;

+	SetCursor(LoadCursor(NULL, IDC_ARROW));

+	SendMessage(pcli->hwndContactTree, WM_ACTIVATE, wParam, lParam);

+	if (ModernGetSettingByte(NULL, "ModernData", "HideBehind", SETTING_HIDEBEHIND_DEFAULT))

+	{

+		if(wParam==WA_INACTIVE && ((HWND)lParam!=m_hWnd) && GetParent((HWND)lParam)!=m_hWnd && !IsOption) 

+		{

+			if (!g_bCalledFromShowHide) CLUI_UpdateTimer(0);

+		}

+		else if (!g_bCalledFromShowHide )

+		{

+			CLUI_ShowFromBehindEdge();

+		}

+	}

+

+	if (!IsWindowVisible(m_hWnd) || mutex_bShowHideCalledFromAnimation) 

+	{

+		KillTimer(m_hWnd,TM_AUTOALPHA);

+		return 0;

+	}

+	if(wParam==WA_INACTIVE && ((HWND)lParam!=m_hWnd) && !CLUI_CheckOwnedByClui((HWND)lParam) && !IsOption) 

+	{

+		if(g_bTransparentFlag)

+			if(bTransparentFocus)

+				CLUI_SafeSetTimer(m_hWnd, TM_AUTOALPHA,250,NULL);

+

+	}

+	else {

+		if (!ModernGetSettingByte(NULL,"CList","OnTop",SETTING_ONTOP_DEFAULT))

+			Sync(CLUIFrames_ActivateSubContainers,TRUE);

+		if(g_bTransparentFlag) {

+			KillTimer(m_hWnd,TM_AUTOALPHA);

+			CLUI_SmoothAlphaTransition(m_hWnd, ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), 1);

+			bTransparentFocus=1;

+		}

+	}

+	RedrawWindow(m_hWnd,NULL,NULL,RDW_INVALIDATE|RDW_ALLCHILDREN);

+	if(g_bTransparentFlag)

+	{

+		BYTE alpha;

+		if (wParam!=WA_INACTIVE || CLUI_CheckOwnedByClui((HWND)lParam)|| IsOption || ((HWND)lParam==m_hWnd) || GetParent((HWND)lParam)==m_hWnd) alpha=ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT);

+		else 

+			alpha=g_bTransparentFlag?ModernGetSettingByte(NULL,"CList","AutoAlpha",SETTING_AUTOALPHA_DEFAULT):255;

+		CLUI_SmoothAlphaTransition(m_hWnd, alpha, 1);

+		if(IsOption) DefWindowProc(m_hWnd,msg,wParam,lParam);

+		else   return 1; 	

+	}

+	return  DefWindowProc(m_hWnd,msg,wParam,lParam);

+}

+

+LRESULT CLUI::OnSetCursor( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	HWND gf=GetForegroundWindow();

+	if (g_CluiData.nBehindEdgeState>=0)  CLUI_UpdateTimer(1);

+	if(g_bTransparentFlag) {

+		if (!bTransparentFocus && gf!=m_hWnd)

+		{

+			CLUI_SmoothAlphaTransition(m_hWnd, ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT), 1);

+			bTransparentFocus=1;

+			CLUI_SafeSetTimer(m_hWnd, TM_AUTOALPHA,250,NULL);

+		}

+	} 

+	int k = CLUI_TestCursorOnBorders();               

+	return k ? k : 1;

+}

+

+LRESULT CLUI::OnMouseActivate( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+

+	if ( mutex_bIgnoreActivation ) 

+	{

+		mutex_bIgnoreActivation = 0;

+		return( MA_NOACTIVATEANDEAT );

+	}

+	int lRes=DefWindowProc(m_hWnd,msg,wParam,lParam);

+	CLUIFrames_RepaintSubContainers();

+	return lRes;

+}

+

+LRESULT CLUI::OnNcLButtonDown( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	POINT pt;

+	pt.x = (short)LOWORD(lParam); 

+	pt.y = (short)HIWORD(lParam); 

+	int k = CLUI_SizingOnBorder(pt,1);

+	return k ? k : DefWindowProc( m_hWnd, msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnNcLButtonDblClk( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if (wParam == HTMENU || wParam == HTCAPTION)

+	{

+		RECT rc;

+		GetWindowRect(m_hWnd, &rc);

+		POINT pt;

+		pt.x = (short)LOWORD(lParam); 

+		pt.y = (short)HIWORD(lParam); 

+		if ( pt.x > rc.right - 16 && pt.x < rc.right )

+			return CallService(MS_CLIST_SHOWHIDE, 0, 0);

+	}

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnNcHitTest( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	LRESULT result;

+	result=DefWindowProc(m_hWnd,WM_NCHITTEST,wParam,lParam);

+

+	if ( (g_CluiData.fAutoSize) && ( result == HTSIZE || result == HTTOP || 

+		result == HTTOPLEFT || result == HTTOPRIGHT ||

+		result==HTBOTTOM || result==HTBOTTOMRIGHT || 

+		result==HTBOTTOMLEFT) )

+		return HTCLIENT;

+

+	if (result==HTMENU) 

+	{

+		int t;

+		POINT pt;

+		pt.x=(short)LOWORD(lParam);

+		pt.y=(short)HIWORD(lParam);

+		t=MenuItemFromPoint(m_hWnd,g_hMenuMain,pt);

+

+		if (t==-1 && (ModernGetSettingByte(NULL,"CLUI","ClientAreaDrag",SETTING_CLIENTDRAG_DEFAULT)))

+			return HTCAPTION;

+	}

+

+	if (result==HTCLIENT)

+	{

+		POINT pt;

+		int k;

+		pt.x=(short)LOWORD(lParam);

+		pt.y=(short)HIWORD(lParam);			

+		k=CLUI_SizingOnBorder(pt,0);

+		if (!k && (ModernGetSettingByte(NULL,"CLUI","ClientAreaDrag",SETTING_CLIENTDRAG_DEFAULT)))

+			return HTCAPTION;

+		else return k+9;

+	}

+	return result;

+}

+

+LRESULT CLUI::OnShowWindow( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	BYTE gAlpha;

+

+	if (lParam) return 0;

+	if (mutex_bShowHideCalledFromAnimation) return 1; 

+	{

+

+		if (!wParam) gAlpha=0;

+		else 

+			gAlpha=(ModernGetSettingByte(NULL,"CList","Transparent",SETTING_TRANSPARENT_DEFAULT)?ModernGetSettingByte(NULL,"CList","Alpha",SETTING_ALPHA_DEFAULT):255);

+		if (wParam) 

+		{

+			g_CluiData.bCurrentAlpha=0;

+			Sync(CLUIFrames_OnShowHide, pcli->hwndContactList,1);

+			ske_RedrawCompleteWindow();

+		}

+		CLUI_SmoothAlphaTransition(m_hWnd, gAlpha, 1);

+	}

+	return FALSE;

+}

+

+LRESULT CLUI::OnSysCommand( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+		switch (wParam)

+		{

+		case SC_MAXIMIZE:

+			return 0;

+

+		case SC_CLOSE:

+			PostMessage(m_hWnd, msg, SC_MINIMIZE, lParam);

+			return 0;

+		}

+

+	DefWindowProc(m_hWnd, msg, wParam, lParam);

+	if (ModernGetSettingByte(NULL,"CList","OnDesktop",SETTING_ONDESKTOP_DEFAULT))

+		Sync( CLUIFrames_ActivateSubContainers, TRUE );

+	return FALSE;

+}

+

+LRESULT CLUI::OnKeyDown( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	if (wParam==VK_F5)

+		SendMessage(pcli->hwndContactTree,CLM_AUTOREBUILD,0,0);

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnGetMinMaxInfo( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	DefWindowProc(m_hWnd,msg,wParam,lParam);

+	((LPMINMAXINFO)lParam)->ptMinTrackSize.x=max(ModernGetSettingWord(NULL,"CLUI","MinWidth",SETTING_MINWIDTH_DEFAULT),max(18,ModernGetSettingByte(NULL,"CLUI","LeftClientMargin",SETTING_LEFTCLIENTMARIGN_DEFAULT)+ModernGetSettingByte(NULL,"CLUI","RightClientMargin",SETTING_RIGHTCLIENTMARIGN_DEFAULT)+18));

+	if (nRequiredHeight==0)

+	{

+		((LPMINMAXINFO)lParam)->ptMinTrackSize.y=CLUIFramesGetMinHeight();

+	}

+	return FALSE;

+}

+

+LRESULT CLUI::OnMoving( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	CallWindowProc( DefWindowProc, m_hWnd, msg, wParam, lParam );

+	if ( FALSE )  //showcontents is turned on

+	{

+		Sync(CLUIFrames_OnMoving,m_hWnd,(RECT*)lParam);

+	}

+	return TRUE;

+}

+

+LRESULT CLUI::OnNewContactNotify( NMCLISTCONTROL * pnmc )

+{

+	ExtraImage_SetAllExtraIcons( pcli->hwndContactTree, pnmc->hItem );

+	return FALSE;

+}

+

+LRESULT CLUI::OnListRebuildNotify( NMCLISTCONTROL * pnmc )

+{

+	ExtraImage_SetAllExtraIcons( pcli->hwndContactTree, 0 );

+	return FALSE;

+}

+LRESULT CLUI::OnListSizeChangeNotify( NMCLISTCONTROL * pnmc )

+{

+

+	// TODO: Check and refactor possible problem of clist resized to full screen problem

+	static RECT rcWindow,rcTree,rcTree2,rcWorkArea,rcOld;

+	int maxHeight, minHeight,newHeight;

+	int winstyle;

+	if (mutex_bDisableAutoUpdate==1)

+		return FALSE;

+	if (mutex_bDuringSizing)

+		rcWindow=rcSizingRect;

+	else					

+		GetWindowRect(m_hWnd,&rcWindow);

+	if ( !g_CluiData.fAutoSize || pcli->hwndContactTree==0 || CallService(MS_CLIST_DOCKINGISDOCKED,0,0) )

+		return FALSE;

+

+	maxHeight=ModernGetSettingByte(NULL,"CLUI","MaxSizeHeight",SETTING_MAXSIZEHEIGHT_DEFAULT);

+	minHeight=ModernGetSettingByte(NULL,"CLUI","MinSizeHeight",SETTING_MINSIZEHEIGHT_DEFAULT);

+	rcOld=rcWindow;

+	GetWindowRect(pcli->hwndContactTree,&rcTree);

+

+	FRAMEWND* frm=FindFrameByItsHWND(pcli->hwndContactTree);

+	if (frm) 

+		rcTree2=frm->wndSize;

+	else

+		SetRect(&rcTree2,0,0,0,0);

+

+	winstyle=GetWindowLongPtr(pcli->hwndContactTree,GWL_STYLE);

+

+	SystemParametersInfo(SPI_GETWORKAREA,0,&rcWorkArea,FALSE);

+	if (MyMonitorFromWindow)

+	{

+ 		HMONITOR hMon = MyMonitorFromWindow(pcli->hwndContactTree, MONITOR_DEFAULTTONEAREST);

+		MONITORINFO mi;

+		mi.cbSize = sizeof(mi);

+		if (MyGetMonitorInfo(hMon, &mi))

+ 			rcWorkArea = mi.rcWork;

+	}

+

+

+	if (pnmc->pt.y>(rcWorkArea.bottom-rcWorkArea.top)) 

+	{

+		pnmc->pt.y=(rcWorkArea.bottom-rcWorkArea.top);

+

+	};

+	if ((pnmc->pt.y)==nLastRequiredHeight)

+	{

+	}

+	nLastRequiredHeight=pnmc->pt.y;

+	newHeight=max(CLUIFramesGetMinHeight(),max(pnmc->pt.y,3)+1+((winstyle&WS_BORDER)?2:0)+(rcWindow.bottom-rcWindow.top)-(rcTree.bottom-rcTree.top));

+	if(newHeight<(rcWorkArea.bottom-rcWorkArea.top)*minHeight/100)

+		newHeight=(rcWorkArea.bottom-rcWorkArea.top)*minHeight/100;

+

+	if(newHeight>(rcWorkArea.bottom-rcWorkArea.top)*maxHeight/100)

+		newHeight=(rcWorkArea.bottom-rcWorkArea.top)*maxHeight/100;

+

+	if (newHeight==(rcWindow.bottom-rcWindow.top)) return 0;

+

+	if(ModernGetSettingByte(NULL,"CLUI","AutoSizeUpward",SETTING_AUTOSIZEUPWARD_DEFAULT)) {

+		rcWindow.top=rcWindow.bottom-newHeight;

+		if(rcWindow.top<rcWorkArea.top) rcWindow.top=rcWorkArea.top;

+	}

+	else {

+		rcWindow.bottom=rcWindow.top+newHeight;

+		if(rcWindow.bottom>rcWorkArea.bottom) rcWindow.bottom=rcWorkArea.bottom;

+	}

+	if (nRequiredHeight==1)

+		return FALSE;

+	nRequiredHeight=1;

+	if (mutex_bDuringSizing)

+	{

+		bNeedFixSizingRect=1;           

+		rcSizingRect.top=rcWindow.top;

+		rcSizingRect.bottom=rcWindow.bottom;

+		rcCorrectSizeRect=rcSizingRect;						

+	}

+	else

+	{

+		bNeedFixSizingRect=0;

+	}

+	if (!mutex_bDuringSizing)

+		SetWindowPos(m_hWnd,0,rcWindow.left,rcWindow.top,rcWindow.right-rcWindow.left,rcWindow.bottom-rcWindow.top,SWP_NOZORDER|SWP_NOACTIVATE);

+	else

+	{

+		SetWindowPos(m_hWnd,0,rcWindow.left,rcWindow.top,rcWindow.right-rcWindow.left,rcWindow.bottom-rcWindow.top,SWP_NOZORDER|SWP_NOACTIVATE);

+	}

+	nRequiredHeight=0;

+

+	return FALSE;

+}

+

+LRESULT CLUI::OnClickNotify( NMCLISTCONTROL * pnmc )

+{

+	DWORD hitFlags;

+	HANDLE hItem = (HANDLE)SendMessage(pcli->hwndContactTree,CLM_HITTEST,(WPARAM)&hitFlags,MAKELPARAM(pnmc->pt.x,pnmc->pt.y));

+

+	if (hitFlags&CLCHT_ONITEMEXTRA)

+	{					

+		if (!IsHContactGroup(hItem)&&!IsHContactInfo(hItem))

+		{

+			pdisplayNameCacheEntry pdnce=(pdisplayNameCacheEntry)pcli->pfnGetCacheEntry(pnmc->hItem);

+			if (pdnce==NULL) return 0;

+

+			int extra = ExtraImage_ColumnNumToExtraID(pnmc->iColumn);

+			NotifyEventHooks(g_CluiData.hEventExtraClick, (WPARAM)pnmc->hItem, extra);

+

+			if (!ServiceExists("ExtraIcon/Register"))

+			{

+				int v,e,w;

+				v=ExtraImage_ExtraIDToColumnNum(EXTRA_ICON_PROTO);

+				e=ExtraImage_ExtraIDToColumnNum(EXTRA_ICON_EMAIL);

+				w=ExtraImage_ExtraIDToColumnNum(EXTRA_ICON_WEB);

+

+				if(pnmc->iColumn==v) {

+					CallService(MS_USERINFO_SHOWDIALOG,(WPARAM)pnmc->hItem,0);

+				};

+				if(pnmc->iColumn==e) 

+				{

+					char *email,buf[4096];

+					email= ModernGetStringA(pnmc->hItem,"UserInfo", "Mye-mail0");

+					if (!email)

+						email= ModernGetStringA(pnmc->hItem, pdnce->m_cache_cszProto, "e-mail");																						

+					if (email)

+					{

+						sprintf(buf,"mailto:%s",email);

+						mir_free_and_nill(email);

+						ShellExecuteA(m_hWnd,"open",buf,NULL,NULL,SW_SHOW);

+					}											

+				};	

+				if(pnmc->iColumn==w) {

+					char *homepage;

+					homepage= ModernGetStringA(pdnce->m_cache_hContact,"UserInfo", "Homepage");

+					if (!homepage)

+						homepage= ModernGetStringA(pdnce->m_cache_hContact,pdnce->m_cache_cszProto, "Homepage");

+					if (homepage!=NULL)

+					{

+						CallService(MS_UTILS_OPENURL, 1, (LPARAM)homepage);

+						mir_free_and_nill(homepage);

+					}

+				}

+			}

+		}

+	};	

+	if(hItem && !(hitFlags&CLCHT_NOWHERE))

+		return DefCluiWndProc( WM_NOTIFY, 0, (LPARAM)pnmc );

+	if ((hitFlags&(CLCHT_NOWHERE|CLCHT_INLEFTMARGIN|CLCHT_BELOWITEMS))==0) 

+		return DefCluiWndProc( WM_NOTIFY, 0, (LPARAM)pnmc );

+	if (ModernGetSettingByte(NULL,"CLUI","ClientAreaDrag",SETTING_CLIENTDRAG_DEFAULT)) {

+		POINT pt;

+		int res;

+		pt=pnmc->pt;

+		ClientToScreen(pcli->hwndContactTree,&pt);

+		res=PostMessage(m_hWnd, WM_SYSCOMMAND, SC_MOVE|HTCAPTION,MAKELPARAM(pt.x,pt.y));

+		return res;

+	}

+	/*===================*/

+	if (ModernGetSettingByte(NULL,"CLUI","DragToScroll",SETTING_DRAGTOSCROLL_DEFAULT) && !ModernGetSettingByte(NULL,"CLUI","ClientAreaDrag",SETTING_CLIENTDRAG_DEFAULT))

+		return ClcEnterDragToScroll(pcli->hwndContactTree,pnmc->pt.y);

+	/*===================*/

+	return 0;

+}	

+

+LRESULT CLUI::OnNotify( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	LPNMHDR pnmhdr = (LPNMHDR)lParam;

+	if ( pnmhdr->hwndFrom != pcli->hwndContactTree ) 

+		return DefCluiWndProc( msg, wParam, lParam );

+

+	switch ( pnmhdr->code) 

+	{

+	case CLN_NEWCONTACT:     return OnNewContactNotify( (NMCLISTCONTROL *)pnmhdr );

+	case CLN_LISTREBUILT:    return OnListRebuildNotify( (NMCLISTCONTROL *)pnmhdr );

+	case CLN_LISTSIZECHANGE: return OnListSizeChangeNotify( (NMCLISTCONTROL *)pnmhdr );

+	case NM_CLICK:           return OnClickNotify( (NMCLISTCONTROL *)pnmhdr );

+

+	} 

+	return DefCluiWndProc( msg, wParam, lParam );

+}

+

+LRESULT CLUI::OnContextMenu( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	RECT rc;

+	POINT pt;

+

+	pt.x=(short)LOWORD(lParam);

+	pt.y=(short)HIWORD(lParam);

+	// x/y might be -1 if it was generated by a kb click			

+	GetWindowRect(pcli->hwndContactTree,&rc);

+	if ( pt.x == -1 && pt.y == -1) {

+		// all this is done in screen-coords!

+		GetCursorPos(&pt);

+		// the mouse isnt near the window, so put it in the middle of the window

+		if (!PtInRect(&rc,pt)) {

+			pt.x = rc.left + (rc.right - rc.left) / 2;

+			pt.y = rc.top + (rc.bottom - rc.top) / 2; 

+		}

+	}

+	if(PtInRect( &rc ,pt ) )

+	{

+		HMENU hMenu;

+		hMenu=(HMENU)CallService(MS_CLIST_MENUBUILDGROUP,0,0);

+		TrackPopupMenu(hMenu,TPM_TOPALIGN|TPM_LEFTALIGN|TPM_LEFTBUTTON,pt.x,pt.y,0,m_hWnd,NULL);

+        DestroyTrayMenu(hMenu);

+	}

+	return FALSE;

+

+}

+LRESULT CLUI::OnMeasureItem( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	LPMEASUREITEMSTRUCT pmis = (LPMEASUREITEMSTRUCT)lParam;

+	switch ( pmis->itemData )

+	{

+	case MENU_MIRANDAMENU:

+		{

+			pmis->itemWidth = GetSystemMetrics( SM_CXSMICON ) * 4 / 3;

+			pmis->itemHeight = 0;

+		}

+		return TRUE;

+	case MENU_STATUSMENU:

+		{

+			HDC hdc;

+			SIZE textSize;

+			hdc=GetDC( m_hWnd );

+			GetTextExtentPoint32A( hdc, Translate("Status"), lstrlenA( Translate( "Status" ) ), &textSize );

+			pmis->itemWidth = textSize.cx;

+			pmis->itemHeight = 0;

+			ReleaseDC( m_hWnd, hdc );

+		}

+		return TRUE;

+	}

+	return CallService( MS_CLIST_MENUMEASUREITEM, wParam, lParam );

+}

+

+LRESULT CLUI::OnDrawItem( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	struct ClcData * dat=(struct ClcData*)GetWindowLongPtr(pcli->hwndContactTree,0);

+	LPDRAWITEMSTRUCT dis=(LPDRAWITEMSTRUCT)lParam;

+	if (!dat) return 0;

+

+	if (dis->CtlType==ODT_MENU) {

+		if (dis->itemData==MENU_MIRANDAMENU) {

+			if (!g_CluiData.fLayered)

+			{	

+				char buf[255];	

+				short offset = 1 + ( dis->itemState&ODS_SELECTED ? 1 : 0 ) 

+								 - ( dis->itemState&ODS_HOTLIGHT ? 1 : 0 );

+				

+				HICON hIcon=LoadSkinnedIcon(SKINICON_OTHER_MAINMENU);

+				

+				CLUI_DrawMenuBackGround(m_hWnd, dis->hDC, 1, dis->itemState);

+				mir_snprintf(buf,SIZEOF(buf),"Main,ID=MainMenu,Selected=%s,Hot=%s",(dis->itemState&ODS_SELECTED)?"True":"False",(dis->itemState&ODS_HOTLIGHT)?"True":"False");

+				SkinDrawGlyph(dis->hDC,&dis->rcItem,&dis->rcItem,buf);

+

+				int x = (dis->rcItem.right  + dis->rcItem.left - GetSystemMetrics(SM_CXSMICON)) / 2 + offset;

+				int y = (dis->rcItem.bottom + dis->rcItem.top  - GetSystemMetrics(SM_CYSMICON)) / 2 + offset;

+

+				DrawState( dis->hDC, NULL, NULL, (LPARAM)hIcon, 0, x, y , 0 , 0 , 

+					DST_ICON | ( dis->itemState & ODS_INACTIVE  && (((FALSE))) ? DSS_DISABLED : DSS_NORMAL ) );

+

+				CallService(MS_SKIN2_RELEASEICON, (WPARAM)hIcon, 0);

+				nMirMenuState=dis->itemState;

+			} else {

+				nMirMenuState=dis->itemState;

+				pcli->pfnInvalidateRect(m_hWnd,NULL,0);

+			}

+			return TRUE;

+		}

+		else if(dis->itemData==MENU_STATUSMENU) {

+			if (!g_CluiData.fLayered)

+			{

+				char buf[255]={0};

+				RECT rc=dis->rcItem;

+				short dx=1+(dis->itemState&ODS_SELECTED?1:0)-(dis->itemState&ODS_HOTLIGHT?1:0);

+				if (dx>1){

+					rc.left+=dx;

+					rc.top+=dx;

+				}else if (dx==0){

+					rc.right-=1;

+					rc.bottom-=1;

+				}

+				CLUI_DrawMenuBackGround(m_hWnd, dis->hDC, 2, dis->itemState);

+				SetBkMode(dis->hDC,TRANSPARENT);

+				mir_snprintf(buf,SIZEOF(buf),"Main,ID=StatusMenu,Selected=%s,Hot=%s",(dis->itemState&ODS_SELECTED)?"True":"False",(dis->itemState&ODS_HOTLIGHT)?"True":"False");

+				SkinDrawGlyph(dis->hDC,&dis->rcItem,&dis->rcItem,buf);

+				SetTextColor(dis->hDC, (dis->itemState&ODS_SELECTED/*|dis->itemState&ODS_HOTLIGHT*/)?dat->MenuTextHiColor:dat->MenuTextColor);

+				DrawText(dis->hDC,TranslateT("Status"), lstrlen(TranslateT("Status")),&rc, DT_CENTER|DT_VCENTER|DT_SINGLELINE);

+				nStatusMenuState=dis->itemState;

+			} else {

+				nStatusMenuState=dis->itemState;

+				pcli->pfnInvalidateRect(m_hWnd,NULL,0);

+			}

+			return TRUE;

+		} else if(dis->itemData==MENU_MINIMIZE && !g_CluiData.fLayered)

+		{

+			//TODO check if caption is visible

+			char buf[255]={0};	

+			short dx=1+(dis->itemState&ODS_SELECTED?1:0)-(dis->itemState&ODS_HOTLIGHT?1:0);

+			HICON hIcon = LoadSkinnedIcon(SKINICON_OTHER_MIRANDA);

+			CLUI_DrawMenuBackGround(m_hWnd, dis->hDC, 3, dis->itemState);

+			mir_snprintf(buf,SIZEOF(buf),"Main,ID=MainMenu,Selected=%s,Hot=%s",(dis->itemState&ODS_SELECTED)?"True":"False",(dis->itemState&ODS_HOTLIGHT)?"True":"False");

+			SkinDrawGlyph(dis->hDC,&dis->rcItem,&dis->rcItem,buf);

+			DrawState(dis->hDC,NULL,NULL,(LPARAM)hIcon,0,(dis->rcItem.right+dis->rcItem.left-GetSystemMetrics(SM_CXSMICON))/2+dx,(dis->rcItem.bottom+dis->rcItem.top-GetSystemMetrics(SM_CYSMICON))/2+dx,0,0,DST_ICON|(dis->itemState&ODS_INACTIVE&&FALSE?DSS_DISABLED:DSS_NORMAL));

+			CallService(MS_SKIN2_RELEASEICON, (WPARAM)hIcon, 0);

+			nMirMenuState=dis->itemState;

+		}

+

+		return CallService(MS_CLIST_MENUDRAWITEM,wParam,lParam);

+	}

+	return 0;

+}

+

+LRESULT CLUI::OnDestroy( UINT msg, WPARAM wParam, LPARAM lParam )

+{

+	int state=ModernGetSettingByte(NULL,"CList","State",SETTING_STATE_NORMAL);

+	BOOL wait = FALSE;

+

+	AniAva_UnloadModule();

+	TRACE("CLUI.c: WM_DESTROY\n");

+	g_CluiData.bSTATE=STATE_EXITING;

+	CLUI_DisconnectAll();

+	//fire the "Away Message" Event to wake the thread so it can die.

+	//fire the "Get Text Async" Event to wake the thread so it can die.

+	if (amWakeThread())

+		wait = TRUE;

+

+	if (gtaWakeThread())

+		wait = TRUE;

+

+	if (wait)

+	{

+		//need to give them a little time to exit.

+		Sleep(50);

+	}

+

+	TRACE("CLUI.c: WM_DESTROY - WaitThreadsCompletion \n");

+	while (CLUI_WaitThreadsCompletion(m_hWnd)); //stop all my threads                

+	TRACE("CLUI.c: WM_DESTROY - WaitThreadsCompletion DONE\n");

+	{

+		int i=0;

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

+			if(CycleStartTick[i].szProto) mir_free_and_nill(CycleStartTick[i].szProto);

+	}

+

+    if (state==SETTING_STATE_NORMAL){CLUI_ShowWindowMod(m_hWnd,SW_HIDE);};

+	UnLoadContactListModule();

+	if(hSettingChangedHook!=0)	ModernUnhookEvent(hSettingChangedHook);

+	ClcUnloadModule();

+

+    RemoveMenu(g_hMenuMain, 0, MF_BYPOSITION);

+    RemoveMenu(g_hMenuMain, 0, MF_BYPOSITION);

+    DestroyMenu(g_hMenuMain);

+

+	pcli->pfnTrayIconDestroy(m_hWnd);	

+	mutex_bAnimationInProgress=0;  		

+	CallService(MS_CLIST_FRAMES_REMOVEFRAME,(WPARAM)hFrameContactTree,(LPARAM)0);		

+	TRACE("CLUI.c: WM_DESTROY - hFrameContactTree removed\n");

+	pcli->hwndContactTree=NULL;

+	pcli->hwndStatus=NULL;

+	{

+		if(g_CluiData.fAutoSize && !g_CluiData.fDocked)

+		{

+			RECT r;

+			GetWindowRect(pcli->hwndContactList,&r);

+			if(ModernGetSettingByte(NULL,"CLUI","AutoSizeUpward",SETTING_AUTOSIZEUPWARD_DEFAULT))

+				r.top=r.bottom-CLUIFrames_GetTotalHeight();

+			else 

+				r.bottom=r.top+CLUIFrames_GetTotalHeight();

+			ModernWriteSettingDword(NULL,"CList","y",r.top);

+			ModernWriteSettingDword(NULL,"CList","Height",r.bottom-r.top);

+		}

+	}

+	UnLoadCLUIFramesModule();

+	//ExtFrames_Uninit();

+	TRACE("CLUI.c: WM_DESTROY - UnLoadCLUIFramesModule DONE\n");

+	ModernWriteSettingByte(NULL,"CList","State",(BYTE)state);

+	ske_UnloadSkin(&g_SkinObjectList);

+

+	delete m_pCLUI;

+

+	pcli->hwndContactList=NULL;

+	pcli->hwndStatus=NULL;

+	PostQuitMessage(0);

+	return 0;

+}