TraySCode/TrayS/TrayS.cpp

// TrayS.cpp : 定义应用程序的入口点。
//
#ifdef _WIN64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif

#include "framework.h"
#include "TrayS.h"
int DPI(int pixel)
{
	return pixel * iDPI / 96;
}
/*
typedef struct _IP_HEADER {
	BYTE bVerAndHLen;        / *版本信息（前4位）和头长度（后4位）* /
	BYTE bTypeOfService;        //服务类型
	USHORT nTotalLength;        //数据包长度
	USHORT nID;                                //数据包标识
	USHORT nReserved;                //保留字段
	BYTE bTTL;                                //生成时间
	BYTE bProtocol;                        //协议类型
	USHORT nCheckSum;                //校验和
	UINT nSourIp;                        //源IP
	UINT nDestIp;                        //目的IP
}IP_HEADER, * PIP_HEADER;
typedef struct _TCP_HEADER {
	USHORT nSourPort;
	USHORT nDestPort;
	UINT nSequNum;
	UINT nAcknowledgeNum;
	USHORT nHLenAndFlag;
	USHORT nWindowSize;
	USHORT nCheckSum;
	USHORT nrgentPointer;
}TCP_HEADER, * PTCP_HEADER;

typedef struct _UDP_HEADER {
	USHORT nSourPort;
	USHORT nDestPort;
	USHORT nLength;
	USHORT nCheckSum;
}UDP_HEADER, * PUDP_HEADER;


typedef struct _PACK_INFO {
	USHORT nLength;
	USHORT nProtocol;
	UINT nSourIp;
	UINT nDestIp;
	USHORT nSourPort;
	USHORT nDestPort;
}PACK_INFO, * LPPACK_INFO;

void AnalyseTcp(DWORD dwPort, ULONG64 ul64Flow, bool IsRecv)
{
	DWORD dwPid = 0;
	MIB_TCPTABLE_OWNER_PID* stcTcpTable = NULL;
	DWORD szTcpTableSize = 0;
	//获取TCP表大小
	GetExtendedTcpTable(stcTcpTable, &szTcpTableSize, FALSE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0);
	//分配内存
	stcTcpTable = (MIB_TCPTABLE_OWNER_PID*)malloc(szTcpTableSize);
	ZeroMemory(stcTcpTable, szTcpTableSize);
	//获取TCP表
	if (NO_ERROR != GetExtendedTcpTable(stcTcpTable, &szTcpTableSize, FALSE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0))
	{
		free(stcTcpTable);
		return;
	}
	for (DWORD i = 0; i < stcTcpTable->dwNumEntries; i++)
	{
		if (stcTcpTable->table[i].dwLocalPort == dwPort)
			dwPid = stcTcpTable->table[i].dwOwningPid;
	}
	free(stcTcpTable);
}



void AnalyseUdp(DWORD dwPort, ULONG64 ul64Flow, bool IsRecv)
{
	DWORD dwPid = 0;
	MIB_UDPTABLE_OWNER_PID* stcUdpTable = NULL;
	DWORD szUdpTableSize = 0;
	//获取UDP表大小
	GetExtendedUdpTable(stcUdpTable, &szUdpTableSize, FALSE, AF_INET, UDP_TABLE_OWNER_PID, 0);
	//分配内存
	stcUdpTable = (MIB_UDPTABLE_OWNER_PID*)malloc(szUdpTableSize);
	ZeroMemory(stcUdpTable, szUdpTableSize);
	//获取UDP表
	if (NO_ERROR != GetExtendedUdpTable(stcUdpTable, &szUdpTableSize, FALSE, AF_INET, UDP_TABLE_OWNER_PID, 0))
	{
		//在实际测试中这个地方确实偶尔是会失败的,不过在频繁的更新中一两次失败无关紧要
		free(stcUdpTable);
		return;
	}
	for (DWORD i = 0; i < stcUdpTable->dwNumEntries; i++)
	{
		if (stcUdpTable->table[i].dwLocalPort == dwPort)
			dwPid = stcUdpTable->table[i].dwOwningPid;
		//此处已经找到进程对应的pid了,同时包的大小和是上传还是下载已经通过参数传进来了。
	}
	free(stcUdpTable);
	//对数据的处理
	//...
}
void Thread()
{
	PACK_INFO        PackInfo = { 0 };
	int nRecvSize = 0;
	char szPackBuf[DEF_BUF_SIZE] = { 0 };

	WSADATA wsaData;
	int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
	if (iResult != NO_ERROR)
		return;

	// 获取本地地址信息
	sockaddr_in LocalAddr;
	char szLocalName[DEF_BUF_SIZE] = { 0 };
	gethostname(szLocalName, DEF_BUF_SIZE);
	hostent* pHost = gethostbyname(szLocalName);
	if (pHost != NULL)
	{
		LocalAddr.sin_family = AF_INET;
		LocalAddr.sin_port = htons(0);
		memcpy(&(LocalAddr.sin_addr.s_addr), pHost->h_addr_list[0], pHost->h_length);
	}
	else
		return;

	// 创建监听套接字
	SOCKET MonSock = socket(AF_INET, SOCK_RAW, IPPROTO_IP);
	if (MonSock == INVALID_SOCKET)
		return;

	// 绑定地址信息到套接字
	if (bind(MonSock, (sockaddr*)&LocalAddr, sizeof(sockaddr)) == SOCKET_ERROR)
		return;

	// 设置为混杂模式，收所有IP包
	DWORD dwValue = 1;
	if (ioctlsocket(MonSock, SIO_RCVALL, &dwValue) != 0)
		return;

	while (1)
	{
		// 取得数据包
		nRecvSize = recv(MonSock, szPackBuf, DEF_BUF_SIZE, 0);
		if (nRecvSize > 0)
		{
			// 解析IP包头
			PIP_HEADER pIpHeader = (PIP_HEADER)szPackBuf;
			PackInfo.nLength = nRecvSize;
			PackInfo.nProtocol = (USHORT)pIpHeader->bProtocol;
			PackInfo.nSourIp = pIpHeader->nSourIp;
			PackInfo.nDestIp = pIpHeader->nDestIp;
			UINT nIpHeadLength = (pIpHeader->bVerAndHLen & 0x0F) * sizeof(UINT);                        // IP数据包头长度

			// 只检测TCP和UDP包
			switch (pIpHeader->bProtocol)
			{
			case IPPROTO_TCP:
			{
				// 取得TCP数据包端口号
				PTCP_HEADER pTcpHeader = (PTCP_HEADER)&szPackBuf[nIpHeadLength];
				PackInfo.nSourPort = pTcpHeader->nSourPort;
				PackInfo.nDestPort = pTcpHeader->nDestPort;
				//判断上传还是下载
				if (PackInfo.nSourIp == LocalAddr.sin_addr.S_un.S_addr)
					AnalyseTcp(PackInfo.nSourPort, PackInfo.nLength, FALSE);
				else
					AnalyseTcp(PackInfo.nDestPort, PackInfo.nLength, TRUE);
			}
			break;
			case IPPROTO_UDP:
			{
				// 取得UDP数据包端口号
				PUDP_HEADER pUdpHeader = (PUDP_HEADER)&szPackBuf[nIpHeadLength];
				PackInfo.nSourPort = pUdpHeader->nSourPort;
				PackInfo.nDestPort = pUdpHeader->nDestPort;
				if (PackInfo.nSourIp == LocalAddr.sin_addr.S_un.S_addr)
					AnalyseUdp(PackInfo.nSourPort, PackInfo.nLength, FALSE);
				else
					AnalyseUdp(PackInfo.nDestPort, PackInfo.nLength, TRUE);

			}
			break;
			}
		}

	}
}
*/
BOOL CALLBACK FindWindowFunc(HWND hWnd, LPARAM lpAram)
{
	WCHAR szText[16];
	GetWindowText(hWnd, szText, 16);
	if (lstrcmp(szText, L"_TrayS_") == 0)
	{
		SendMessage(hWnd, WM_TRAYS, 0, 0);
		return FALSE;
	}
	return TRUE;
}
BOOL CALLBACK IsZoomedFunc(HWND hWnd, LPARAM lpAram)
{
	if (::IsWindowVisible(hWnd) && IsZoomed(hWnd))
	{
		if (MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST) == (HMONITOR)lpAram)
		{
			BOOL Attribute = FALSE;
			if (pDwmGetWindowAttribute)
				pDwmGetWindowAttribute(hWnd, 14, &Attribute, sizeof(BOOL));
			if (Attribute == FALSE)
			{
				iWindowMode = 1;
				return FALSE;
			}
		}
	}
	return TRUE;
}
/*
BOOL CreateProcessByExplorer(LPCWSTR process, LPCWSTR szDir, LPCWSTR cmd)
{
	BOOL ret = FALSE;

	HANDLE hProcess = 0, hToken = 0, hDuplicatedToken = 0;
	LPVOID lpEnv = NULL;
	do
	{
		HWND hTrayWnd = ::FindWindow(szShellTray, NULL);
		DWORD explorerPid;
		GetWindowThreadProcessId(hTrayWnd, &explorerPid);// 获取explorer进程号，自行实现

		if (explorerPid == NULL)
			break;
		hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, explorerPid);
		if (INVALID_HANDLE_VALUE == hProcess)
			break;

		if (!OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken))
			break;

		DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL, SecurityIdentification, TokenPrimary, &hDuplicatedToken);
		CreateEnvironmentBlock(&lpEnv, hDuplicatedToken, FALSE);

		/ *
			WCHAR szDir[MAX_PATH] = L"\"";
		wcscpy_s(&szDir[2], MAX_PATH, process);
		int iLen = wcslen(szDir);
		if (NULL != cmd)
		{
			wcscpy_s(&szDir[iLen], MAX_PATH, L"\" \"");
			iLen = wcslen(szDir);
			wcscpy_s(&szDir[iLen], MAX_PATH, cmd);
		}
		iLen = wcslen(szDir);
		wcscpy_s(&szDir[iLen], MAX_PATH, L"\"");
		* /

			STARTUPINFO si = { 0 };
		PROCESS_INFORMATION pi = { 0 };
		si.cb = sizeof(STARTUPINFO);
		si.lpDesktop = (LPWSTR)L"winsta0\\default";
		si.dwFlags = STARTF_USESHOWWINDOW;
		si.wShowWindow = SW_HIDE;
		if (!CreateProcessAsUser(hToken, process, NULL / *const_cast<LPWSTR>(szDir) * / , 0, 0, FALSE, CREATE_UNICODE_ENVIRONMENT, lpEnv, NULL, &si, &pi))
			break;
		ret = TRUE;
	} while (0);
	if (INVALID_HANDLE_VALUE != hProcess)
		CloseHandle(hProcess);
	if (INVALID_HANDLE_VALUE != hToken)
		CloseHandle(hToken);
	if (INVALID_HANDLE_VALUE != hDuplicatedToken)
		CloseHandle(hDuplicatedToken);
	if (NULL != lpEnv)
		DestroyEnvironmentBlock(lpEnv);
	return ret;
}

*/
DWORD iCPU;
/////////////////////////////////////////////////////////////////////////////CPU占用率
FILETIME pre_idleTime;
FILETIME pre_kernelTime;
FILETIME pre_userTime;
__int64 CompareFileTime(FILETIME time1, FILETIME time2)
{
	__int64 a = time1.dwHighDateTime;
	a = a << 32 | time1.dwLowDateTime;
	__int64 b = time2.dwHighDateTime;
	b = b << 32 | time2.dwLowDateTime;
	return (b - a);
}
typedef struct _PDH_RAW_COUNTER {
	volatile DWORD CStatus;
	FILETIME    TimeStamp;
	LONGLONG    FirstValue;
	LONGLONG    SecondValue;
	DWORD       MultiCount;
} PDH_RAW_COUNTER, * PPDH_RAW_COUNTER;
PDH_RAW_COUNTER m_last_rawData;
BOOL m_first_get_CPU_utility=TRUE;
int GetCPUUseRate()
{
	if (TraySave.bMonitorPDH)
	{
#define PDH_FMT_RAW          ((DWORD) 0x00000010)
#define PDH_FMT_ANSI         ((DWORD) 0x00000020)
#define PDH_FMT_UNICODE      ((DWORD) 0x00000040)
#define PDH_FMT_LONG         ((DWORD) 0x00000100)
#define PDH_FMT_DOUBLE       ((DWORD) 0x00000200)
#define PDH_FMT_LARGE        ((DWORD) 0x00000400)
#define PDH_FMT_NOSCALE      ((DWORD) 0x00001000)
#define PDH_FMT_1000         ((DWORD) 0x00002000)
#define PDH_FMT_NODATA       ((DWORD) 0x00004000)
#define PDH_FMT_NOCAP100     ((DWORD) 0x00008000)
#define PERF_DETAIL_COSTLY   ((DWORD) 0x00010000)
#define PERF_DETAIL_STANDARD ((DWORD) 0x0000FFFF)
		typedef HANDLE       PDH_HCOUNTER;
		typedef HANDLE       PDH_HQUERY;
		typedef HANDLE       PDH_HLOG;

		typedef PDH_HCOUNTER HCOUNTER;
		typedef PDH_HQUERY   HQUERY;

		typedef struct _PDH_FMT_COUNTERVALUE {
			DWORD    CStatus;
			union {
				LONG        longValue;
				double      doubleValue;
				LONGLONG    largeValue;
				LPCSTR      AnsiStringValue;
				LPCWSTR     WideStringValue;
			};
		} PDH_FMT_COUNTERVALUE, * PPDH_FMT_COUNTERVALUE;
		//获取CPU使用率
		HQUERY hQuery;
		HCOUNTER hCounter;
		DWORD counterType;
		PDH_RAW_COUNTER rawData;
		typedef ULONG(WINAPI* pfnPdhOpenQuery)(_In_opt_ LPCWSTR szDataSource, _In_ DWORD_PTR dwUserData, _Out_ PDH_HQUERY* phQuery);
		typedef ULONG(WINAPI* pfnPdhAddCounter)(_In_ PDH_HQUERY hQuery, _In_ LPCWSTR szFullCounterPath, _In_ DWORD_PTR dwUserData, _Out_ PDH_HCOUNTER* phCounter);
		typedef ULONG(WINAPI* pfnPdhCollectQueryData)(PDH_HQUERY hQuery);
		typedef ULONG(WINAPI* pfnPdhGetRawCounterValue)(PDH_HCOUNTER hCounter, LPDWORD lpdwType, PPDH_RAW_COUNTER pValue);
		typedef ULONG(WINAPI* pfnPdhCalculateCounterFromRawValue)(PDH_HCOUNTER hCounter, DWORD dwFormat, PPDH_RAW_COUNTER rawValue1, PPDH_RAW_COUNTER rawValue2, PPDH_FMT_COUNTERVALUE fmtValue);
		typedef ULONG(WINAPI* pfnPdhCloseQuery)(PDH_HQUERY hQuery);
		if (hPDH == NULL)
			hPDH = LoadLibrary(L"pdh.dll");
		if (hPDH)
		{
			pfnPdhOpenQuery PdhOpenQuery = (pfnPdhOpenQuery)GetProcAddress(hPDH, "PdhOpenQueryW");
			pfnPdhAddCounter PdhAddCounter = (pfnPdhAddCounter)GetProcAddress(hPDH, "PdhAddCounterW");
			pfnPdhCollectQueryData PdhCollectQueryData = (pfnPdhCollectQueryData)GetProcAddress(hPDH, "PdhCollectQueryData");
			pfnPdhGetRawCounterValue PdhGetRawCounterValue = (pfnPdhGetRawCounterValue)GetProcAddress(hPDH, "PdhGetRawCounterValue");
			pfnPdhCalculateCounterFromRawValue PdhCalculateCounterFromRawValue = (pfnPdhCalculateCounterFromRawValue)GetProcAddress(hPDH, "PdhCalculateCounterFromRawValue");
			pfnPdhCloseQuery PdhCloseQuery = (pfnPdhCloseQuery)GetProcAddress(hPDH, "PdhCloseQuery");
			if (PdhCloseQuery != NULL && PdhAddCounter != NULL && PdhCollectQueryData != NULL && PdhGetRawCounterValue != NULL && PdhCalculateCounterFromRawValue != NULL && PdhCloseQuery != NULL)
			{
				PdhOpenQuery(NULL, 0, &hQuery);//开始查询
				const wchar_t* query_str{};

				query_str = L"\\Processor Information(_Total)\\% Processor Utility";
				PdhAddCounter(hQuery, query_str, NULL, &hCounter);
				PdhCollectQueryData(hQuery);
				PdhGetRawCounterValue(hCounter, &counterType, &rawData);
				PDH_FMT_COUNTERVALUE fmtValue;
				PdhCalculateCounterFromRawValue(hCounter, PDH_FMT_DOUBLE, &rawData, &m_last_rawData, &fmtValue);//计算使用率
				iCPU = (int)fmtValue.doubleValue;//传出数据
				if (iCPU > 100)
					iCPU = 100;
				m_last_rawData = rawData;//保存上一次数据
				PdhCloseQuery(hQuery);//关闭查询
			}
		}
		return iCPU;
	}
	else
	{
		if (hPDH)
		{
			FreeLibrary(hPDH);
			hPDH = NULL;
		}
		int nCPUUseRate = -1;
		FILETIME idleTime;//空闲时间 
		FILETIME kernelTime;//核心态时间 
		FILETIME userTime;//用户态时间 
		GetSystemTimes(&idleTime, &kernelTime, &userTime);

		__int64 idle = CompareFileTime(pre_idleTime, idleTime);
		__int64 kernel = CompareFileTime(pre_kernelTime, kernelTime);
		__int64 user = CompareFileTime(pre_userTime, userTime);
		if (kernel + user != 0)
			nCPUUseRate = (int)((kernel + user - idle) * 100 / (kernel + user));
		pre_idleTime = idleTime;
		pre_kernelTime = kernelTime;
		pre_userTime = userTime;
		if (nCPUUseRate < 1)
			nCPUUseRate = iCPU;
		else if (nCPUUseRate > 100)
			nCPUUseRate = 100;
		return nCPUUseRate;
	}
}
void ReadReg()//读取设置
{
	SetToCurrentPath();
	HANDLE hFile = CreateFile(szTraySave, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL);
	if (hFile)
	{
		DWORD dwBytes;
		ReadFile(hFile, &TraySave, sizeof TraySave, &dwBytes, NULL);
		CloseHandle(hFile);
	}
	/*
		HKEY pKey;
		if(IsUserAdmin())
			RegOpenKeyEx(HKEY_LOCAL_MACHINE, szSubKey, NULL, KEY_ALL_ACCESS, &pKey);
		else
			RegOpenKeyEx(HKEY_CURRENT_USER, szSubKey, NULL, KEY_ALL_ACCESS, &pKey);
		if (pKey)
		{
			DWORD dType = REG_BINARY;
			DWORD cbData = sizeof(aMode);
			RegQueryValueEx(pKey, szMode, NULL, &dType, (BYTE*)aMode, &cbData);
			dType = REG_BINARY;
			cbData = sizeof(dAlphaColor);
			RegQueryValueEx(pKey, szAlphaColor, NULL, &dType, (BYTE*)dAlphaColor, &cbData);
			dType = REG_BINARY;
			cbData = sizeof(bAlpha);
			RegQueryValueEx(pKey, szAlpha, NULL, &dType, (BYTE*)bAlpha, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szPos, NULL, &dType, (BYTE*)&iPos, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szUnit, NULL, &dType, (BYTE*)&iUnit, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szTrayIcon, NULL, &dType, (BYTE*)&bTrayIcon, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitor, NULL, &dType, (BYTE*)&bMonitor, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorLeft, NULL, &dType, (BYTE*)&bMonitorLeft, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorFloat, NULL, &dType, (BYTE*)&bMonitorFloat, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorTransparent, NULL, &dType, (BYTE*)&bMonitorTransparent, &cbData);
			dType = REG_BINARY;
			cbData = sizeof(dMonitorPoint);
			RegQueryValueEx(pKey, szMonitorPoint, NULL, &dType, (BYTE*)&dMonitorPoint, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorTraffic, NULL, &dType, (BYTE*)&bMonitorTraffic, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorTemperature, NULL, &dType, (BYTE*)&bMonitorTemperature, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorUsage, NULL, &dType, (BYTE*)&bMonitorUsage, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szSound, NULL, &dType, (BYTE*)&bSound, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorPDH, NULL, &dType, (BYTE*)&bMonitorPDH, &cbData);
			dType = REG_DWORD;
			cbData = sizeof(DWORD);
			RegQueryValueEx(pKey, szMonitorSimple, NULL, &dType, (BYTE*)&bMonitorSimple, &cbData);
			dType = REG_BINARY;
			cbData = sizeof(cMonitorColor);
			RegQueryValueEx(pKey, szMonitorColor, NULL, &dType, (BYTE*)cMonitorColor, &cbData);
			dType = REG_BINARY;
			cbData = sizeof(dNumValues);
			RegQueryValueEx(pKey, szNumValues, NULL, &dType, (BYTE*)dNumValues, &cbData);
			dType = REG_BINARY;
			cbData = 38;
			RegQueryValueEx(pKey, szAdapterName, NULL, &dType, (BYTE*)AdpterName, &cbData);
			RegCloseKey(pKey);
		}
	*/
}
void WriteReg()//写入设置
{
	SetToCurrentPath();
	HANDLE hFile = CreateFile(szTraySave, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_ARCHIVE, NULL);
	if (hFile)
	{
		DWORD dwBytes;
		WriteFile(hFile, &TraySave, sizeof TraySave, &dwBytes, NULL);
		CloseHandle(hFile);
	}
	/*
		HKEY pKey;
		if (IsUserAdmin())
		{
			RegCreateKey(HKEY_LOCAL_MACHINE, szSubKey, &pKey);
			RegCloseKey(pKey);
			RegOpenKeyEx(HKEY_LOCAL_MACHINE, szSubKey, NULL, KEY_ALL_ACCESS, &pKey);
		}
		else
		{
			RegCreateKey(HKEY_CURRENT_USER, szSubKey, &pKey);
			RegCloseKey(pKey);
			RegOpenKeyEx(HKEY_CURRENT_USER, szSubKey, NULL, KEY_ALL_ACCESS, &pKey);
		}
		if (pKey)
		{
			RegSetValueEx(pKey, szMode, NULL, REG_BINARY, (BYTE*)aMode, sizeof(aMode));
			RegSetValueEx(pKey, szAlphaColor, NULL, REG_BINARY, (BYTE*)dAlphaColor, sizeof(dAlphaColor));
			RegSetValueEx(pKey, szAlpha, NULL, REG_BINARY, (BYTE*)bAlpha, sizeof(bAlpha));
			RegSetValueEx(pKey, szPos, NULL, REG_DWORD, (BYTE*)&iPos, sizeof(iPos));
			RegSetValueEx(pKey, szUnit, NULL, REG_DWORD, (BYTE*)&iUnit, sizeof(iUnit));
			RegSetValueEx(pKey, szTrayIcon, NULL, REG_DWORD, (BYTE*)&bTrayIcon, sizeof(bTrayIcon));
			RegSetValueEx(pKey, szMonitor, NULL, REG_DWORD, (BYTE*)&bMonitor, sizeof(bMonitor));
			RegSetValueEx(pKey, szMonitorLeft, NULL, REG_DWORD, (BYTE*)&bMonitorLeft, sizeof(bMonitorLeft));
			RegSetValueEx(pKey, szMonitorFloat, NULL, REG_DWORD, (BYTE*)&bMonitorFloat, sizeof(bMonitorFloat));
			RegSetValueEx(pKey, szMonitorTransparent, NULL, REG_DWORD, (BYTE*)&bMonitorTransparent, sizeof(bMonitorTransparent));
			RegSetValueEx(pKey, szMonitorPoint, NULL, REG_BINARY, (BYTE*)&dMonitorPoint, sizeof(dMonitorPoint));
			RegSetValueEx(pKey, szMonitorTraffic, NULL, REG_DWORD, (BYTE*)&bMonitorTraffic, sizeof(bMonitorTraffic));
			RegSetValueEx(pKey, szMonitorTemperature, NULL, REG_DWORD, (BYTE*)&bMonitorTemperature, sizeof(bMonitorTemperature));
			RegSetValueEx(pKey, szMonitorUsage, NULL, REG_DWORD, (BYTE*)&bMonitorUsage, sizeof(bMonitorUsage));
			RegSetValueEx(pKey, szMonitorPDH, NULL, REG_DWORD, (BYTE*)&bMonitorPDH, sizeof(bMonitorPDH));
			RegSetValueEx(pKey, szMonitorSimple, NULL, REG_DWORD, (BYTE*)&bMonitorSimple, sizeof(bMonitorSimple));
			RegSetValueEx(pKey, szSound, NULL, REG_DWORD, (BYTE*)&bSound, sizeof(bSound));
			RegSetValueEx(pKey, szMonitorColor, NULL, REG_BINARY, (BYTE*)cMonitorColor, sizeof(cMonitorColor));
			RegSetValueEx(pKey, szNumValues, NULL, REG_BINARY, (BYTE*)dNumValues, sizeof(dNumValues));
			RegSetValueEx(pKey, szAdapterName, NULL, REG_BINARY, (BYTE*)AdpterName, 38);
			RegCloseKey(pKey);
		}
	*/
}
void GetShellAllWnd()
{
	while (IsWindow(hTray) == FALSE)
	{
		hTray = FindWindow(szShellTray, NULL);
		if (hTray == NULL)
			Sleep(100);
	}
	while (IsWindow(hReBarWnd) == FALSE)
	{
		hReBarWnd = FindWindowEx(hTray, 0, L"ReBarWindow32", NULL);
		if (hReBarWnd == NULL)
			Sleep(100);
	}
	if (IsWindow(hTaskWnd) == FALSE)
		hTaskWnd = FindWindowEx(hReBarWnd, NULL, L"MSTaskSwWClass", NULL);
	if (IsWindow(hTaskListWnd) == FALSE)
		hTaskListWnd = FindWindowEx(hTaskWnd, NULL, L"MSTaskListWClass", NULL);
}
void CloseTaskBar()
{
	if (IsWindow(hTaskBar))
		DestroyWindow(hTaskBar);
	if (IsWindow(hTaskTips))
		DestroyWindow(hTaskTips);
}
void OpenTaskBar()
{
	if (IsWindow(hTaskBar) == FALSE)
	{
		hTaskBar = ::CreateDialog(hInst, MAKEINTRESOURCE(IDD_TASKBAR), NULL, (DLGPROC)TaskBarProc);
		if (hTaskBar)
		{
			GetShellAllWnd();
			if (TraySave.bMonitorFloat)
			{
				LONG exStyle = WS_EX_LAYERED | WS_EX_TOPMOST;
				if (TraySave.bMonitorTransparent)
					exStyle |= WS_EX_TRANSPARENT;
				SetWindowLongPtr(hTaskBar, GWL_EXSTYLE, GetWindowLongPtr(hTaskBar, GWL_EXSTYLE) | exStyle);
				SetLayeredWindowAttributes(hTaskBar, RGB(0, 0, 1), 198, LWA_ALPHA | LWA_COLORKEY);
				SetParent(hTaskBar, NULL);
			}
			else
				SetParent(hTaskBar, hReBarWnd);
			SetWH();
			/*
						if (rovi.dwMajorVersion < 10)
						{
							SetWindowLongPtr(hTaskBar, GWL_EXSTYLE, GetWindowLongPtr(hTaskBar, GWL_EXSTYLE) | WS_EX_LAYERED);
							SetLayeredWindowAttributes(hTaskBar, RGB(128, 128, 129), 0, LWA_COLORKEY);
						}
			*/
			ShowWindow(hTaskBar, SW_SHOW);
			SetTimer(hTaskBar, 3, 1000, NULL);
			//			SetTimer(hTaskBar, 6, 100, NULL);
		}
	}
	else
	{
		if (TraySave.bMonitorTransparent)
			SetWindowLongPtr(hTaskBar, GWL_EXSTYLE, GetWindowLongPtr(hTaskBar, GWL_EXSTYLE) | WS_EX_TRANSPARENT);
		else
			SetWindowLongPtr(hTaskBar, GWL_EXSTYLE, GetWindowLongPtr(hTaskBar, GWL_EXSTYLE) & ~WS_EX_TRANSPARENT);
	}
}
////////////////////////////////////////////获取CPU温度
#define MISC_CONTROL_3 0x3+((0x18)<<3)
int GetCpuTemp(DWORD Core)
{
	if (bRing0)
	{
		SetThreadAffinityMask(GetCurrentThread(), Core);
		DWORD eax = 0, ebx, ecx, edx;
		if (!bIntel)
		{
			Cpuid(1, &eax, &ebx, &ecx, &edx);
			int family = ((eax >> 20) & 0xFF) + ((eax >> 8) & 0xF);
			if (family > 0xf)
			{
				//				DWORD pciDevAddr = FindPciDeviceById(0x1022, 0x1203, 0);
				DWORD miscReg;
				ReadPciConfigDwordEx(MISC_CONTROL_3, 0xa4, &miscReg);
				return (miscReg >> 21) >> 3;
			}
			else
			{
				//				DWORD pciDevAddr = FindPciDeviceById(0x1022, 0x1103, 0);
				DWORD miscReg;
				ReadPciConfigDwordEx(MISC_CONTROL_3, 0xe4, &miscReg);
				return ((miscReg & 0xFF0000) >> 16) - 49;
				//				return (miscReg >> 16) & 0xFF;
			}
		}
		else
		{
			DWORD IAcore;
			int Tjunction = 100;
			Rdmsr(0x1A2, &eax, &edx);
			if (eax & 0x20000000)
				Tjunction = 85;
			Rdmsr(0x19C, &eax, &edx);
			IAcore = eax;
			IAcore &= 0xFF0000;
			IAcore = IAcore >> 16;
			return Tjunction - IAcore;
		}
	}
	return 0;
}
//////////////////////////////////////////////////载入温度DLL
void LoadTemperatureDLL()
{
	if (!InitOpenLibSys(&m_hOpenLibSys))
		bRing0 = FALSE;
	else
	{
		bRing0 = TRUE;
		DWORD eax, ebx, ecx, edx;
		Cpuid(0, &eax, &ebx, &ecx, &edx);
		bIntel = TRUE;
		if (ebx == 0x68747541)
		{
			bIntel = FALSE;
		}
	}
#ifdef _WIN64
	hNVDLL = LoadLibrary(L"nvapi64.dll");
#else
	hNVDLL = LoadLibrary(L"nvapi.dll");
#endif
	if (hNVDLL)
	{
		NvAPI_QueryInterface = (NvAPI_QueryInterface_t)GetProcAddress(hNVDLL, "nvapi_QueryInterface");
		if (NvAPI_QueryInterface)
		{
			NvAPI_Initialize_t NvAPI_Initialize = (NvAPI_Initialize_t)NvAPI_QueryInterface(ID_NvAPI_Initialize);
			NvAPI_EnumPhysicalGPUs_t NvAPI_EnumPhysicalGPUs = (NvAPI_EnumPhysicalGPUs_t)NvAPI_QueryInterface(ID_NvAPI_EnumPhysicalGPUs);
			NvAPI_GPU_GetThermalSettings = (NvAPI_GPU_GetThermalSettings_t)NvAPI_QueryInterface(ID_NvAPI_GPU_GetThermalSettings);
			if (NvAPI_Initialize != NULL && NvAPI_EnumPhysicalGPUs != NULL && NvAPI_GPU_GetThermalSettings != NULL)
			{
				if (NvAPI_Initialize() == 0)
				{
					for (NvU32 PhysicalGpuIndex = 0; PhysicalGpuIndex < 4; PhysicalGpuIndex++)
					{
						hPhysicalGpu[PhysicalGpuIndex] = 0;
					}
					int physicalGpuCount;
					NvAPI_EnumPhysicalGPUs(hPhysicalGpu, &physicalGpuCount);
				}
				else
				{
					FreeLibrary(hNVDLL);
					hNVDLL = NULL;
				}
			}
			else
			{
				FreeLibrary(hNVDLL);
				hNVDLL = NULL;
			}
		}
		else
		{
			FreeLibrary(hNVDLL);
			hNVDLL = NULL;
		}
	}
#ifdef _WIN64
	hATIDLL = LoadLibrary(L"atiadlxx.dll");
#else
	hATIDLL = LoadLibrary(L"atiadlxy.dll");
#endif
	if (hATIDLL)
	{
		ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(hATIDLL, "ADL_Main_Control_Create");
		ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)GetProcAddress(hATIDLL, "ADL_Main_Control_Destroy");
		ADL_Overdrive5_Temperature_Get = (ADL_OVERDRIVE5_TEMPERATURE_GET)GetProcAddress(hATIDLL, "ADL_Overdrive5_Temperature_Get");
		if (NULL != ADL_Main_Control_Create &&
			NULL != ADL_Main_Control_Destroy
			)
		{
			if (ADL_OK != ADL_Main_Control_Create(ADL_Main_Memory_Alloc, 1))
			{
				FreeLibrary(hATIDLL);
				hATIDLL = NULL;
			}
		}
		else
		{
			FreeLibrary(hATIDLL);
			hATIDLL = NULL;
		}
	}
}
///////////////////////////////////释放温度DLL
void FreeTemperatureDLL()
{
	if (hATIDLL)
	{
		ADL_Main_Control_Destroy();
		FreeLibrary(hATIDLL);
		hATIDLL = NULL;
	}
	if (hNVDLL)
	{
		FreeLibrary(hNVDLL);
		hNVDLL = NULL;
	}
	if (m_hOpenLibSys)
		DeinitOpenLibSys(&m_hOpenLibSys);
	m_hOpenLibSys = NULL;
}
///////////////////////////////////////////////打开读取设置
void OpenSetting()
{
	if (IsWindow(hSetting))
	{
		SetForegroundWindow(hSetting);
		return;
	}
	hSetting = ::CreateDialog(hInst, MAKEINTRESOURCE(IDD_SETTING), NULL, (DLGPROC)SettingProc);
	if (!hSetting)
	{
		return;
	}
	SendMessage(hSetting, WM_SETICON, ICON_BIG, (LPARAM)(HICON)iMain);
	SendMessage(hSetting, WM_SETICON, ICON_SMALL, (LPARAM)(HICON)iMain);
	CheckRadioButton(hSetting, IDC_RADIO_NORMAL, IDC_RADIO_MAXIMIZE, IDC_RADIO_NORMAL);
	iProject = iWindowMode;
	if (iProject == 0)
		CheckRadioButton(hSetting, IDC_RADIO_NORMAL, IDC_RADIO_MAXIMIZE, IDC_RADIO_NORMAL);
	else
		CheckRadioButton(hSetting, IDC_RADIO_NORMAL, IDC_RADIO_MAXIMIZE, IDC_RADIO_MAXIMIZE);
	if (TraySave.aMode[iProject] == ACCENT_DISABLED)
		CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_DEFAULT);
	else if (TraySave.aMode[iProject] == ACCENT_ENABLE_TRANSPARENTGRADIENT)
		CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_TRANSPARENT);
	else if (TraySave.aMode[iProject] == ACCENT_ENABLE_BLURBEHIND)
		CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_BLURBEHIND);
	else if (TraySave.aMode[iProject] == ACCENT_ENABLE_ACRYLICBLURBEHIND)
		CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_ACRYLIC);
	if (TraySave.iPos == 0)
		CheckRadioButton(hSetting, IDC_RADIO_LEFT, IDC_RADIO_RIGHT, IDC_RADIO_LEFT);
	else if (TraySave.iPos == 1)
		CheckRadioButton(hSetting, IDC_RADIO_LEFT, IDC_RADIO_RIGHT, IDC_RADIO_CENTER);
	else if (TraySave.iPos == 2)
		CheckRadioButton(hSetting, IDC_RADIO_LEFT, IDC_RADIO_RIGHT, IDC_RADIO_RIGHT);
	if (LOWORD(TraySave.iUnit) == 0)
		CheckRadioButton(hSetting, IDC_RADIO_AUTO, IDC_RADIO_MB, IDC_RADIO_AUTO);
	else if (LOWORD(TraySave.iUnit) == 1)
		CheckRadioButton(hSetting, IDC_RADIO_AUTO, IDC_RADIO_MB, IDC_RADIO_KB);
	else if (LOWORD(TraySave.iUnit) == 2)
		CheckRadioButton(hSetting, IDC_RADIO_AUTO, IDC_RADIO_MB, IDC_RADIO_MB);
	if (HIWORD(TraySave.iUnit) == 0)
		CheckRadioButton(hSetting, IDC_RADIO_BYTE, IDC_RADIO_BIT, IDC_RADIO_BYTE);
	else
		CheckRadioButton(hSetting, IDC_RADIO_BYTE, IDC_RADIO_BIT, IDC_RADIO_BIT);
	CheckDlgButton(hSetting, IDC_CHECK_TRAYICON, TraySave.bTrayIcon);
	CheckDlgButton(hSetting, IDC_CHECK_MONITOR, TraySave.bMonitor);
	CheckDlgButton(hSetting, IDC_CHECK_TRAFFIC, TraySave.bMonitorTraffic);
	CheckDlgButton(hSetting, IDC_CHECK_TEMPERATURE, TraySave.bMonitorTemperature);
	CheckDlgButton(hSetting, IDC_CHECK_USAGE, TraySave.bMonitorUsage);
	CheckDlgButton(hSetting, IDC_CHECK_SOUND, TraySave.bSound);
	CheckDlgButton(hSetting, IDC_CHECK_MONITOR_PDH, TraySave.bMonitorPDH);
	CheckDlgButton(hSetting, IDC_CHECK_MONITOR_SIMPLE, TraySave.iMonitorSimple);
	CheckDlgButton(hSetting, IDC_CHECK_MONITOR_LEFT, TraySave.bMonitorLeft);
	CheckDlgButton(hSetting, IDC_CHECK_MONITOR_FLOAT, TraySave.bMonitorFloat);
	CheckDlgButton(hSetting, IDC_CHECK_TRANSPARENT, TraySave.bMonitorTransparent);
	CheckDlgButton(hSetting, IDC_CHECK_TIPS, TraySave.bMonitorTips);
	SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA, TBM_SETRANGE, 0, MAKELPARAM(0, 255));
	SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA, TBM_SETPOS, TRUE, TraySave.bAlpha[iProject]);
	SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA_B, TBM_SETRANGE, 0, MAKELPARAM(0, 255));
	BYTE bAlphaB = TraySave.dAlphaColor[iProject] >> 24;
	SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA_B, TBM_SETPOS, TRUE, bAlphaB);
	SendDlgItemMessage(hSetting, IDC_CHECK_AUTORUN, BM_SETCHECK, AutoRun(FALSE, FALSE,szAppName), NULL);
	bSettingInit = TRUE;
	SetDlgItemInt(hSetting, IDC_EDIT1, TraySave.dNumValues[0] / 1048576, 0);
	SetDlgItemInt(hSetting, IDC_EDIT2, TraySave.dNumValues[1] / 1048576, 0);
	SetDlgItemInt(hSetting, IDC_EDIT3, TraySave.dNumValues[2], 0);
	SetDlgItemInt(hSetting, IDC_EDIT4, TraySave.dNumValues[3], 0);
	SetDlgItemInt(hSetting, IDC_EDIT5, TraySave.dNumValues[4], 0);
	SetDlgItemInt(hSetting, IDC_EDIT6, TraySave.dNumValues[5], 0);
	SetDlgItemInt(hSetting, IDC_EDIT7, TraySave.dNumValues[6], 0);
	SetDlgItemInt(hSetting, IDC_EDIT8, TraySave.dNumValues[7], 0);
	SetDlgItemInt(hSetting, IDC_EDIT9, TraySave.dNumValues[8] / 1048576, 0);
	SetDlgItemInt(hSetting, IDC_EDIT10, TraySave.dNumValues[9], 0);
	SetDlgItemInt(hSetting, IDC_EDIT11, TraySave.dNumValues[10], 0);
	SetDlgItemInt(hSetting, IDC_EDIT12, TraySave.dNumValues[11], 0);
	SetDlgItemInt(hSetting, IDC_EDIT_TIME, TraySave.FlushTime, 0);
	SetDlgItemText(hSetting, IDC_EDIT14, TraySave.szTrafficOut);
	SetDlgItemText(hSetting, IDC_EDIT15, TraySave.szTrafficIn);
	SetDlgItemText(hSetting, IDC_EDIT16, TraySave.szTemperatureCPU);
	SetDlgItemText(hSetting, IDC_EDIT17, TraySave.szTemperatureGPU);
	SetDlgItemText(hSetting, IDC_EDIT18, TraySave.szTemperatureCPUUnit);
	SetDlgItemText(hSetting, IDC_EDIT19, TraySave.szTemperatureGPUUnit);
	SetDlgItemText(hSetting, IDC_EDIT20, TraySave.szUsageCPU);
	SetDlgItemText(hSetting, IDC_EDIT21, TraySave.szUsageMEM);
	SetDlgItemText(hSetting, IDC_EDIT22, TraySave.szUsageCPUUnit);
	SetDlgItemText(hSetting, IDC_EDIT23, TraySave.szUsageMEMUnit);
	bSettingInit = FALSE;
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_BACKGROUND), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_TRAFFIC_LOW), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_TRAFFIC_MEDIUM), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_TRAFFIC_HIGH), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_LOW), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_MEDUIM), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	oldColorButtonPoroc = (WNDPROC)SetWindowLongPtr(GetDlgItem(hSetting, IDC_BUTTON_COLOR_HIGH), GWLP_WNDPROC, (LONG_PTR)ColorButtonProc);
	ShowWindow(hSetting, SW_SHOW);
	UpdateWindow(hSetting);
	SetForegroundWindow(hSetting);
}
/*
void SetTaskScheduler(BOOL bAdd)
{
	HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
	if (SUCCEEDED(hr))
	{
		//  Set general COM security levels.
		hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, 0, NULL);
		if (SUCCEEDED(hr))
		{
			ITaskService* pService = NULL;
			hr = CoCreateInstance(CLSID_TaskScheduler,
				NULL,
				CLSCTX_INPROC_SERVER,
				IID_ITaskService,
				(void**)&pService);
			if (SUCCEEDED(hr))
			{
				hr = pService->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());
				if (SUCCEEDED(hr))
				{
					ITaskFolder* pRootFolder = NULL;
					hr = pService->GetFolder(_bstr_t(L"\\"), &pRootFolder);
					if (SUCCEEDED(hr))
					{
						pRootFolder->DeleteTask(_bstr_t(szAppName), 0);
						if (bAdd)
						{
							ITaskDefinition* pTask = NULL;
							hr = pService->NewTask(0, &pTask);
							//						pService->Release();  // COM clean up.  Pointer is no longer used.
							if (SUCCEEDED(hr))
							{
								if (IsUserAdmin())
								{
									IPrincipal* pPrincipal;
									hr = pTask->get_Principal(&pPrincipal);
									if (SUCCEEDED(hr))
									{
										pPrincipal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);
									}
								}
								IRegistrationInfo* pRegInfo = NULL;
								hr = pTask->get_RegistrationInfo(&pRegInfo);
								if (SUCCEEDED(hr))
								{
									hr = pRegInfo->put_Author(_bstr_t(L"cgbsmy"));
									pRegInfo->Release();
									
									if (SUCCEEDED(hr))
									{
										ITaskSettings* pSettings = NULL;
										hr = pTask->get_Settings(&pSettings);
										if (SUCCEEDED(hr))
										{
											pSettings->put_StopIfGoingOnBatteries(VARIANT_FALSE);
											pSettings->put_DisallowStartIfOnBatteries(VARIANT_FALSE);
											pSettings->put_AllowHardTerminate(VARIANT_FALSE);
											pSettings->put_ExecutionTimeLimit(_bstr_t(L"PT0S"));
											pSettings->put_WakeToRun(VARIANT_TRUE);
											hr = pSettings->put_StartWhenAvailable(VARIANT_TRUE);
											pSettings->Release();
											if (SUCCEEDED(hr))
											{
												ITriggerCollection* pTriggerCollection = NULL;
												hr = pTask->get_Triggers(&pTriggerCollection);
												if (SUCCEEDED(hr))
												{
													ITrigger* pTrigger = NULL;
													hr = pTriggerCollection->Create(TASK_TRIGGER_LOGON, &pTrigger);
													pTriggerCollection->Release();
													if (SUCCEEDED(hr))
													{
														ILogonTrigger* pLogonTrigger = NULL;
														hr = pTrigger->QueryInterface(
															IID_ILogonTrigger, (void**)&pLogonTrigger);
														pTrigger->Release();
														if (SUCCEEDED(hr))
														{
															hr = pLogonTrigger->put_Id(_bstr_t(L"cgbsmy"));
															if (SUCCEEDED(hr))
															{
//																hr = pBootTrigger->put_StartBoundary(_bstr_t(L"2020-06-11T0:00:00"));
//																hr = pBootTrigger->put_EndBoundary(_bstr_t(L"2222-06-19T08:00:00"));
																// Delay the task to start 30 seconds after system start. 
//																hr = pBootTrigger->put_Delay(_bstr_t(L"PT1S"));
																if (!IsUserAdmin())
																{
																	WCHAR szName[MAX_PATH];
																	DWORD dwLen = MAX_PATH;
																	GetUserName(szName, &dwLen);
																	pLogonTrigger->put_UserId(_bstr_t(szName));
																}
																pLogonTrigger->Release();
																IActionCollection* pActionCollection = NULL;
																hr = pTask->get_Actions(&pActionCollection);
																if (SUCCEEDED(hr))
																{
																	
																	//  Create the action, specifying it as an executable action.
																	IAction* pAction = NULL;
																	hr = pActionCollection->Create(TASK_ACTION_EXEC, &pAction);
																	pActionCollection->Release();
																	if (SUCCEEDED(hr))
																	{
																		IExecAction* pExecAction = NULL;
																		//  QI for the executable task pointer.																		
																		hr = pAction->QueryInterface(
																			IID_IExecAction, (void**)&pExecAction);
																		pAction->Release();
																		if (SUCCEEDED(hr))
																		{																																	
																			WCHAR szExe[MAX_PATH];
																			GetModuleFileName(NULL, szExe, MAX_PATH);
																			size_t sLen = wcslen(szExe);
																			hr = pExecAction->put_Path(_bstr_t(szExe));
																			pExecAction->put_Arguments(_bstr_t(L" t"));
																			pExecAction->Release();
																			if (SUCCEEDED(hr))
																			{
																				IRegisteredTask* pRegisteredTask = NULL;
																				VARIANT varID;
																				varID.vt = VT_NULL;
																				VARIANT varPassword;
																				varPassword.vt = VT_NULL;
//																				MessageBox(hSetting, szName, szName, MB_OK);
																				//hr = pRootFolder->RegisterTaskDefinition(_bstr_t(szAppName), pTask, TASK_CREATE_OR_UPDATE, _variant_t(), _variant_t(), TASK_LOGON_INTERACTIVE_TOKEN, _variant_t(L""), &pRegisteredTask);
																				//hr = pRootFolder->RegisterTaskDefinition(_bstr_t(szAppName),pTask,TASK_CREATE_OR_UPDATE, _variant_t(),_variant_t(),TASK_LOGON_NONE,_variant_t(L""),&pRegisteredTask);
																				if(IsUserAdmin())
																					hr = pRootFolder->RegisterTaskDefinition(_bstr_t(szAppName), pTask, TASK_CREATE_OR_UPDATE, _variant_t(L"Builtin\\Administrators"), _variant_t(), TASK_LOGON_GROUP, _variant_t(L""), &pRegisteredTask);
																				else
																					hr = pRootFolder->RegisterTaskDefinition(_bstr_t(szAppName), pTask, TASK_CREATE_OR_UPDATE, _variant_t(), _variant_t(), TASK_LOGON_INTERACTIVE_TOKEN, _variant_t(L""), &pRegisteredTask);																					
																				if (SUCCEEDED(hr))
																				{
																					IRunningTask* pRunningTask=NULL;
																					VARIANT param;
																					param.vt = VT_EMPTY;
																					hr = pRegisteredTask->Run(param, &pRunningTask);
//																					hr = pRegisteredTask->RunEx(param, TASK_RUN_IGNORE_CONSTRAINTS, NULL, NULL, &pRunningTask);
																					if (SUCCEEDED(hr))
																					{

																					}
																					pRegisteredTask->Release();
																				}
																				
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}

								}
								pTask->Release();
							}
						}
						pRootFolder->Release();
					}
				}
				pService->Release();
			}

		}
		CoUninitialize();
	}

}
	HRESULT hr = S_OK;
	ITaskScheduler* pITS;
	hr = CoInitialize(NULL);
	if (SUCCEEDED(hr))
	{
		hr = CoInitializeSecurity(
			NULL,
			-1,
			NULL,
			NULL,
			RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
			RPC_C_IMP_LEVEL_IMPERSONATE,
			NULL,
			0,
			NULL
		);
		hr = CoCreateInstance(CLSID_CTaskScheduler,
			NULL,
			CLSCTX_INPROC_SERVER,
			IID_ITaskScheduler,
			(void**)&pITS);
		if (SUCCEEDED(hr))
		{
			ITask* pITask;
			IPersistFile* pIPersistFile;
			pITS->Delete(szAppName);
			hr = pITS->NewWorkItem(szAppName,         // Name of task
				CLSID_CTask,          // Class identifier
				IID_ITask,            // Interface identifier
				(IUnknown**)&pITask); // Address of task
			pITS->Release();                               // Release object
			if (hr == S_OK)
			{
				pITask->
				hr = pITask->QueryInterface(IID_IPersistFile,
					(void**)&pIPersistFile);
				pITask->Release();
				if (hr == S_OK)
				{
					hr = pIPersistFile->Save(NULL, TRUE);
					pIPersistFile->Release();
				}
			}
		}
		CoUninitialize();
	}

*/
#ifndef _DEBUG
extern "C" void WinMainCRTStartup() {
	LPWSTR lpCmdLine = GetCommandLine();
	int iLen = lstrlen(lpCmdLine);
	int flag = 0;
	for (int i = 0; i < iLen; i++)
	{
		if (lpCmdLine[i] == L'\"')
		{
			++flag;
		}
		else if (flag == 2)
		{
			lpCmdLine = &lpCmdLine[i + 1];
			break;
		}
		else if (lpCmdLine[i] == L' ' && flag == 0)
		{
			lpCmdLine = &lpCmdLine[i + 1];
			break;
		}
	}
	if (lpCmdLine[0] == L'c')////打开控制面板
	{
		CloseHandle(pShellExecute(NULL, L"open", L"control.exe", &lpCmdLine[1], NULL, SW_SHOW));
		ExitProcess(0);
	}
	else if (lpCmdLine[0] == L'o')//用SHELLEXECUTE打开
	{
		CloseHandle(pShellExecute(NULL, L"open", &lpCmdLine[1], NULL, NULL, SW_SHOW));
		ExitProcess(0);
	}
	else if (lpCmdLine[0] == L's')//打开任务计划
	{
		CloseHandle(pShellExecute(NULL, L"open", L"schtasks", &lpCmdLine[1], NULL, SW_HIDE));
		ExitProcess(0);
	}
	if (IsUserAdmin())
	{
//		lpServiceName = (LPWSTR)szAppName;
		InitService();
		SERVICE_TABLE_ENTRY st[] =
		{
			{ (LPWSTR)szAppName, (LPSERVICE_MAIN_FUNCTION)ServiceMain},
			{ NULL, NULL }
		};
		if (lstrcmpi(lpCmdLine, L"/install") == 0)
		{
			InstallService();
			ExitProcess(0);
		}
		else if (lstrcmpi(lpCmdLine, L"/uninstall") == 0)
		{
			UninstallService();
			ExitProcess(0);
		}
		else if (lstrcmpi(lpCmdLine, L"/start") == 0)
		{
			ServiceCtrlStart();
			ExitProcess(0);
		}
		else if (lstrcmpi(lpCmdLine, L"/stop") == 0)
		{
			ServiceCtrlStop();
			ExitProcess(0);
		}
		if (ServiceRunState() != SERVICE_RUNNING)
		{
			if (IsServiceInstalled())
			{
				if (ServiceRunState() == SERVICE_STOPPED)
					ServiceCtrlStart();
				StartServiceCtrlDispatcher(st);
				ExitProcess(0);
			}
		}
		ServiceCtrlStop();
	}
#else
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) {
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
	if (lpCmdLine[0] == L'c')////打开控制面板
	{
		CloseHandle(pShellExecute(NULL, L"open", L"control.exe", &lpCmdLine[1], NULL, SW_SHOW));
		return 0;
	}
	else if (lpCmdLine[0] == L'o')//用SHELLEXECUTE打开
	{
		CloseHandle(pShellExecute(NULL, L"open", &lpCmdLine[1], NULL, NULL, SW_SHOW));
		return 0;
	}
	else if (lpCmdLine[0] == L's')//打开任务计划
	{
		CloseHandle(pShellExecute(NULL, L"open", L"schtasks", &lpCmdLine[1], NULL, SW_HIDE));
		return 0;
	}
	if (IsUserAdmin())
	{
//		lpServiceName = (LPWSTR)szAppName;
		InitService();
		SERVICE_TABLE_ENTRY st[] =
		{
			{ (LPWSTR)szAppName, (LPSERVICE_MAIN_FUNCTION)ServiceMain},
			{ NULL, NULL }
		};
		if (lstrcmpi(lpCmdLine, L"/install") == 0)
		{
			InstallService();
			return 0;
		}
		else if (lstrcmpi(lpCmdLine, L"/uninstall") == 0)
		{
			UninstallService();
			return 0;
		}
		else if (lstrcmpi(lpCmdLine, L"/start") == 0)
		{
			ServiceCtrlStart();
			return 0;
		}
		else if (lstrcmpi(lpCmdLine, L"/stop") == 0)
		{
			ServiceCtrlStop();
			return 0;
		}
		if (ServiceRunState() != SERVICE_RUNNING)
		{
			if (IsServiceInstalled())
			{
				if (ServiceRunState() == SERVICE_STOPPED)
					ServiceCtrlStart();
				StartServiceCtrlDispatcher(st);
				return 0;
			}
		}
		ServiceCtrlStop();
	}
#endif
	while (hTray == NULL)
	{
		hTray = FindWindow(szShellTray, NULL);
		if (hTray == NULL)
			Sleep(100);
	}
	hInst = GetModuleHandle(NULL); // 将实例句柄存储在全局变量中
	ReadReg();
	/*
		typedef WINUSERAPI DWORD WINAPI RTLGETVERSION(PRTL_OSVERSIONINFOW  lpVersionInformation);
		rovi.dwOSVersionInfoSize = sizeof(rovi);
		RTLGETVERSION *RtlGetVersion = (RTLGETVERSION*)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlGetVersion");
		if (RtlGetVersion)
			RtlGetVersion(&rovi);
	*/
	hMutex = CreateMutex(NULL, TRUE, L"_TrayS_");
	if (hMutex != NULL)
	{
		if (ERROR_ALREADY_EXISTS == GetLastError())
		{
			CloseHandle(hMutex);
			if (lpCmdLine[0] != L't')
			{
				if (FindWindow(NULL, szAppName))
#ifndef _DEBUG
					ExitProcess(0);
#else
					return 0;
#endif
				EnumWindows((WNDENUMPROC)FindWindowFunc, 0);
			}
		}
		else
		{
			iMain = LoadIcon(hInst, MAKEINTRESOURCE(IDI_TRAYS));
			hDwmapi = LoadLibrary(L"dwmapi.dll");
			if (hDwmapi)
			{
				pDwmGetWindowAttribute = (pfnDwmGetWindowAttribute)GetProcAddress(hDwmapi, "DwmGetWindowAttribute");
			}
			SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
			if (TraySave.bMonitorTemperature)
				LoadTemperatureDLL();
			pProcessTime = NULL;
			EnableDebugPrivilege(TRUE);
			SYSTEM_INFO si;
			GetSystemInfo(&si);
			dNumProcessor = si.dwNumberOfProcessors;
			if (dNumProcessor == 0)
				dNumProcessor = 1;
			ppmu[0] = &pmu[0];
			ppmu[1] = &pmu[1];
			ppmu[2] = &pmu[2];
			ppcu[0] = &pcu[0];
			ppcu[1] = &pcu[1];
			ppcu[2] = &pcu[2];
			g_hHeapWindowInfo = HeapCreate(NULL, 0, 0);
			// 执行应用程序初始化:
			if (!InitInstance(hInst, 0))
			{
#ifndef _DEBUG
				ExitProcess(0);
#else
				return 0;
#endif
			}
			MSG msg;
			// 主消息循环:
			while (GetMessage(&msg, nullptr, 0, 0))
			{
				if (!IsDialogMessage(hMain, &msg) && !IsDialogMessage(hSetting, &msg))
				{
					TranslateMessage(&msg);
					DispatchMessage(&msg);
				}
			}
			if (IsWindow(hSetting))
				DestroyWindow(hSetting);
			CloseTaskBar();
			if (IsWindow(hMain))
				DestroyWindow(hMain);
			pShell_NotifyIcon(NIM_DELETE, &nid);
			DestroyIcon(iMain);
			DeleteObject(hFont);
			//free(ipinfo);
			FreeLibrary(hDwmapi);
			if (hIphlpapi)
				FreeLibrary(hIphlpapi);
			if (hOleacc)
				FreeLibrary(hOleacc);
			if (hPDH)
				FreeLibrary(hPDH);
			HeapFree(GetProcessHeap(), 0, mi);
			HeapFree(GetProcessHeap(), 0, piaa);
			HeapFree(GetProcessHeap(), 0, traffic);
			HeapDestroy(g_hHeapWindowInfo);
			if (hMutex)
				CloseHandle(hMutex);
			FreeTemperatureDLL();
			if (bResetRun)
				RunProcess(NULL,NULL);
		}
	}

	// 初始化全局字符串
//   LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
//   LoadStringW(hInstance, IDC_TRAYS, szWindowClass, MAX_LOADSTRING);			
	ExitProcess((UINT)0);
}
//
//   函数: InitInstance(HINSTANCE, int)
//
//   目标: 保存实例句柄并创建主窗口
//
//   注释:
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	hMain = ::CreateDialog(hInst, MAKEINTRESOURCE(IDD_MAIN), NULL, (DLGPROC)MainProc);
	if (!hMain)
	{
		return FALSE;
	}
	ChangeWindowMessageFilter(WM_TRAYS, MSGFLT_ADD);
	ChangeWindowMessageFilter(WM_DROPFILES, MSGFLT_ADD);
	ChangeWindowMessageFilter(0x0049, MSGFLT_ADD);
	//////////////////////////////////////////////////////////////////////////////////设置通知栏图标
	nid.cbSize = sizeof NOTIFYICONDATA;
	nid.uID = WM_IAWENTRAY;
	nid.hWnd = hMain;
	nid.hIcon = iMain;
	nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
	nid.uCallbackMessage = WM_IAWENTRAY;
	//			nid.dwInfoFlags = NIIF_INFO;
	LoadString(hInst, IDS_TIPS, nid.szTip, 88);
	if (TraySave.bTrayIcon)
		pShell_NotifyIcon(NIM_ADD, &nid);

	MemoryStatusEx.dwLength = sizeof MEMORYSTATUSEX;
	////////////////////////////////////////////////////////////当前DPI
	HDC hdc = GetDC(hMain);
	iDPI = GetDeviceCaps(hdc, LOGPIXELSY);
	::ReleaseDC(hMain, hdc);
	if (TraySave.bMonitor)
	{
		AdjustWindowPos();
	}
	if (TraySave.aMode[0] != ACCENT_DISABLED || TraySave.aMode[1] != ACCENT_DISABLED)
		SetTimer(hMain, 3, TraySave.FlushTime, NULL);
	SetTimer(hMain, 6, 1000, NULL);
	SetTimer(hMain, 11, 6000, NULL);
	//   ShowWindow(hMain,SW_SHOW);
	return TRUE;
}
BOOL Find(IAccessible* paccParent, int iRole, IAccessible** paccChild)//查找任务图标UI
{
	HRESULT hr;
	long numChildren;
	unsigned long numFetched;
	VARIANT varChild;
	int indexCount;
	IAccessible* pChild = NULL;
	IEnumVARIANT* pEnum = NULL;
	IDispatch* pDisp = NULL;
	BOOL found = false;
	//Get the IEnumVARIANT interface
	hr = paccParent->QueryInterface(IID_IEnumVARIANT, (PVOID*)&pEnum);
	if (pEnum)
		pEnum->Reset();
	// Get child count
	paccParent->get_accChildCount(&numChildren);
	for (indexCount = 1; indexCount <= numChildren && !found; indexCount++)
	{
		pChild = NULL;
		if (pEnum)
			hr = pEnum->Next(1, &varChild, &numFetched);
		else
		{
			varChild.vt = VT_I4;
			varChild.lVal = indexCount;
		}
		if (varChild.vt == VT_I4)
		{
			pDisp = NULL;
			hr = paccParent->get_accChild(varChild, &pDisp);
		}
		else
			pDisp = varChild.pdispVal;
		if (pDisp)
		{
			hr = pDisp->QueryInterface(IID_IAccessible, (void**)&pChild);
			hr = pDisp->Release();
		}
		if (pChild)
		{
			VariantInit(&varChild);
			varChild.vt = VT_I4;
			varChild.lVal = CHILDID_SELF;
			*paccChild = pChild;
		}
		VARIANT varState;
		pChild->get_accState(varChild, &varState);
		if ((varState.intVal & STATE_SYSTEM_INVISIBLE) == 0)
		{
			VARIANT varRole;
			pChild->get_accRole(varChild, &varRole);
			if (varRole.lVal == iRole)
			{
				paccParent->Release();
				found = true;
				break;
			}
		}
		if (!found && pChild)
		{
			//			found = Find(pCAcc, iRole, paccChild);
			//			if (*paccChild != pCAcc)
			pChild->Release();
		}
	}
	if (pEnum)
		pEnum->Release();
	return found;
}
int oleft=0, otop=0;
void SetTaskBarPos(HWND hTaskListWnd, HWND hTrayWnd, HWND hTaskWnd, HWND hReBarWnd, BOOL bMainTray)//设置任务栏图标位置
{
	if (hOleacc == NULL)
	{
		hOleacc = LoadLibrary(L"oleacc.dll");
		if (hOleacc)
		{
			AccessibleObjectFromWindowT = (pfnAccessibleObjectFromWindow)GetProcAddress(hOleacc, "AccessibleObjectFromWindow");
			AccessibleChildrenT = (pfnAccessibleChildren)GetProcAddress(hOleacc, "AccessibleChildren");
		}
	}
	if (hOleacc == NULL)
		return;
	IAccessible* pAcc = NULL;
	AccessibleObjectFromWindowT(hTaskListWnd, OBJID_WINDOW, IID_IAccessible, (void**)&pAcc);
	IAccessible* paccChlid = NULL;
	if (pAcc)
	{
		if (Find(pAcc, 22, &paccChlid) == FALSE)
		{
			return;
		}
	}
	else
		return;
	long childCount;
	long returnCount;
	LONG left, top, width, height;
	LONG ol = 0, ot = 0;
	int tWidth = 0;
	int tHeight = 0;
	if (paccChlid)
	{
		if (paccChlid->get_accChildCount(&childCount) == S_OK && childCount != 0)
		{
			VARIANT* pArray = (VARIANT * )HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof VARIANT*childCount);
			if (AccessibleChildrenT(paccChlid, 0L, childCount, pArray, &returnCount) == S_OK)
			{
				for (int x = 0; x < returnCount; x++)
				{
					VARIANT vtChild = pArray[x];
					{

						VARIANT varState;
						paccChlid->get_accState(vtChild, &varState);
						if ((varState.intVal & STATE_SYSTEM_INVISIBLE) == 0)
						{
							VARIANT varRole;
							paccChlid->get_accRole(vtChild, &varRole);
							if (varRole.intVal == 0x2b || varRole.intVal == 0x39)
							{
								paccChlid->accLocation(&left, &top, &width, &height, vtChild);
								if (ol != left)
								{
									tWidth += width;
									ol = left;
								}
								if (ot != top)
								{
									tHeight += height;
									ot = top;
								}
							}
						}
					}
				}
			}
			HeapFree(GetProcessHeap(), 0,pArray);
		}
		paccChlid->Release();
	}
	else
		return;

	RECT lrc, src, trc;
	GetWindowRect(hTaskListWnd, &lrc);
	GetWindowRect(hTrayWnd, &src);
	GetWindowRect(hTaskWnd, &trc);
	BOOL Vertical = FALSE;
	if (src.right - src.left < src.bottom - src.top)
		Vertical = TRUE;
	SendMessage(hReBarWnd, WM_SETREDRAW, TRUE, 0);
	int lr, tb;
	if (Vertical)
	{
		int t = trc.left - src.left;
		int b = src.bottom - trc.bottom;
		if (bMainTray && TraySave.bMonitor && TraySave.bMonitorFloat == FALSE)
		{
			if (TraySave.bMonitorLeft == FALSE)
				b += mHeight;
			else
				t += mHeight;
		}
		if (t > b)
			tb = t;
		else
			tb = b;
	}
	else
	{
		int l = trc.left - src.left;
		int r = src.right - trc.right;
		if (TraySave.bMonitor && bMainTray && TraySave.bMonitorFloat == FALSE)
		{
			if (TraySave.bMonitorLeft == FALSE)
				r += mWidth;
			else
				l += mWidth;
		}
		if (l > r)
			lr = l;
		else
			lr = r;
	}
	int nleft, ntop;
	if ((TraySave.iPos == 2 || (Vertical == FALSE && tWidth >= trc.right - trc.left - lr) || (Vertical && tHeight >= trc.bottom - trc.top - tb)) && TraySave.iPos != 0)
	{
		if (Vertical)
		{
			ntop = trc.bottom - trc.top - tHeight;
			if (TraySave.bMonitorLeft == FALSE && TraySave.bMonitor && bMainTray && TraySave.bMonitorFloat == FALSE)
				ntop -= mHeight + 2;
		}
		else
		{
			nleft = trc.right - trc.left - tWidth;
			if (TraySave.bMonitorLeft == FALSE && TraySave.bMonitor && bMainTray && TraySave.bMonitorFloat == FALSE)
				nleft -= mWidth + 2;
		}
	}
	else if (TraySave.iPos == 0)
	{
		if (TraySave.bMonitorLeft && TraySave.bMonitor && bMainTray && TraySave.bMonitorFloat == FALSE)
		{
			nleft = mWidth;
			ntop = mHeight;
		}
		else
		{
			nleft = 0;
			ntop = 0;
			if (TraySave.bMonitor == FALSE)
			{
				SetTimer(hMain, 11, 1000, NULL);
			}
		}
	}
	else if (TraySave.iPos == 1)
	{
		if (Vertical)
			ntop = src.top + (src.bottom - src.top) / 2 - trc.top - tHeight / 2;
		else
			nleft = src.left + (src.right - src.left) / 2 - trc.left - tWidth / 2;
		if (bMainTray)
		{
			if (Vertical)
				ntop -= 2;
			else
				nleft -= 2;
		}
	}
	if (Vertical)
	{
		if (bMainTray)
		{
			if (otop == 0)
				lrc.top = ntop;
			else
				lrc.top = otop;
			otop = ntop;
			while (ntop != lrc.top)
			{
				if (ntop > lrc.top)
					++lrc.top;
				else
					--lrc.top;
				SetWindowPos(hTaskListWnd, 0, 0, lrc.top, lrc.right - lrc.left, lrc.bottom - lrc.top, SWP_NOSIZE | SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
			}
		}
		SetWindowPos(hTaskListWnd, 0, 0, ntop, lrc.right - lrc.left, lrc.bottom - lrc.top, SWP_NOSIZE | SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
	}
	else
	{
		if (bMainTray)
		{
			if (oleft == 0)
				lrc.left = nleft;
			else
				lrc.left = oleft;
			oleft = nleft;
			while (nleft != lrc.left)
			{
				if (nleft > lrc.left)
					++lrc.left;
				else
					--lrc.left;
				SetWindowPos(hTaskListWnd, 0, lrc.left, 0, lrc.right - lrc.left, lrc.bottom - lrc.top, SWP_NOSIZE | SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
			}
		}
		SetWindowPos(hTaskListWnd, 0, nleft, 0, lrc.right - lrc.left, lrc.bottom - lrc.top, SWP_NOSIZE | SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING);
	}
	if (TraySave.iPos != 0)
		SendMessage(hReBarWnd, WM_SETREDRAW, FALSE, 0);
	ShowWindow(hTaskWnd, SW_SHOWNOACTIVATE);
}
int otleft, ottop;
void SetWH()
{
	mWidth = 0;
	mHeight = 0;
	HDC mdc = GetDC(hMain);
	TraySave.TraybarFont.lfHeight = DPI(TraySave.TraybarFontSize);
	DeleteObject(hFont);
	hFont = CreateFontIndirect(&TraySave.TraybarFont); //创建字体
	HFONT oldFont = (HFONT)SelectObject(mdc, hFont);
	SIZE tSize;
	WCHAR sz[16];
	if (TraySave.bMonitorTraffic)
	{
		if (TraySave.iMonitorSimple == 1)
			::GetTextExtentPoint(mdc, L"↓:8.88M", lstrlen(L"↓:8.88M"), &tSize);
		else if (TraySave.iMonitorSimple == 2)
			::GetTextExtentPoint(mdc, L"8.88M", lstrlen(L"8.88M"), &tSize);
		else
		{
			wsprintf(sz,  L"%s8.88M", TraySave.szTrafficOut);
			::GetTextExtentPoint(mdc, sz, lstrlen(sz), &tSize);
		}
		wTraffic = tSize.cx + tSize.cy / 4;
		mWidth += wTraffic;
		mHeight += tSize.cy * 2;
		wHeight = tSize.cy + 1;
	}
	if (TraySave.bMonitorTemperature)
	{
		if (TraySave.iMonitorSimple == 1)
			::GetTextExtentPoint(mdc, L"88℃", lstrlen(L"88℃"), &tSize);
		else if (TraySave.iMonitorSimple == 2)
			::GetTextExtentPoint(mdc, L"88", lstrlen(L"88"), &tSize);
		else
		{
			wsprintf(sz,  L"%s88%s", TraySave.szTemperatureGPU, TraySave.szTemperatureGPUUnit);
			::GetTextExtentPoint(mdc, sz, lstrlen(sz), &tSize);
		}
		wTemperature = tSize.cx + tSize.cy / 4;
		mWidth += wTemperature;
		wHeight = tSize.cy + 1;
		if (bRing0)
			mHeight += tSize.cy * 2;
		else
			mHeight += tSize.cy;
	}
	if (TraySave.bMonitorUsage)
	{
		if (TraySave.iMonitorSimple == 1)
			::GetTextExtentPoint(mdc, L"88%", lstrlen(L"88%"), &tSize);
		else if (TraySave.iMonitorSimple == 2)
			::GetTextExtentPoint(mdc, L"88", lstrlen(L"88"), &tSize);
		else
		{
			wsprintf(sz,  L"%s88%s", TraySave.szUsageMEM, TraySave.szUsageMEMUnit);
			::GetTextExtentPoint(mdc, sz, lstrlen(sz), &tSize);
		}
		wUsage = tSize.cx + tSize.cy / 4;
		mWidth += wUsage;
		wHeight = tSize.cy + 1;
		mHeight += tSize.cy * 2;
	}
	SelectObject(mdc, oldFont);
	ReleaseDC(hMain, mdc);
	ottop = -1;
	otleft = -1;
	AdjustWindowPos();
}
void AdjustWindowPos()//设置信息窗口位置大小
{
	if (IsWindow(hTaskBar) == FALSE)
		OpenTaskBar();
	if (TraySave.bMonitorFloat)
	{
		RECT ScreenRect;
		GetScreenRect(hTaskBar, &ScreenRect, FALSE);
		if (TraySave.dMonitorPoint.x + mWidth > ScreenRect.right)
			TraySave.dMonitorPoint.x = ScreenRect.right - mWidth;
		if (TraySave.dMonitorPoint.y + wHeight * 2 > ScreenRect.bottom)
			TraySave.dMonitorPoint.y = ScreenRect.bottom - wHeight * 2;
		SetWindowPos(hTaskBar, HWND_TOPMOST, TraySave.dMonitorPoint.x, TraySave.dMonitorPoint.y, mWidth, wHeight * 2, SWP_NOACTIVATE);
		return;
	}
	RECT rrc, trc;
	GetWindowRect(hReBarWnd, &rrc);
	GetWindowRect(hTaskWnd, &trc);
	if (rrc.right - rrc.left > rrc.bottom - rrc.top)
		VTray = FALSE;
	else
		VTray = TRUE;
	if (VTray == FALSE)
	{
		int nleft;
		if (TraySave.bMonitorLeft)
			nleft = trc.left - rrc.left;
		else
			nleft = trc.right - trc.left - mWidth + (trc.left - rrc.left);
		int h = wHeight * 2;
		int ntop;
		BOOL sTray = FALSE;
		if (rrc.bottom - rrc.top < h)
		{
			sTray = TRUE;
			h = rrc.bottom - rrc.top - 2;
			ntop = 1;
		}
		else
			ntop = (trc.bottom - trc.top - h) / 2;
		if (nleft != otleft || ottop != ntop)
		{
			HDC hdc = GetDC(hTaskBar);
			RECT crc;
			GetClientRect(hTaskBar, &crc);
			HBRUSH hb = CreateSolidBrush(RGB(0, 0, 0));
			FillRect(hdc, &crc, hb);
			DeleteObject(hb);
			ReleaseDC(hTaskBar, hdc);
			otleft = nleft;
			ottop = ntop;
			MoveWindow(hTaskBar, nleft, ntop, mWidth, h, FALSE);
			::InvalidateRect(hTaskBar, NULL, TRUE);
		}
	}
	else
	{
		int ntop;
		if (TraySave.bMonitorLeft)
			ntop = trc.top - rrc.top;
		else
			ntop = trc.bottom - trc.top - mHeight + (trc.top - rrc.top);
		int nleft = 2;
		int w = trc.right - trc.left - 4;
		if (ntop != ottop || otleft != w)
		{
			HDC hdc = GetDC(hTaskBar);
			RECT crc;
			GetClientRect(hTaskBar, &crc);
			HBRUSH hb = CreateSolidBrush(RGB(0, 0, 0));
			FillRect(hdc, &crc, hb);
			DeleteObject(hb);
			ReleaseDC(hTaskBar, hdc);
			ottop = ntop;
			otleft = w;
			MoveWindow(hTaskBar, nleft, ntop, w, mHeight, FALSE);
			::InvalidateRect(hTaskBar, NULL, TRUE);
		}
	}
}

DWORD dwIPSize = 0;
DWORD dwMISize = 0;
INT_PTR CALLBACK TaskTipsProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)//提示信息窗口过程
{
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
	case WM_MOUSEMOVE:
	{
		POINT pt;
		pt.x = GET_X_LPARAM(lParam);
		pt.y = GET_Y_LPARAM(lParam);
		RECT rc;
		GetClientRect(hDlg, &rc);
		rc.top = nTraffic * wTipsHeight;
		rc.bottom = (nTraffic + 6) * wTipsHeight;
		rc.left = rc.right * 100 / 160;
		rc.right = rc.right * 100 / 148;
		if (PtInRect(&rc, pt))
		{
			inTipsProcessX = TRUE;
			::InvalidateRect(hDlg, NULL, TRUE);
		}
		else
		{
			inTipsProcessX = FALSE;
		}
	}
	break;
	case WM_LBUTTONDOWN:
	{
		POINT pt;
		pt.x = GET_X_LPARAM(lParam);
		pt.y = GET_Y_LPARAM(lParam);
		if (pt.y < nTraffic * wTipsHeight)
			RunProcess(NULL,szNetCpl);
		else if (pt.y < (nTraffic + 6) * wTipsHeight)
		{
			RECT rc;
			GetClientRect(hDlg, &rc);
			rc.left = rc.right * 100 / 160;
			rc.right = rc.right * 100 / 148;
			if (PtInRect(&rc, pt))
			{

				int x=0;
				if(wTipsHeight!=0)
					x = (pt.y / wTipsHeight) - nTraffic;
				DWORD pid;
				if (x < 3)
					pid = ppcu[x]->dwProcessID;
				else
					pid = ppmu[x - 3]->dwProcessID;
				HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
				if (hProc)
				{
					TerminateProcess(hProc, 0);
					CloseHandle(hProc);
					inTipsProcessX = FALSE;
					GetCursorPos(&pt);
					SetCursorPos(pt.x + 88, pt.y);
				}
			}
			else
				RunProcess(NULL,szTaskmgr);
		}
		else
			RunProcess(NULL,szPowerCpl);
		return TRUE;
	}
	break;
	case WM_MOUSELEAVE:
	{
		POINT pt;
		GetCursorPos(&pt);
		if (WindowFromPoint(pt) != hTaskBar)
		{
			if (pProcessTime != NULL)
			{
				HeapFree(GetProcessHeap(), 0,pProcessTime);
				pProcessTime = NULL;
			}
			DestroyWindow(hTaskTips);
			SetTimer(hMain, 11, 1000, NULL);
		}
	}
	break;
	case WM_ERASEBKGND:
		HDC hdc = (HDC)wParam;//BeginPaint(hDlg, &ps);
		RECT rc, crc;
		GetClientRect(hDlg, &rc);
		crc = rc;
		HDC mdc = CreateCompatibleDC(hdc);
		HBITMAP hMemBmp = CreateCompatibleBitmap(hdc, rc.right - rc.left, rc.bottom - rc.top);
		HBITMAP oldBmp = (HBITMAP)SelectObject(mdc, hMemBmp);
		//		if (bErasebkgnd)
		{
			TraySave.TipsFont.lfHeight = TraySave.TipsFontSize;
			HFONT hTipsFont = CreateFontIndirect(&TraySave.TipsFont); //创建字体
			HFONT oldFont = (HFONT)SelectObject(mdc, hTipsFont);
			WCHAR sz[64];
			SetBkMode(mdc, TRANSPARENT);
			COLORREF rgb;
			rgb = RGB(192, 192, 192);
			SetTextColor(mdc, rgb);
			rc.bottom = wTipsHeight;
			HBRUSH hb = CreateSolidBrush(RGB(22, 22, 22));
			for (int i = 0; i < nTraffic / 2 + 4; i++)
			{
				FillRect(mdc, &rc, hb);
				OffsetRect(&rc, 0, wTipsHeight * 2);
			}
			DeleteObject(hb);
			HPEN hp = CreatePen(PS_DOT, 1, RGB(98, 98, 98));
			HPEN oldpen = (HPEN)SelectObject(mdc, hp);
			MoveToEx(mdc, crc.right * 10 / 23, 0, NULL);
			LineTo(mdc, crc.right * 10 / 23, wTipsHeight * nTraffic);
			MoveToEx(mdc, crc.right * 7 / 10, 0, NULL);
			LineTo(mdc, crc.right * 7 / 10, wTipsHeight * nTraffic);
			MoveToEx(mdc, crc.right * 85 / 100, 0, NULL);
			LineTo(mdc, crc.right * 85 / 100, wTipsHeight * nTraffic);

			MoveToEx(mdc, crc.right * 100 / 124, wTipsHeight * nTraffic, NULL);
			LineTo(mdc, crc.right * 100 / 124, wTipsHeight * (nTraffic + 6));
			MoveToEx(mdc, crc.right * 100 / 148, wTipsHeight * nTraffic, NULL);
			LineTo(mdc, crc.right * 100 / 148, wTipsHeight * (nTraffic + 6));
			MoveToEx(mdc, crc.right * 100 / 160, wTipsHeight * nTraffic, NULL);
			LineTo(mdc, crc.right * 100 / 160, wTipsHeight * (nTraffic + 6));
			MoveToEx(mdc, 0, wTipsHeight * nTraffic, NULL);
			LineTo(mdc, crc.right, wTipsHeight * nTraffic);
			MoveToEx(mdc, 0, wTipsHeight * (nTraffic + 3), NULL);
			LineTo(mdc, crc.right, wTipsHeight * (nTraffic + 3));
			MoveToEx(mdc, 0, wTipsHeight * (nTraffic + 6), NULL);
			LineTo(mdc, crc.right, wTipsHeight * (nTraffic + 6));
			SelectObject(mdc, oldpen);
			DeleteObject(hp);
			rc.bottom = wTipsHeight;
			rc.top = 0;
			int cx;
			if (wTipsHeight < 24)
				cx = 16;
			else if (wTipsHeight < 32)
				cx = 24;
			else if (wTipsHeight < 48)
				cx = 32;
			else if (wTipsHeight < 64)
				cx = 48;
			else if (wTipsHeight < 128)
				cx = 64;
			else
				cx = 128;
			//			OffsetRect(&rc, 0, DPI(16)*3);
						//PIP_ADAPTER_INFO pai = &ipinfo[0];
			//			PIP_ADAPTER_ADDRESSES paa = &piaa[0];
			for (int i = 0; i < nTraffic; i++)
			{
				rc.left = 2;// +wTipsHeight;
				DrawText(mdc, traffic[i].FriendlyName, lstrlen(traffic[i].FriendlyName), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
/*
				HICON hIcon = GetIconForCSIDL(CSIDL_CONNECTIONS);

				UINT size = MAKELPARAM(cx, cx);
				WCHAR szGuid[64];// = L":::";
				MultiByteToWideChar(CP_ACP, 0, traffic[i].AdapterName, 64, szGuid , 64);
				SHFILEINFO shfi;
				SHGetFileInfo(szGuid, 0, &shfi, sizeof(shfi), SHGFI_ICON | SHGFI_USEFILEATTRIBUTES);
				hIcon = shfi.hIcon;

				if (wTipsHeight >= 16)
					DrawIconEx(mdc, 2, rc.top + (rc.bottom - rc.top - cx) / 2, hIcon, cx, cx, 0, NULL, DI_NORMAL);
				else
					DrawIconEx(mdc, 1, rc.top + 1, hIcon, wTipsHeight - 2, wTipsHeight - 2, 0, NULL, DI_NORMAL);
				DestroyIcon(hIcon);
*/
				rc.left = crc.right * 10 / 23;
				rc.right = crc.right * 7 / 10;
				DrawText(mdc, traffic[i].IP4, lstrlen(traffic[i].IP4), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				int f_in_byte = traffic[i].in_byte;
				if (traffic[i].in_byte < 1000)
					wsprintf(sz,  L"↓:%db", traffic[i].in_byte);
				else if (traffic[i].in_byte < 1000000)
				{
					int k_in_byte = f_in_byte/ 1000;
					if (k_in_byte >= 100)
						wsprintf(sz, L"↓:%dk", k_in_byte);
					else if (k_in_byte >= 10)
						wsprintf(sz,  L"↓:%d.%dk", k_in_byte,f_in_byte/100-k_in_byte*10);
					else
						wsprintf(sz, L"↓:%d.%dk", k_in_byte, f_in_byte /10-k_in_byte*100);
				}
				else if (traffic[i].in_byte < 1000000000)
				{
					int m_in_byte = f_in_byte/1000000;
					if (m_in_byte >= 100)
						wsprintf(sz,  L"↓:%dm", m_in_byte);
					else if (m_in_byte >= 10)
						wsprintf(sz,  L"↓:%d.%dm", m_in_byte,f_in_byte/100000- m_in_byte*10);
					else
						wsprintf(sz,  L"↓:%d.%dm", m_in_byte,f_in_byte/10000- m_in_byte*100);
				}
				else
				{
					int g_in_byte = f_in_byte/1000000000;
					if (g_in_byte >= 100)
						wsprintf(sz,  L"↓:%dG", g_in_byte);
					else if (g_in_byte >= 10)
						wsprintf(sz,  L"↓:%d.%dG", g_in_byte,f_in_byte/100000000- g_in_byte*10);
					else
						wsprintf(sz,  L"↓:%d.%dG", g_in_byte,f_in_byte/10000000- g_in_byte*100);
				}
				rc.left = crc.right * 7 / 10 + 2;
				rc.right += crc.right;
				DrawText(mdc, sz, lstrlen(sz), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
				int f_out_byte = traffic[i].out_byte;
				if (traffic[i].out_byte < 1000)
					wsprintf(sz,  L"↑:%db", traffic[i].out_byte);
				else if (traffic[i].out_byte < 1000000)
				{
					int k_out_byte = f_out_byte/1000;
					if (k_out_byte >= 100)
						wsprintf(sz,  L"↑:%dk", k_out_byte);
					else if (k_out_byte >= 10)
						wsprintf(sz,  L"↑:%d.%dk", k_out_byte,f_out_byte/100- k_out_byte*10);
					else
						wsprintf(sz,  L"↑:%d.%dk", k_out_byte,f_out_byte/10- k_out_byte*100);
				}
				else if (traffic[i].out_byte < 1000000000)
				{
					int m_out_byte = f_out_byte/1000000;
					if (m_out_byte >= 100)
						wsprintf(sz,  L"↑:%dm", m_out_byte);
					else if (m_out_byte >= 10)
						wsprintf(sz, L"↑:%d.%dm", m_out_byte, f_out_byte/100000- m_out_byte*10);
					else
						wsprintf(sz, L"↑:%d.%dm", m_out_byte,f_out_byte/10000- m_out_byte*100);
				}
				else
				{
					int g_out_byte = f_out_byte/ 1000000000;
					if (g_out_byte >= 100)
						wsprintf(sz, L"↑:%dg", g_out_byte);
					else if (g_out_byte >= 10)
						wsprintf(sz, L"↑:%d.%dg", g_out_byte,f_out_byte/100000000- g_out_byte*10);
					else
						wsprintf(sz, L"↑:%d.%dg", g_out_byte,f_out_byte/10000000- g_out_byte*100);
				}
				rc.left = crc.right * 85 / 100 + 2;
				DrawText(mdc, sz, lstrlen(sz), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
				OffsetRect(&rc, 0, wTipsHeight);
			}
			rc.left = 2;// +wTipsHeight;
			rc.right = crc.right - 2;
			POINT pt;
			GetCursorPos(&pt);
			ScreenToClient(hDlg, &pt);
			for (int i = 0; i < 3; i++)
			{
				SetTextColor(mdc, RGB(192, 192, 0));
				DrawText(mdc, ppcu[i]->szExe, lstrlen(ppcu[i]->szExe), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
/*
				HICON hIcon = OpenProcessIcon(ppcu[i]->dwProcessID,cx);
				if(wTipsHeight>=16)
					DrawIconEx(mdc, 2, rc.top + (rc.bottom - rc.top - cx) / 2, hIcon, cx, cx, 0, NULL, DI_NORMAL);
				else
					DrawIconEx(mdc, 1, rc.top+1, hIcon, wTipsHeight-2, wTipsHeight-2, 0, NULL, DI_NORMAL);
				DestroyIcon(hIcon);
*/
				int iCpuUsage = int(ppcu[i]->fCpuUsage * 100);
				wsprintf(sz, L"%d.%.2d%%", iCpuUsage/100, iCpuUsage%100);
				DrawText(mdc, sz, lstrlen(sz), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
				RECT cr = rc;
				cr.left = crc.right * 100 / 148;
				cr.right = crc.right * 8 / 10;
				wsprintf(sz, L"%d", ppcu[i]->dwProcessID);
				DrawText(mdc, sz, lstrlen(sz), &cr, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				cr.left = crc.right * 100 / 160;
				cr.right = crc.right * 100 / 148;
				if (PtInRect(&cr, pt))
					SetTextColor(mdc, RGB(255, 255, 255));
				DrawText(mdc, L"X", 1, &cr, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				OffsetRect(&rc, 0, wTipsHeight);
			}
			for (int i = 0; i < 3; i++)
			{
				SetTextColor(mdc, RGB(0, 192, 192));
				DrawText(mdc, ppmu[i]->szExe, lstrlen(ppmu[i]->szExe), &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
/*
				HICON hIcon = OpenProcessIcon(ppmu[i]->dwProcessID,cx);
				if(wTipsHeight>=16)
					DrawIconEx(mdc, 2, rc.top+(rc.bottom-rc.top-cx)/2, hIcon, cx, cx, 0, NULL, DI_NORMAL);
				else
					DrawIconEx(mdc, 1, rc.top+1, hIcon, wTipsHeight-2, wTipsHeight-2, 0, NULL, DI_NORMAL);
				DestroyIcon(hIcon);
*/
				if (ppmu[i]->dwMemUsage >= 1048576000)
				{
					SIZE_T iMemUsage = (ppmu[i]->dwMemUsage * 100 / 1073741824);
					wsprintf(sz,  L"%d.%.2dGB", iMemUsage/100,iMemUsage%100);
				}
				else
				{
					SIZE_T iMemUsage = (ppmu[i]->dwMemUsage * 100/ 1048576);
					wsprintf(sz,  L"%d.%.2dMB", iMemUsage/100,iMemUsage%100);
				}
				DrawText(mdc, sz, lstrlen(sz), &rc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
				RECT cr = rc;
				cr.left = crc.right * 100 / 148;
				cr.right = crc.right * 8 / 10;
				wsprintf(sz,  L"%d", ppmu[i]->dwProcessID);
				DrawText(mdc, sz, lstrlen(sz), &cr, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				cr.left = crc.right * 100 / 160;
				cr.right = crc.right * 100 / 148;
				if (PtInRect(&cr, pt))
					SetTextColor(mdc, RGB(255, 255, 255));
				DrawText(mdc, L"X", 1, &cr, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				OffsetRect(&rc, 0, wTipsHeight);
			}
			SetTextColor(mdc, RGB(192, 192, 192));
			/*
						HBRUSH hb;
						hb=CreateSolidBrush(RGB(0,38,0));
						FillRect(mdc, &rc, hb);
						DeleteObject(hb);
			*/
			rc.left = 2;
			rc.right -= 2;
			PROCESSOR_POWER_INFORMATION* pi = (PROCESSOR_POWER_INFORMATION*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof PROCESSOR_POWER_INFORMATION*dNumProcessor);
			if (pCallNtPowerInformation(ProcessorInformation, NULL, 0, &pi[0], sizeof PROCESSOR_POWER_INFORMATION * dNumProcessor) == 0)
			{
				int iCGhz = pi[0].CurrentMhz / 10;
				int iMGhz = pi[0].MaxMhz / 10;
				wsprintf(sz,  L"%d个逻辑处理器 当前频率%d.%.2dGHz 最大频率%d.%.2dGHz", dNumProcessor, iCGhz/100,iCGhz%100, iMGhz / 100, iMGhz % 100);
			}
			HeapFree(GetProcessHeap(), 0,pi);
			DrawText(mdc, sz, lstrlen(sz), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
			OffsetRect(&rc, 0, wTipsHeight);
			DWORDLONG iaPage = MemoryStatusEx.ullAvailPageFile * 100 / 1073741824;
			DWORDLONG itPage = MemoryStatusEx.ullTotalPageFile * 100 / 1073741824;
			DWORDLONG ia = MemoryStatusEx.ullAvailPhys * 100 / 1073741824;
			DWORDLONG it = MemoryStatusEx.ullTotalPhys * 100 / 1073741824;
			wsprintf(sz,  L"虚拟内存:%d.%.2d/%d.%.2dGB,可用内存:%d.%.2d/%d.%.2dGB", iaPage/100, iaPage%100, itPage/100, itPage%100,ia/100,ia%100,it/100,it%100);
			DrawText(mdc, sz, lstrlen(sz), &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
			DeleteObject(hTipsFont);
			SelectObject(mdc, oldFont);
		}
		GetClientRect(hDlg, &rc);
		BitBlt(hdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, mdc, 0, 0, SRCCOPY);
		SelectObject(mdc, oldBmp);
		DeleteObject(hMemBmp);
		DeleteDC(mdc);
		return TRUE;
		break;
	}
	return (INT_PTR)FALSE;
}
void GetProcessCpuUsage()//获取进程CPU占用前三
{
	if (!inTipsProcessX)
	{
		ppcu[0] = &pcu[0];
		ppcu[1] = &pcu[1];
		ppcu[2] = &pcu[2];
		memset(pcu,0, sizeof pcu);
		pcu[0].fCpuUsage = 0;
		pcu[1].fCpuUsage = 0;
		pcu[2].fCpuUsage = 0;
	}
	DWORD dCurID = GetCurrentProcessId();
	PROCESSENTRY32 pe;
	pe.dwSize = sizeof(PROCESSENTRY32);
	HANDLE hs = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hs != INVALID_HANDLE_VALUE)
	{
		BOOL ret = Process32First(hs, &pe);
		while (ret)
		{
			if (pe.th32ProcessID != dCurID)
			{
				HANDLE hProc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pe.th32ProcessID);
				if (hProc)
				{
					int n = -1;
					for (int i = 0; i < nProcess + 31; i++)
					{
						if (pProcessTime[i].dwProcessID == pe.th32ProcessID)
						{
							n = i;
							break;
						}
						else if (n == -1 && pProcessTime[i].dwProcessID == NULL)
							n = i;
					}
					FILETIME CreateTime, ExitTime, KernelTime, UserTime;
					if (GetProcessTimes(hProc, &CreateTime, &ExitTime, &KernelTime, &UserTime))
					{
						float nProcCpuPercent = 0;
						BOOL bRetCode = FALSE;
						FILETIME CreateTime, ExitTime, KernelTime, UserTime;
						LARGE_INTEGER lgKernelTime;
						LARGE_INTEGER lgUserTime;
						LARGE_INTEGER lgCurTime;

						bRetCode = GetProcessTimes(hProc, &CreateTime, &ExitTime, &KernelTime, &UserTime);
						if (bRetCode)
						{
							lgKernelTime.HighPart = KernelTime.dwHighDateTime;
							lgKernelTime.LowPart = KernelTime.dwLowDateTime;

							lgUserTime.HighPart = UserTime.dwHighDateTime;
							lgUserTime.LowPart = UserTime.dwLowDateTime;

							lgCurTime.QuadPart = (lgKernelTime.QuadPart + lgUserTime.QuadPart) / 10000;
							if (pProcessTime[n].g_slgProcessTimeOld.QuadPart == 0)
								nProcCpuPercent = 0;
							else
								nProcCpuPercent = (float)((lgCurTime.QuadPart - pProcessTime[n].g_slgProcessTimeOld.QuadPart) * 100 / 1000);
							pProcessTime[n].g_slgProcessTimeOld = lgCurTime;
							pProcessTime[n].dwProcessID = pe.th32ProcessID;
							nProcCpuPercent = nProcCpuPercent / dNumProcessor;
						}
						else
						{
							nProcCpuPercent = 0;
						}
						if (nProcCpuPercent > 100)
							nProcCpuPercent = 0;
						if (!inTipsProcessX)
						{
							PROCESSCPUUSAGE* ppc;
							if (ppcu[0]->fCpuUsage <= nProcCpuPercent)
							{
								ppc = ppcu[2];
								ppcu[2] = ppcu[1];
								ppcu[1] = ppcu[0];
								ppcu[0] = ppc;
								ppcu[0]->dwProcessID = pe.th32ProcessID;
								ppcu[0]->fCpuUsage = nProcCpuPercent;
								lstrcpyn(ppcu[0]->szExe,pe.szExeFile, 24);
							}
							else if (ppcu[1]->fCpuUsage <= nProcCpuPercent)
							{
								ppc = ppcu[2];
								ppcu[2] = ppcu[1];
								ppcu[1] = ppc;
								ppcu[1]->dwProcessID = pe.th32ProcessID;
								ppcu[1]->fCpuUsage = nProcCpuPercent;
								lstrcpyn(ppcu[1]->szExe, pe.szExeFile, 24);
							}
							else if (ppcu[2]->fCpuUsage <= nProcCpuPercent)
							{
								ppcu[2]->dwProcessID = pe.th32ProcessID;
								ppcu[2]->fCpuUsage = nProcCpuPercent;
								lstrcpyn(ppcu[2]->szExe,pe.szExeFile, 24);
							}
						}
					}
					CloseHandle(hProc);
				}
			}
			ret = Process32Next(hs, &pe);
		}
		CloseHandle(hs);
	}
}
int GetProcessMemUsage()//获取进程内存占用前三
{
	if (!inTipsProcessX)
	{
		ppmu[0] = &pmu[0];
		ppmu[1] = &pmu[1];
		ppmu[2] = &pmu[2];
		memset(pmu,0, sizeof pmu);
		pmu[0].dwMemUsage = 0;
		pmu[1].dwMemUsage = 0;
		pmu[2].dwMemUsage = 0;
	}
	PROCESSENTRY32 pe;
	pe.dwSize = sizeof(PROCESSENTRY32);
	int n = 0;
	HANDLE hs = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hs != INVALID_HANDLE_VALUE)
	{
		BOOL ret = Process32First(hs, &pe);
		while (ret)
		{
			++n;
			if (lstrcmp(pe.szExeFile, L"Memory Compression") != 0 && !inTipsProcessX)
			{
				HANDLE hProc = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pe.th32ProcessID);
				if (hProc)
				{
					PROCESS_MEMORY_COUNTERS_EX pmc;
					if (GetProcessMemoryInfo(hProc, (PPROCESS_MEMORY_COUNTERS)&pmc, sizeof(pmc)))
					{
						//QueryWorkingSet()
						PROCESSMEMORYUSAGE* ppm;
						if (ppmu[0]->dwMemUsage <= pmc.WorkingSetSize)
						{
							ppm = ppmu[2];
							ppmu[2] = ppmu[1];
							ppmu[1] = ppmu[0];
							ppmu[0] = ppm;
							ppmu[0]->dwProcessID = pe.th32ProcessID;
							ppmu[0]->dwMemUsage = pmc.WorkingSetSize;
							lstrcpyn(ppmu[0]->szExe, pe.szExeFile, 24);

						}
						else if (ppmu[1]->dwMemUsage <= pmc.WorkingSetSize)
						{
							ppm = ppmu[2];
							ppmu[2] = ppmu[1];
							ppmu[1] = ppm;
							ppmu[1]->dwProcessID = pe.th32ProcessID;
							ppmu[1]->dwMemUsage = pmc.WorkingSetSize;
							lstrcpyn(ppmu[1]->szExe, pe.szExeFile, 24);
						}
						else if (ppmu[2]->dwMemUsage <= pmc.WorkingSetSize)
						{
							ppmu[2]->dwProcessID = pe.th32ProcessID;
							ppmu[2]->dwMemUsage = pmc.WorkingSetSize;
							lstrcpyn(ppmu[2]->szExe, pe.szExeFile, 24);
						}
					}
					CloseHandle(hProc);
				}
			}
			ret = Process32Next(hs, &pe);
		}
		CloseHandle(hs);
	}
	return n;
}
void DrawTraffic(HDC mdc, LPRECT lpRect, DWORD dwByte, BOOL bInOut)
{
	WCHAR szInS[] = L"↓:";
	WCHAR szInS2[] = L"";
	WCHAR szOutS[] = L"↑:";
	WCHAR szOutS2[] = L"";
	WCHAR* szT;
	if (bInOut)
	{
		if (TraySave.iMonitorSimple == 1)
			szT = szInS;
		else if (TraySave.iMonitorSimple == 2)
			szT = szInS2;
		else
			szT = TraySave.szTrafficIn;
	}
	else
	{
		if (TraySave.iMonitorSimple == 1)
			szT = szOutS;
		else if (TraySave.iMonitorSimple == 2)
			szT = szOutS2;
		else
			szT = TraySave.szTrafficOut;
	}
	WCHAR sz[24];
	COLORREF rgb;
	if (dwByte < TraySave.dNumValues[0])
		rgb = TraySave.cMonitorColor[1];
	else if (dwByte < TraySave.dNumValues[1])
		rgb = TraySave.cMonitorColor[2];
	else
		rgb = TraySave.cMonitorColor[3];
	SetTextColor(mdc, rgb);
	if (HIWORD(TraySave.iUnit))
		dwByte *= 8;
	float f_byte = (float)dwByte;
	if (dwByte < 1000 && LOWORD(TraySave.iUnit) == 0)
		wsprintf(sz,  L"%s%dB", szT, dwByte);
	else if ((dwByte < 1024000 || (dwByte < 1000000 && HIWORD(TraySave.iUnit))) && LOWORD(TraySave.iUnit) != 2)
	{
		if (HIWORD(TraySave.iUnit))
			f_byte /= 1000;
		else
			f_byte /= 1024;
		int k_byte = int(f_byte * 100);
		if (f_byte >= 100)
			wsprintf(sz,  L"%s%dK", szT, k_byte/100);
		else if (f_byte >= 10)
			wsprintf(sz,  L"%s%d.%.1dK", szT, k_byte/100,(k_byte/10)%10);
		else
			wsprintf(sz,  L"%s%d.%.2dK", szT, k_byte/100,k_byte%100);
	}
	else if (dwByte < 1048576000 || (dwByte < 1000000000 && HIWORD(TraySave.iUnit)))
	{
		if (HIWORD(TraySave.iUnit))
			f_byte /= 1000000;
		else
			f_byte /= 1048576;
		int m_byte = int(f_byte * 100);
		if (f_byte >= 100)
			wsprintf(sz,  L"%s%dM", szT, m_byte/100);
		else if (f_byte >= 10)
			wsprintf(sz,  L"%s%d.%.1dM", szT, m_byte/100,(m_byte/10)%10);
		else
			wsprintf(sz,  L"%s%d.%.2dM", szT, m_byte/100,m_byte%100);
	}
	else
	{
		if (HIWORD(TraySave.iUnit))
			f_byte /= 1000000000;
		else
			f_byte /= 1073741824;
		int g_byte = int(f_byte * 100);
		if (f_byte >= 100)
			wsprintf(sz, L"%s%dG", szT, g_byte/100);
		else if (f_byte >= 10)
			wsprintf(sz,  L"%s%d.%.1dG", szT, g_byte/100,(g_byte/10)%10);
		else
			wsprintf(sz,  L"%s%d.%.2dG", szT,g_byte/100,g_byte%100);
	}
	if (HIWORD(TraySave.iUnit))
		lstrlwr(sz, 16);
	if (VTray&&TraySave.bMonitorFloat==FALSE)
		DrawShadowText(mdc, sz, lstrlen(sz), lpRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	else
		DrawShadowText(mdc, sz, lstrlen(sz), lpRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
}
BOOL bEvent = FALSE;//
BOOL SetTrackMouseEvent(HWND hWnd, DWORD dwFlags)
{
	TRACKMOUSEEVENT csTME;
	csTME.cbSize = sizeof(csTME);
	csTME.dwFlags = dwFlags;
	csTME.hwndTrack = hWnd;// 指定要 追踪 的窗口
	csTME.dwHoverTime = 300;  // 鼠标在按钮上停留超过 300ms ，才认为状态为 HOVER
	return TrackMouseEvent(&csTME);
}
int iGetAddressTime=10;//10秒一次获取网卡信息
INT_PTR CALLBACK TaskBarProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)//任务栏信息窗口过程
{
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
	case WM_COMMAND:
		if (LOWORD(wParam) >= IDC_SELECT_ALL && LOWORD(wParam) <= IDC_SELECT_ALL + 99)
		{
			if (LOWORD(wParam) == IDC_SELECT_ALL)
				TraySave.AdpterName[0] = L'\0';
			else
			{
				int x = LOWORD(wParam) - IDC_SELECT_ALL;
				PIP_ADAPTER_ADDRESSES paa;
				paa = &piaa[0];
				int n = 1;
				while (paa)
				{
					if (paa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && paa->IfType != IF_TYPE_TUNNEL)
					{
						if (n == x)
						{							
							lstrcpyA(TraySave.AdpterName,paa->AdapterName);
							break;
						}
						n++;
					}
					paa = paa->Next;
				}
			}
			WriteReg();
			m_last_in_bytes = 0;
			m_last_out_bytes = 0;
			s_in_byte = 0;
			s_out_byte = 0;
		}
		break;
	case WM_MOUSEMOVE:
		if (bEvent == FALSE && TraySave.bMonitorTips)
		{
			SetTrackMouseEvent(hTaskBar, TME_LEAVE | TME_HOVER);
			bEvent = TRUE;
		}
		break;
	case WM_MOUSEHOVER:
	{
		if (!IsWindowVisible(hTaskTips))
		{
			if (!IsWindow(hTaskTips))
			{
				hTaskTips = ::CreateDialog(hInst, MAKEINTRESOURCE(IDD_TIPS), NULL, (DLGPROC)TaskTipsProc);
				SetLayeredWindowAttributes(hTaskTips, 0, 255, LWA_ALPHA);
			}
			nProcess = GetProcessMemUsage();
			if (pProcessTime == NULL)
			{
				pProcessTime = (PROCESSTIME*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof PROCESSTIME*(nProcess + 32));
				memset(pProcessTime,0, sizeof(PROCESSTIME) * (nProcess + 32));
			}
			GetProcessCpuUsage();
			HDC mdc = GetDC(hMain);
			TraySave.TipsFont.lfHeight = DPI(TraySave.TipsFontSize);
			HFONT hTipsFont = CreateFontIndirect(&TraySave.TipsFont); //创建字体
			HFONT oldFont = (HFONT)SelectObject(mdc, hTipsFont);
			SIZE tSize;
			::GetTextExtentPoint(mdc, L"虚拟内存虚拟内存虚拟内存虚拟内存虚拟内存虚拟内存虚拟内存虚拟内存", 32, &tSize);
			SelectObject(mdc, oldFont);
			DeleteObject(hTipsFont);
			::ReleaseDC(hMain, mdc);
			int x, y, w, h;
			w = tSize.cx;
			wTipsHeight = tSize.cy;
			h = wTipsHeight * (nTraffic + 8);
			RECT wrc, src;
			GetWindowRect(hDlg, &wrc);
			GetScreenRect(hDlg, &src, TRUE);
			if (wrc.bottom + h > src.bottom)
				y = wrc.top - h;
			else
				y = wrc.bottom;
			if (wrc.right - (wrc.right - wrc.left) / 2 + w / 2 > src.right)
				x = src.right - w;
			else if (wrc.right - (wrc.right - wrc.left) / 2 - w / 2 < src.left)
				x = src.left;
			else
				x = wrc.right - (wrc.right - wrc.left) / 2 - w / 2;
			SetWindowPos(hTaskTips, HWND_TOPMOST, x, y, w, h, SWP_NOACTIVATE | SWP_SHOWWINDOW);
			HRGN hRgn = CreateRoundRectRgn(0, 0, w + 1, h + 1, 3, 3);
			SetWindowRgn(hTaskTips, hRgn, FALSE);
		}
	}
	break;
	case WM_MOUSELEAVE:
		if (TraySave.bMonitorFloat)
		{
			RECT wrc;
			GetWindowRect(hDlg, &wrc);
			TraySave.dMonitorPoint.x = wrc.left;
			TraySave.dMonitorPoint.y = wrc.top;
			WriteReg();
			bTaskBarMoveing = FALSE;
			//			SetTimer(hDlg, 6, 100, NULL);
		}
		POINT pt;
		GetCursorPos(&pt);
		if (WindowFromPoint(pt) != hTaskTips)
		{
			if (pProcessTime != NULL)
			{
				HeapFree(GetProcessHeap(), 0, pProcessTime);
				pProcessTime = NULL;
			}
			DestroyWindow(hTaskTips);
			//			ShowWindow(hTaskTips, SW_HIDE);
			SetTimer(hMain, 11, 1000, NULL);
		}
		else
			SetTrackMouseEvent(hTaskTips, TME_LEAVE);
		bEvent = FALSE;
		break;
	case  WM_RBUTTONDOWN:
	{
		POINT pt;
		GetCursorPos(&pt);
		ScreenToClient(hDlg, &pt);
		if (TraySave.bMonitorTraffic && pt.x < wTraffic && pt.y < wHeight * 2)
		{

			HMENU hMenu = LoadMenu(hInst, MAKEINTRESOURCEW(IDR_MENU));
			HMENU subMenu = GetSubMenu(hMenu, 0);
			PIP_ADAPTER_ADDRESSES paa;
			paa = &piaa[0];
			int n = 1;
			CheckMenuRadioItem(subMenu, IDC_SELECT_ALL, IDC_SELECT_ALL + 99, IDC_SELECT_ALL, MF_BYCOMMAND);
			while (paa)
			{
				if (paa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && paa->IfType != IF_TYPE_TUNNEL)
				{
					AppendMenu(subMenu, MF_BYCOMMAND, IDC_SELECT_ALL + n, paa->FriendlyName);
					if (lstrcmpA(paa->AdapterName, TraySave.AdpterName) == 0)
						CheckMenuRadioItem(subMenu, IDC_SELECT_ALL, IDC_SELECT_ALL + 99, IDC_SELECT_ALL + n, MF_BYCOMMAND);
					n++;
				}
				paa = paa->Next;
			}
			POINT point;
			GetCursorPos(&point);
			SetTimer(hDlg, 5, 1200, NULL);
			TrackPopupMenu(subMenu, TPM_LEFTALIGN, point.x, point.y, NULL, hDlg, NULL);
			DestroyMenu(hMenu);
		}
		else
			OpenSetting();
		return TRUE;
	}
	break;
	case WM_LBUTTONDOWN:
	{
		if (TraySave.bMonitorFloat)
		{
			bTaskBarMoveing = TRUE;
			PostMessage(hDlg, WM_NCLBUTTONDOWN, HTCAPTION, lParam);
		}
		return TRUE;
		/*
				else
					RunProcess(szNetCpl);
		*/
	}
	break;
	case WM_LBUTTONUP:
		if (!TraySave.bMonitorFloat)
		{
			ShowWindow(hDlg, SW_HIDE);
			SetTimer(hDlg, 9, 100, NULL);
			return TRUE;
		}
		break;
	case WM_TIMER:
		if (wParam == 9)
		{
			KillTimer(hDlg, wParam);
			POINT pt;
			GetCursorPos(&pt);
			mouse_event(MOUSEEVENTF_LEFTDOWN, pt.x, pt.y, 0, 0);
			mouse_event(MOUSEEVENTF_LEFTUP, pt.x, pt.y, 0, 0);
			ShowWindow(hDlg, SW_SHOWNOACTIVATE);
		}
		else if (wParam == 5)////////////////////////////////////////////////光标移出弹出式菜单自动隐藏菜单
		{

			HWND hMenu = FindWindow(L"#32768", NULL);
			POINT pt;
			GetCursorPos(&pt);
			if (WindowFromPoint(pt) != hMenu)
			{
				KillTimer(hDlg, wParam);
				PostMessage(hMenu, WM_CLOSE, NULL, NULL);
			}
		}
		else if (wParam == 3)
		{
			if (IsWindowVisible(hTaskTips))
			{
				nProcess = GetProcessMemUsage();
				GetProcessCpuUsage();
			}
			if (TraySave.bMonitorUsage)
			{
				iCPU = GetCPUUseRate();
				GlobalMemoryStatusEx(&MemoryStatusEx);
			}
			if (TraySave.bMonitorTemperature)
			{
				if (bRing0)
				{
					iTemperature1 = GetCpuTemp(1);
					iTemperature2 = GetCpuTemp(dNumProcessor);
				}
				int iATITemperature = 0;
				int iNVTemperature = 0;
				if (hNVDLL)
				{
					NV_GPU_THERMAL_SETTINGS currentTemp;//获取温度的数据结构
					currentTemp.version = NV_GPU_THERMAL_SETTINGS_VER;//一定要设置，不然调用获取温度函数时候会出错
					for (int GpuIndex = 0; GpuIndex < 4; GpuIndex++)
					{
						if (NvAPI_GPU_GetThermalSettings(hPhysicalGpu[GpuIndex], 15, &currentTemp) == 0)
						{
							iNVTemperature = currentTemp.sensor[0].currentTemp;
							break;
						}
					}
				}
				if (hATIDLL)
				{
					adlTemperature.iSize = sizeof(ADLTemperature);
					ADL_Overdrive5_Temperature_Get(0, 0, &adlTemperature);
					iATITemperature = adlTemperature.iTemperature / 1000;
				}
				if (iATITemperature != 0 || iNVTemperature != 0)
				{
					if (iATITemperature > iNVTemperature)
						iTemperature2 = iATITemperature;
					else
						iTemperature2 = iNVTemperature;
				}
			}
			if (TraySave.bMonitorTraffic)
			{
				if (hIphlpapi == NULL)
				{
					hIphlpapi = LoadLibrary(L"iphlpapi.dll");
					if (hIphlpapi)
					{
						GetAdaptersAddressesT = (pfnGetAdaptersAddresses)GetProcAddress(hIphlpapi, "GetAdaptersAddresses");
						GetIfTableT = (pfnGetIfTable)GetProcAddress(hIphlpapi, "GetIfTable");
					}
				}
				if (hIphlpapi)
				{
					PIP_ADAPTER_ADDRESSES paa;
					if (iGetAddressTime == 10)
					{
						//				DWORD odwIPSize = dwIPSize;
						dwIPSize = 0;
						if (GetAdaptersAddressesT(AF_INET, 0, 0, piaa, &dwIPSize) == ERROR_BUFFER_OVERFLOW)
						{
							//					if (dwIPSize != odwIPSize)
							{

								HeapFree(GetProcessHeap(),0,piaa);
								int n = 0;
								piaa = (PIP_ADAPTER_ADDRESSES)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwIPSize);
								if (GetAdaptersAddressesT(AF_INET, 0, 0, piaa, &dwIPSize) == ERROR_SUCCESS)
								{
									paa = &piaa[0];
									while (paa)
									{
										if (paa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && paa->IfType != IF_TYPE_TUNNEL)
										{
											++n;
										}
										paa = paa->Next;
									}
									if (n != nTraffic)
									{
										HeapFree(GetProcessHeap(), 0, traffic);
										nTraffic = n;
										traffic = (TRAFFIC*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nTraffic * sizeof TRAFFIC);
									}
								}
							}
						}
						iGetAddressTime = 0;
					}
					else
						iGetAddressTime++;
					/*
								PIP_ADAPTER_INFO pai;
								if (GetAdaptersInfo(ipinfo, &dwIPSize) == ERROR_BUFFER_OVERFLOW)
								{
									free(ipinfo);
									ipinfo = (PIP_ADAPTER_INFO)malloc(dwIPSize);
									GetAdaptersInfo(ipinfo, &dwIPSize);
									pai = &ipinfo[0];
									nTraffic = 0;
									while (pai)
									{
										++nTraffic;
										pai = pai->Next;
									}
									free(traffic);
									traffic = (TRAFFIC*)malloc(nTraffic * sizeof TRAFFIC);
								}
					*/
					if (GetIfTableT(mi, &dwMISize, FALSE) == ERROR_INSUFFICIENT_BUFFER)
					{
						dwMISize += sizeof MIB_IFROW * 2;
						HeapFree(GetProcessHeap(), 0, mi);
						mi = (MIB_IFTABLE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwMISize);
						GetIfTableT(mi, &dwMISize, FALSE);
					}
					DWORD m_in_bytes = 0;
					DWORD m_out_bytes = 0;
					for (DWORD i = 0; i < mi->dwNumEntries; i++)
					{
						int l = 0;
						paa = &piaa[0];
						while (paa)
						{
							if (paa->IfType != IF_TYPE_SOFTWARE_LOOPBACK && paa->IfType != IF_TYPE_TUNNEL)
							{
								if (paa->IfIndex == mi->table[i].dwIndex)
								{
									traffic[l].in_byte = (mi->table[i].dwInOctets - traffic[l].in_bytes) * 8;
									traffic[l].out_byte = (mi->table[i].dwOutOctets - traffic[l].out_bytes) * 8;
									traffic[l].in_bytes = mi->table[i].dwInOctets;
									traffic[l].out_bytes = mi->table[i].dwOutOctets;

									PIP_ADAPTER_UNICAST_ADDRESS pUnicast = paa->FirstUnicastAddress;
									//							char IP[130];
									while (pUnicast)
									{
										if (AF_INET == pUnicast->Address.lpSockaddr->sa_family)// IPV4 地址，使用 IPV4 转换
										{
											void* pAddr = &((sockaddr_in*)pUnicast->Address.lpSockaddr)->sin_addr;
											byte* bp = (byte*)pAddr;
											wsprintf(traffic[l].IP4,  L"%d.%d.%d.%d", bp[0], bp[1], bp[2], bp[3]);
											break;
										}
										//								else if (AF_INET6 == pUnicast->Address.lpSockaddr->sa_family)// IPV6 地址，使用 IPV6 转换
										//									inet_ntop(PF_INET6, &((sockaddr_in6*)pUnicast->Address.lpSockaddr)->sin6_addr, IP, sizeof(IP));
										pUnicast = pUnicast->Next;
									}
									//							MultiByteToWideChar(CP_ACP, 0, IP, 15, traffic[l].IP4, 15);
									traffic[l].FriendlyName = paa->FriendlyName;
									traffic[l].AdapterName = paa->AdapterName;
									if (lstrlen(paa->FriendlyName) > 19)
									{
										paa->FriendlyName[16] = L'.';
										paa->FriendlyName[17] = L'.';
										paa->FriendlyName[18] = L'.';
										paa->FriendlyName[19] = L'\0';
									}
									//							wcsncpy_s(traffic[l].FriendlyName, 24, paa->FriendlyName,24);
									if (TraySave.AdpterName[0] == L'\0' || lstrcmpA(paa->AdapterName, TraySave.AdpterName) == 0)
									{
										m_in_bytes += mi->table[i].dwInOctets;
										m_out_bytes += mi->table[i].dwOutOctets;
									}
								}
								++l;
							}
							paa = paa->Next;
						}
					}
					if (m_last_in_bytes != 0)
					{
						s_in_byte = m_in_bytes - m_last_in_bytes;
						s_out_byte = m_out_bytes - m_last_out_bytes;
					}
					m_last_out_bytes = m_out_bytes;
					m_last_in_bytes = m_in_bytes;
				}
			}
			else
			{
				if (hIphlpapi)
				{
					FreeLibrary(hIphlpapi);
					hIphlpapi = NULL;
				}
			}
			if (TraySave.bSound)
			{
				if ((TraySave.dNumValues[8] != 0 && (s_in_byte > TraySave.dNumValues[8] || s_out_byte > TraySave.dNumValues[8]))
					|| (TraySave.dNumValues[9] != 0 && ((DWORD)iTemperature1 > TraySave.dNumValues[9] || (DWORD)iTemperature2 > TraySave.dNumValues[9]))
					|| (TraySave.dNumValues[10] != 0 && (DWORD)iCPU > TraySave.dNumValues[10])
					|| (TraySave.dNumValues[11] != 0 && MemoryStatusEx.dwMemoryLoad > TraySave.dNumValues[11]))
				{
					MessageBeep(MB_ICONHAND);
					//PlaySound((LPCWSTR)SND_ALIAS_SYSTEMQUESTION, NULL, SND_ASYNC | SND_ALIAS_ID);
				}
			}
			::InvalidateRect(hTaskBar, NULL, TRUE);
		}
	case WM_ERASEBKGND:
	{
		//		PAINTSTRUCT ps;
		HDC hdc = (HDC)wParam;//BeginPaint(hDlg, &ps);		
		RECT rc;
		GetClientRect(hDlg, &rc);
		HDC mdc = CreateCompatibleDC(hdc);
		HBITMAP hMemBmp = CreateCompatibleBitmap(hdc, rc.right - rc.left, rc.bottom - rc.top);
		HBITMAP oldBmp = (HBITMAP)SelectObject(mdc, hMemBmp);
		if (TraySave.cMonitorColor[0] != 0)
		{
			HBRUSH hb = CreateSolidBrush(TraySave.cMonitorColor[0]);
			FillRect(mdc, &rc, hb);
			DeleteObject(hb);
		}
		//		if (bErasebkgnd)
		{
			if (VTray && TraySave.bMonitorFloat == FALSE)
			{
				/*
								int s = (rc.right - rc.left - DPI(54)) / 2;
								rc.left += s;
								rc.right -= s;
				*/
			}
			else
			{
				InflateRect(&rc, -2, 0);
			}
			HFONT oldFont = (HFONT)SelectObject(mdc, hFont);
			WCHAR sz[16];
			SetBkMode(mdc, TRANSPARENT);
			COLORREF rgb;
			if (TraySave.bMonitorTraffic)
			{
				RECT crc = rc;
				if (VTray && TraySave.bMonitorFloat == FALSE)
				{
					crc.bottom = wHeight;
					DrawTraffic(mdc, &crc, s_out_byte, FALSE);
					OffsetRect(&crc, 0, wHeight);
					DrawTraffic(mdc, &crc, s_in_byte, TRUE);
				}
				else
				{
					crc.bottom /= 2;
					DrawTraffic(mdc, &crc, s_out_byte, FALSE);
					OffsetRect(&crc, 0, crc.bottom);
					DrawTraffic(mdc, &crc, s_in_byte, TRUE);
				}
			}
			if (TraySave.bMonitorTemperature)
			{
				RECT crc = rc;
				if (VTray && TraySave.bMonitorFloat == FALSE)
				{
					if (TraySave.bMonitorTraffic)
						crc.top = wHeight * 2;
					crc.bottom = crc.top + wHeight;
				}
				else
				{

					if (TraySave.bMonitorTraffic)
						crc.left = wTraffic;
					else
						crc.left = 0;
					crc.bottom /= 2;
				}
				if (bRing0)
				{
					if (iTemperature1 <= TraySave.dNumValues[2])
						rgb = TraySave.cMonitorColor[4];
					else if (iTemperature1 <= TraySave.dNumValues[3])
						rgb = TraySave.cMonitorColor[5];
					else
						rgb = TraySave.cMonitorColor[6];
					SetTextColor(mdc, rgb);
					if (TraySave.iMonitorSimple == 1)
						wsprintf(sz,  L"%.2d℃", iTemperature1);
					else if (TraySave.iMonitorSimple == 2)
						wsprintf(sz,  L"%.2d", iTemperature1);
					else
						wsprintf(sz,  L"%s%.2d%s", TraySave.szTemperatureCPU, iTemperature1, TraySave.szTemperatureCPUUnit);

					if (VTray && TraySave.bMonitorFloat == FALSE)
						DrawShadowText(mdc, sz, lstrlen(sz), &crc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
					else
						DrawShadowText(mdc, sz, lstrlen(sz), &crc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
				}
				if (bRing0)
				{
					if (VTray && TraySave.bMonitorFloat == FALSE)
						OffsetRect(&crc, 0, wHeight);
					else
						OffsetRect(&crc, 0, crc.bottom - crc.top);
				}
				else
				{
					if (VTray && TraySave.bMonitorFloat == FALSE)
					{
						//						crc.bottom += wHeight;
					}
					else
						crc.bottom += (crc.bottom - crc.top);
				}
				if (iTemperature2 <= TraySave.dNumValues[2])
					rgb = TraySave.cMonitorColor[4];
				else if (iTemperature2 <= TraySave.dNumValues[3])
					rgb = TraySave.cMonitorColor[5];
				else
					rgb = TraySave.cMonitorColor[6];
				SetTextColor(mdc, rgb);
				if (TraySave.iMonitorSimple == 0)
					wsprintf(sz,  L"%s%.2d%s", TraySave.szTemperatureGPU, iTemperature2, TraySave.szTemperatureGPUUnit);
				else if (TraySave.iMonitorSimple == 1)
					wsprintf(sz,  L"%.2d℃", iTemperature2);
				else
					wsprintf(sz,  L"%.2d", iTemperature2);
				if (VTray && TraySave.bMonitorFloat == FALSE)
					DrawShadowText(mdc, sz, lstrlen(sz), &crc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				else
					DrawShadowText(mdc, sz, lstrlen(sz), &crc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

			}
			if (TraySave.bMonitorUsage)
			{
				if (iCPU <= TraySave.dNumValues[4])
					rgb = TraySave.cMonitorColor[4];
				else if (iCPU <= TraySave.dNumValues[5])
					rgb = TraySave.cMonitorColor[5];
				else
					rgb = TraySave.cMonitorColor[6];
				SetTextColor(mdc, rgb);
				/*
							if(bRing0)
								swprintf_s(sz, 16, L"%.2d%%", iCPU);
							else
				*/
				if (TraySave.iMonitorSimple == 1)
					wsprintf(sz,  L"%.2d%%", iCPU);
				else if (TraySave.iMonitorSimple == 2)
					wsprintf(sz,  L"%.2d", iCPU);
				else
					wsprintf(sz,  L"%s%.2d%s", TraySave.szUsageCPU, iCPU, TraySave.szUsageCPUUnit);

				int sLen = lstrlen(sz);
				RECT crc = rc;
				if (VTray && TraySave.bMonitorFloat == FALSE)
				{
					if (TraySave.bMonitorTraffic)
						crc.top = wHeight * 2;
					if (TraySave.bMonitorTemperature)
					{
						crc.top += wHeight;
						if (bRing0)
							crc.top += wHeight;
					}
					crc.bottom = crc.top + wHeight;
					DrawShadowText(mdc, sz, sLen, &crc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				}
				else
				{
					crc.bottom /= 2;
					DrawShadowText(mdc, sz, sLen, &crc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
				}
				/*
							if(bRing0)
								swprintf_s(sz, 16, L"%.2d%%", MemoryStatusEx.dwMemoryLoad);
							else
				*/
				if (TraySave.iMonitorSimple == 1)
					wsprintf(sz,  L"%.2d%%", MemoryStatusEx.dwMemoryLoad);
				else if (TraySave.iMonitorSimple == 2)
					wsprintf(sz,  L"%.2d", MemoryStatusEx.dwMemoryLoad);
				else
					wsprintf(sz,  L"%s%.2d%s", TraySave.szUsageMEM, MemoryStatusEx.dwMemoryLoad, TraySave.szUsageMEMUnit);
				sLen = lstrlen(sz);
				if (MemoryStatusEx.dwMemoryLoad <= TraySave.dNumValues[6])
					rgb = TraySave.cMonitorColor[4];
				else if (MemoryStatusEx.dwMemoryLoad <= TraySave.dNumValues[7])
					rgb = TraySave.cMonitorColor[5];
				else
					rgb = TraySave.cMonitorColor[6];
				SetTextColor(mdc, rgb);
				if (VTray && TraySave.bMonitorFloat == FALSE)
				{
					OffsetRect(&crc, 0, wHeight);
					DrawShadowText(mdc, sz, (int)sLen, &crc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
				}
				else
				{
					OffsetRect(&crc, 0, crc.bottom);
					DrawShadowText(mdc, sz, (int)sLen, &crc, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
				}
			}
			SelectObject(mdc, oldFont);
		}
		//		GetClientRect(hDlg, &rc);
		InflateRect(&rc, 2, 0);
/*
		BLENDFUNCTION bf1;
		bf1.BlendOp = AC_SRC_OVER;
		bf1.BlendFlags = 0;
		bf1.SourceConstantAlpha = 88;
		bf1.AlphaFormat = AC_SRC_ALPHA;
		::AlphaBlend(hdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, mdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, bf1);
*/
		if (TraySave.cMonitorColor[0] != RGB(0, 0, 0))
		{
			BYTE* lpvBits = NULL;
			
			BITMAPINFO binfo;
			memset(&binfo, 0, sizeof(BITMAPINFO));
			binfo.bmiHeader.biBitCount = 32;     //每个像素多少位，也可直接写24(RGB)或者32(RGBA)
			binfo.bmiHeader.biCompression = 0;
			binfo.bmiHeader.biHeight = rc.bottom - rc.top;
			binfo.bmiHeader.biPlanes = 1;
			binfo.bmiHeader.biSizeImage = (rc.bottom - rc.top) * (rc.right - rc.left) * 4;
			binfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
			binfo.bmiHeader.biWidth = rc.right - rc.left;
			lpvBits = (BYTE*)HeapAlloc(GetProcessHeap(), HEAP_NO_SERIALIZE, binfo.bmiHeader.biSizeImage);
			//		GetDIBits(mdc, hMemBmp, 0, rc.bottom - rc.top, lpvBits, &bmpInfo, DIB_RGB_COLORS);

			GetDIBits(mdc, hMemBmp, 0, rc.bottom - rc.top, lpvBits, &binfo, DIB_RGB_COLORS);
			for (DWORD i = 0; i < binfo.bmiHeader.biSizeImage-4; i += 4)
			{
				if (lpvBits[i] >3 || lpvBits[i + 1] != 0 || lpvBits[i + 2] != 0)
					lpvBits[i + 3] = 0x80;
			}
			SetDIBits(mdc, hMemBmp, 0, rc.bottom - rc.top, lpvBits, &binfo, DIB_RGB_COLORS);
			HeapFree(GetProcessHeap(), 0, lpvBits);
		}
		BitBlt(hdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, mdc, 0, 0, SRCCOPY);
		SelectObject(mdc, oldBmp);
		DeleteObject(hMemBmp);
		DeleteDC(mdc);
		//		EndPaint(hDlg, &ps);

		return TRUE;
	}
	break;
	}
	return FALSE;
}
INT_PTR CALLBACK MainProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)//主窗口过程
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
		/*
			case WM_ENDSESSION:
				if (lParam == ENDSESSION_LOGOFF)
				{
					DestroyWindow(hTray);
					RunProcess(NULL);
					return TRUE;
				}
				break;
		*/
	case WM_TRAYS:
		OpenSetting();
		break;
	case WM_DPICHANGED:
	{
		iDPI = LOWORD(wParam);
		SetTimer(hDlg, 8, 1000, NULL);
	}
	break;
	case WM_CLOSE:
	{
		KillTimer(hDlg, 6);
		KillTimer(hDlg, 3);
		SendMessage(hReBarWnd, WM_SETREDRAW, TRUE, 0);
		HWND hSecondaryTray;
		hSecondaryTray = FindWindow(szSecondaryTray, NULL);
		while (hSecondaryTray)
		{
			HWND hSReBarWnd = FindWindowEx(hSecondaryTray, 0, L"WorkerW", NULL);
			SendMessage(hSReBarWnd, WM_SETREDRAW, TRUE, 0);
			ShowWindow(hSReBarWnd, SW_SHOWNOACTIVATE);
			hSecondaryTray = FindWindowEx(NULL, hSecondaryTray, szSecondaryTray, NULL);
		}
		ShowWindow(hTaskListWnd, SW_SHOW);
		PostQuitMessage(0);
	}
	break;
	case WM_TIMER:
	{
		if (wParam == 8)
		{
			KillTimer(hDlg, wParam);			
			SetWH();
		}
		else if (wParam == 11)//释放内存
		{
			KillTimer(hDlg, wParam);
			SetTimer(hDlg, wParam, 60000, NULL);
			HANDLE hProcess = GetCurrentProcess();
			SetProcessWorkingSetSize(hProcess, -1, -1);
			EmptyWorkingSet(hProcess);
		}
		else if (wParam == 6)//处理任务栏图标与信息窗口
		{
			if (TraySave.bMonitor)
			{
//				if (!bTaskBarMoveing)
//					AdjustWindowPos();
				if (IsWindowVisible(hTaskTips))
					::InvalidateRect(hTaskTips, NULL, TRUE);
			}
			if (TraySave.iPos != 0 || TraySave.bMonitor)
			{
//				if (TraySave.bTaskIcon == FALSE)
				{
					GetShellAllWnd();
					SetTaskBarPos(hTaskListWnd, hTray, hTaskWnd, hReBarWnd, TRUE);
				}
				HWND hSecondaryTray;
				hSecondaryTray = FindWindow(szSecondaryTray, NULL);
				while (hSecondaryTray)
				{
					HWND hSReBarWnd = FindWindowEx(hSecondaryTray, 0, L"WorkerW", NULL);
					if (hSReBarWnd)
					{
						HWND hSTaskListWnd = FindWindowEx(hSReBarWnd, NULL, L"MSTaskListWClass", NULL);
						if (hSTaskListWnd)
						{
							SetTaskBarPos(hSTaskListWnd, hSecondaryTray, hSReBarWnd, hSReBarWnd, FALSE);
						}
					}
					hSecondaryTray = FindWindowEx(NULL, hSecondaryTray, szSecondaryTray, NULL);
				}
			}
		}
		else if (wParam == 3)//处理任务栏风格
		{
			if (TraySave.bMonitor)
			{
				if (!bTaskBarMoveing)
				{
					AdjustWindowPos();
				}
			}
			{
				HWND hTray = FindWindow(szShellTray, NULL);
				if (hTray)
				{
					if (iProject == 0)
						iWindowMode = 0;
					else if (iProject == 1)
						iWindowMode = 1;
					else
					{
						iWindowMode = 0;
						EnumWindows(IsZoomedFunc, (LPARAM)MonitorFromWindow(hTray, MONITOR_DEFAULTTONEAREST));
					}
					SetWindowCompositionAttribute(hTray, TraySave.aMode[iWindowMode], TraySave.dAlphaColor[iWindowMode]);
					LONG_PTR exStyle = GetWindowLongPtr(hTray, GWL_EXSTYLE);
					exStyle |= WS_EX_LAYERED;
					SetWindowLongPtr(hTray, GWL_EXSTYLE, exStyle);
					SetLayeredWindowAttributes(hTray, 0, (BYTE)TraySave.bAlpha[iWindowMode], LWA_ALPHA);
				}
				HWND hSecondaryTray = FindWindow(szSecondaryTray, NULL);
				while (hSecondaryTray)
				{
					if (iProject == 0)
						iWindowMode = 0;
					else if (iProject == 1)
						iWindowMode = 1;
					else
					{
						iWindowMode = 0;
						EnumWindows(IsZoomedFunc, (LPARAM)MonitorFromWindow(hSecondaryTray, MONITOR_DEFAULTTONEAREST));
					}
					SetWindowCompositionAttribute(hSecondaryTray, TraySave.aMode[iWindowMode], TraySave.dAlphaColor[iWindowMode]);
					LONG_PTR exStyle = GetWindowLongPtr(hSecondaryTray, GWL_EXSTYLE);
					exStyle |= WS_EX_LAYERED;
					SetWindowLongPtr(hSecondaryTray, GWL_EXSTYLE, exStyle);
					SetLayeredWindowAttributes(hSecondaryTray, 0, (BYTE)TraySave.bAlpha[iWindowMode], LWA_ALPHA);
					hSecondaryTray = FindWindowEx(NULL, hSecondaryTray, szSecondaryTray, NULL);
				}
			}
			if (TraySave.aMode[0] == ACCENT_DISABLED && TraySave.aMode[1] == ACCENT_DISABLED)//默认则关闭定时器
				KillTimer(hDlg, 3);
		}
	}
	break;
	case WM_IAWENTRAY://////////////////////////////////////////////////////////////////////////////////通知栏左右键处理
	{
		if (wParam == WM_IAWENTRAY)
		{
			if (lParam == WM_LBUTTONDOWN || lParam == WM_RBUTTONDOWN)
			{
				OpenSetting();
			}
		}
		break;
	}
	break;
	}
	return FALSE;
}
INT_PTR CALLBACK SettingProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)//设置窗口过程
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
	case WM_NOTIFY:
		switch (((LPNMHDR)lParam)->code)
		{
		case NM_CLICK:
		case NM_RETURN:
		{
			HWND g_hLink = GetDlgItem(hDlg, IDC_SYSLINK);
			PNMLINK pNMLink = (PNMLINK)lParam;
			LITEM item = pNMLink->item;
			if ((((LPNMHDR)lParam)->hwndFrom == g_hLink) && (item.iLink == 0))
			{
				CloseHandle(pShellExecute(NULL, L"open", L"https://gitee.com/cgbsmy/TrayS", NULL, NULL, SW_SHOW));
				//mailto:cgbsmy@live.com?subject=TrayS
			}
			else
			{
				CloseHandle(pShellExecute(NULL, L"open", L"https://www.52pojie.cn/thread-1182669-1-1.html", NULL, NULL, SW_SHOW));
			}
			break;
		}
		}
		break;
	case WM_HSCROLL://////////////////////////////////////////////////////////////////////////////////透明度处理
	{
		HWND hSlider = GetDlgItem(hDlg, IDC_SLIDER_ALPHA);
		HWND hSliderB = GetDlgItem(hDlg, IDC_SLIDER_ALPHA_B);
		if (hSlider == (HWND)lParam)
		{
			TraySave.bAlpha[iProject] = (int)SendDlgItemMessage(hDlg, IDC_SLIDER_ALPHA, TBM_GETPOS, 0, 0);
		}
		else if (hSliderB == (HWND)lParam)
		{
			DWORD bAlphaB = (int)SendDlgItemMessage(hDlg, IDC_SLIDER_ALPHA_B, TBM_GETPOS, 0, 0);
			bAlphaB = bAlphaB << 24;
			TraySave.dAlphaColor[iProject] = bAlphaB + (TraySave.dAlphaColor[iProject] & 0xffffff);
		}
		SetTimer(hDlg, 3, 500, NULL);
		break;
	}
	case WM_TIMER:
		if (wParam == 3)
		{
			KillTimer(hDlg, wParam);
			WriteReg();
		}
		break;
	case WM_COMMAND:
		if (HIWORD(wParam) == EN_CHANGE && !bSettingInit)
		{
			if (LOWORD(wParam) >= IDC_EDIT1 && LOWORD(wParam) <= IDC_EDIT12)
			{
				int index = LOWORD(wParam) - IDC_EDIT1;
				TraySave.dNumValues[index] = GetDlgItemInt(hDlg, LOWORD(wParam), NULL, 0);
				if (index == 0 || index == 1 || index == 8)
					TraySave.dNumValues[index] *= 1048576;
				SetTimer(hDlg, 3, 500, NULL);
			}
			else if (LOWORD(wParam) == IDC_EDIT_TIME)
			{
				TraySave.FlushTime = GetDlgItemInt(hDlg, LOWORD(wParam), NULL, 0);
				if (TraySave.aMode[0] != ACCENT_DISABLED || TraySave.aMode[1] != ACCENT_DISABLED)
					SetTimer(hMain, 3, TraySave.FlushTime, NULL);
				SetTimer(hDlg, 3, 500, NULL);
			}
			else if (LOWORD(wParam) >= IDC_EDIT14 && LOWORD(wParam) <= IDC_EDIT23)
			{
				GetDlgItemText(hDlg, IDC_EDIT14, TraySave.szTrafficOut, 8);
				GetDlgItemText(hDlg, IDC_EDIT15, TraySave.szTrafficIn, 8);
				GetDlgItemText(hDlg, IDC_EDIT16, TraySave.szTemperatureCPU, 8);
				GetDlgItemText(hDlg, IDC_EDIT17, TraySave.szTemperatureGPU, 8);
				GetDlgItemText(hDlg, IDC_EDIT18, TraySave.szTemperatureCPUUnit, 4);
				GetDlgItemText(hDlg, IDC_EDIT19, TraySave.szTemperatureGPUUnit, 4);
				GetDlgItemText(hDlg, IDC_EDIT20, TraySave.szUsageCPU, 8);
				GetDlgItemText(hDlg, IDC_EDIT21, TraySave.szUsageMEM, 8);
				GetDlgItemText(hDlg, IDC_EDIT22, TraySave.szUsageCPUUnit, 4);
				GetDlgItemText(hDlg, IDC_EDIT23, TraySave.szUsageMEMUnit, 4);
				SetTimer(hDlg, 3, 1500, NULL);
				if (TraySave.iMonitorSimple == 0)
					SetWH();
			}
		}
		else if (LOWORD(wParam) >= IDC_RADIO_DEFAULT && LOWORD(wParam) <= IDC_RADIO_ACRYLIC)
		{
			if (IsDlgButtonChecked(hDlg, IDC_RADIO_DEFAULT))
				TraySave.aMode[iProject] = ACCENT_DISABLED;
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_TRANSPARENT))
				TraySave.aMode[iProject] = ACCENT_ENABLE_TRANSPARENTGRADIENT;
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_BLURBEHIND))
				TraySave.aMode[iProject] = ACCENT_ENABLE_BLURBEHIND;
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_ACRYLIC))
				TraySave.aMode[iProject] = ACCENT_ENABLE_ACRYLICBLURBEHIND;
			WriteReg();
			if (TraySave.aMode[0] != ACCENT_DISABLED || TraySave.aMode[1] != ACCENT_DISABLED)
				SetTimer(hMain, 3, TraySave.FlushTime, NULL);
			else
				KillTimer(hMain, 3);

		}
		else if (LOWORD(wParam) >= IDC_RADIO_LEFT && LOWORD(wParam) <= IDC_RADIO_RIGHT)
		{
			if (IsDlgButtonChecked(hDlg, IDC_RADIO_LEFT))
			{
				TraySave.iPos = 0;
			}
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_CENTER))
			{
				TraySave.iPos = 1;
			}
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_RIGHT))
			{
				TraySave.iPos = 2;
			}
			WriteReg();
		}
		else if (LOWORD(wParam) >= IDC_RADIO_BYTE && LOWORD(wParam) <= IDC_RADIO_MB)
		{
			if (IsDlgButtonChecked(hDlg, IDC_RADIO_AUTO))
				TraySave.iUnit = 0;
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_KB))
				TraySave.iUnit = 1;
			else if (IsDlgButtonChecked(hDlg, IDC_RADIO_MB))
				TraySave.iUnit = 2;
			if (IsDlgButtonChecked(hDlg, IDC_RADIO_BIT))
				TraySave.iUnit |= 0x10000;
			WriteReg();
		}
		if (LOWORD(wParam) == IDC_RADIO_NORMAL || LOWORD(wParam) == IDC_RADIO_MAXIMIZE)
		{
			if (IsDlgButtonChecked(hDlg, IDC_RADIO_NORMAL))
				iProject = 0;
			else
				iProject = 1;
			if (TraySave.aMode[iProject] == ACCENT_DISABLED)
				CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_DEFAULT);
			else if (TraySave.aMode[iProject] == ACCENT_ENABLE_TRANSPARENTGRADIENT)
				CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_TRANSPARENT);
			else if (TraySave.aMode[iProject] == ACCENT_ENABLE_BLURBEHIND)
				CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_BLURBEHIND);
			else if (TraySave.aMode[iProject] == ACCENT_ENABLE_ACRYLICBLURBEHIND)
				CheckRadioButton(hSetting, IDC_RADIO_DEFAULT, IDC_RADIO_ACRYLIC, IDC_RADIO_ACRYLIC);
			SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA, TBM_SETPOS, TRUE, TraySave.bAlpha[iProject]);
			BYTE bAlphaB = TraySave.dAlphaColor[iProject] >> 24;
			SendDlgItemMessage(hSetting, IDC_SLIDER_ALPHA_B, TBM_SETPOS, TRUE, bAlphaB);
			::InvalidateRect(GetDlgItem(hSetting, IDC_BUTTON_COLOR), NULL, FALSE);
		}
		else if (LOWORD(wParam) == IDC_CHECK_SOUND)
		{
			TraySave.bSound = IsDlgButtonChecked(hDlg, IDC_CHECK_SOUND);
			WriteReg();
		}
		else if (LOWORD(wParam) == IDC_CHECK_TIPS)
		{
			TraySave.bMonitorTips = IsDlgButtonChecked(hDlg, IDC_CHECK_TIPS);
			WriteReg();
		}
		else if (LOWORD(wParam) == IDC_CHECK_TRAYICON)
		{
			TraySave.bTrayIcon = IsDlgButtonChecked(hDlg, IDC_CHECK_TRAYICON);
			WriteReg();
			CloseTaskBar();
			if (TraySave.bTrayIcon)
				pShell_NotifyIcon(NIM_ADD, &nid);
			else
				pShell_NotifyIcon(NIM_DELETE, &nid);
		}
		else if (LOWORD(wParam) == IDC_CHECK_MONITOR)
		{
			TraySave.bMonitor = IsDlgButtonChecked(hDlg, IDC_CHECK_MONITOR);
			WriteReg();
			if (!TraySave.bMonitor)
			{
				CloseTaskBar();
			}
		}
		else if (LOWORD(wParam) == IDC_CHECK_TRAFFIC)
		{
			TraySave.bMonitorTraffic = IsDlgButtonChecked(hDlg, IDC_CHECK_TRAFFIC);
			WriteReg();
			SetWH();
		}
		else if (LOWORD(wParam) == IDC_CHECK_TEMPERATURE)
		{
			TraySave.bMonitorTemperature = IsDlgButtonChecked(hDlg, IDC_CHECK_TEMPERATURE);
			if (TraySave.bMonitorTemperature)
				LoadTemperatureDLL();
			else
				FreeTemperatureDLL();
			WriteReg();
			SetWH();
		}
		else if (LOWORD(wParam) == IDC_CHECK_MONITOR_SIMPLE)
		{
			TraySave.iMonitorSimple = IsDlgButtonChecked(hDlg, IDC_CHECK_MONITOR_SIMPLE);
			WriteReg();
			SetWH();
		}
		else if (LOWORD(wParam) == IDC_CHECK_USAGE)
		{
			TraySave.bMonitorUsage = IsDlgButtonChecked(hDlg, IDC_CHECK_USAGE);
			WriteReg();
			SetWH();
		}
		else if (LOWORD(wParam) == IDC_CHECK_MONITOR_PDH)
		{
			TraySave.bMonitorPDH = IsDlgButtonChecked(hDlg, IDC_CHECK_MONITOR_PDH);
			WriteReg();
		}
		else if (LOWORD(wParam) == IDC_CHECK_MONITOR_LEFT)
		{
			TraySave.bMonitorLeft = IsDlgButtonChecked(hDlg, IDC_CHECK_MONITOR_LEFT);
			WriteReg();
		}
		else if (LOWORD(wParam) == IDC_CHECK_MONITOR_FLOAT)
		{
			TraySave.bMonitorFloat = IsDlgButtonChecked(hDlg, IDC_CHECK_MONITOR_FLOAT);
			WriteReg();
			CloseTaskBar();
		}
		else if (LOWORD(wParam) == IDC_CHECK_TRANSPARENT)
		{
			TraySave.bMonitorTransparent = IsDlgButtonChecked(hDlg, IDC_CHECK_TRANSPARENT);
			OpenTaskBar();
			WriteReg();
		}
		else if (LOWORD(wParam) == IDC_CHECK_AUTORUN)
		{
			if (IsDlgButtonChecked(hDlg, IDC_CHECK_AUTORUN))
				AutoRun(TRUE, TRUE, szAppName);
			else
				AutoRun(TRUE, FALSE, szAppName);
		}
		else if (LOWORD(wParam) == IDC_RESTORE_DEFAULT)
		{
			DeleteFile(szTraySave);
			//			RegDeleteKey(HKEY_CURRENT_USER, szSubKey);
			SendMessage(hDlg, WM_COMMAND, IDCANCEL, 0);
		}
		else if (LOWORD(wParam) == IDCANCEL)
		{
			/*
						SendMessage(hMain, WM_TIMER, 11, 1000);
						DestroyWindow(hDlg);
						return (INT_PTR)TRUE;
			*/
			//			SendMessage(hReBarWnd, WM_SETREDRAW, TRUE, 0);
			bResetRun = TRUE;
			SendMessage(hMain, WM_CLOSE, NULL, NULL);
			return (INT_PTR)TRUE;
		}
		else if (LOWORD(wParam) == IDC_CLOSE)
		{
			SendMessage(hMain, WM_CLOSE, NULL, NULL);
		}
		else if (LOWORD(wParam) == IDC_BUTTON_FONT || LOWORD(wParam) == IDC_BUTTON_TIPS_FONT)
		{
			typedef UINT_PTR(CALLBACK* LPCFHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
			typedef struct tagCHOOSEFONTW {
				DWORD           lStructSize;
				HWND            hwndOwner;          // caller's window handle
				HDC             hDC;                // printer DC/IC or NULL
				LPLOGFONTW      lpLogFont;          // ptr. to a LOGFONT struct
				INT             iPointSize;         // 10 * size in points of selected font
				DWORD           Flags;              // enum. type flags
				COLORREF        rgbColors;          // returned text color
				LPARAM          lCustData;          // data passed to hook fn.
				LPCFHOOKPROC    lpfnHook;           // ptr. to hook function
				LPCWSTR         lpTemplateName;     // custom template name
				HINSTANCE       hInstance;          // instance handle of.EXE that
													//   contains cust. dlg. template
				LPWSTR          lpszStyle;          // return the style field here
													// must be LF_FACESIZE or bigger
				WORD            nFontType;          // same value reported to the EnumFonts
													//   call back with the extra FONTTYPE_
													//   bits added
				WORD            ___MISSING_ALIGNMENT__;
				INT             nSizeMin;           // minimum pt size allowed &
				INT             nSizeMax;           // max pt size allowed if
													//   CF_LIMITSIZE is used
			} CHOOSEFONT;
			TraySave.TraybarFont.lfHeight = TraySave.TraybarFontSize;
			TraySave.TipsFont.lfHeight = TraySave.TipsFontSize;
			CHOOSEFONT cf;
			cf.lStructSize = sizeof cf;
			cf.hwndOwner = hDlg;
			cf.hDC = NULL;
			if (LOWORD(wParam) == IDC_BUTTON_FONT)
				cf.lpLogFont = &TraySave.TraybarFont;
			else
				cf.lpLogFont = &TraySave.TipsFont;
			cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS;
			cf.nFontType = SCREEN_FONTTYPE;
			cf.rgbColors = RGB(0, 0, 0);
			typedef BOOL(WINAPI* pfnChooseFont)(CHOOSEFONT* lpcf);
			HMODULE hComdlg32 = LoadLibrary(L"comdlg32.dll");
			if (hComdlg32)
			{
				pfnChooseFont ChooseFont = (pfnChooseFont)GetProcAddress(hComdlg32, "ChooseFontW");
				if (ChooseFont)
				{
					if (ChooseFont(&cf))
					{
						if (LOWORD(wParam) == IDC_BUTTON_FONT)
						{
							TraySave.TraybarFontSize = TraySave.TraybarFont.lfHeight;
							otleft = -1;
							SetWH();
							AdjustWindowPos();
						}
						else
							TraySave.TipsFontSize = TraySave.TipsFont.lfHeight;
						WriteReg();
					}
				}
				FreeLibrary(hComdlg32);
			}
		}
		else if (LOWORD(wParam) == IDC_BUTTON_COLOR || (LOWORD(wParam) >= IDC_BUTTON_COLOR_BACKGROUND && LOWORD(wParam) <= IDC_BUTTON_COLOR_HIGH))
		{
			CHOOSECOLOR stChooseColor;
			stChooseColor.lStructSize = sizeof(CHOOSECOLOR);
			stChooseColor.hwndOwner = hDlg;
			if (LOWORD(wParam) == IDC_BUTTON_COLOR)
			{
				stChooseColor.rgbResult = TraySave.dAlphaColor[iProject];
				stChooseColor.lpCustColors = (LPDWORD)&TraySave.dAlphaColor[iProject];
			}
			else
			{
				stChooseColor.rgbResult = TraySave.cMonitorColor[LOWORD(wParam) - IDC_BUTTON_COLOR_BACKGROUND];
				stChooseColor.lpCustColors = TraySave.cMonitorColor;
			}
			stChooseColor.Flags = CC_RGBINIT | CC_FULLOPEN;
			stChooseColor.lCustData = 0;
			stChooseColor.lpfnHook = NULL;
			stChooseColor.lpTemplateName = NULL;
			typedef BOOL(WINAPI* pfnChooseColor)(LPCHOOSECOLOR lpcc);
			HMODULE hComdlg32 = LoadLibrary(L"comdlg32.dll");
			if (hComdlg32)
			{
				pfnChooseColor ChooseColor = (pfnChooseColor)GetProcAddress(hComdlg32, "ChooseColorW");
				if (ChooseColor)
				{
					if (ChooseColor(&stChooseColor))
					{
						if (LOWORD(wParam) == IDC_BUTTON_COLOR)
						{
							TraySave.dAlphaColor[iProject] = stChooseColor.rgbResult;
							DWORD bAlphaB = (int)SendDlgItemMessage(hDlg, IDC_SLIDER_ALPHA_B, TBM_GETPOS, 0, 0);
							bAlphaB = bAlphaB << 24;
							TraySave.dAlphaColor[iProject] = bAlphaB + (TraySave.dAlphaColor[iProject] & 0xffffff);
						}
						else
						{
							TraySave.cMonitorColor[LOWORD(wParam - IDC_BUTTON_COLOR_BACKGROUND)] = stChooseColor.rgbResult;
						}
						::InvalidateRect(GetDlgItem(hMain, LOWORD(wParam)), NULL, FALSE);
					}
				}
				FreeLibrary(hComdlg32);
			}
			WriteReg();
			//			SendMessage(hMain, WM_TRAYS, NULL, NULL);
		}
		break;
	}
	return (INT_PTR)FALSE;
}
INT_PTR CALLBACK ColorButtonProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)//颜色按钮控件过程
{
	switch (message)
	{
	case WM_PAINT:
	{
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hWnd, &ps);
		RECT rc;
		GetClientRect(hWnd, &rc);
		HBRUSH hb;
		int id = GetDlgCtrlID(hWnd);
		if (id >= IDC_BUTTON_COLOR_BACKGROUND && id <= IDC_BUTTON_COLOR_HIGH)
		{
			hb = CreateSolidBrush(TraySave.cMonitorColor[id - IDC_BUTTON_COLOR_BACKGROUND]);
		}
		else
			hb = CreateSolidBrush(TraySave.dAlphaColor[iProject] & 0xffffff);
		FillRect(hdc, &rc, hb);
		DeleteObject(hb);
		EndPaint(hWnd, &ps);
		return TRUE;
	}
	}
	return CallWindowProc(oldColorButtonPoroc, hWnd, message, wParam, lParam);
}

int DrawShadowText(HDC hDC, LPCTSTR lpString, int nCount, LPRECT lpRect, UINT uFormat)//绘制阴影文字
{
	//	COLORREF cColor = GetTextColor(hDC);
	//	return DrawShadowText(hDC, lpString, nCount, lpRect, uFormat, cColor, RGB(066, 66,66), 1, 1);	
	if (TraySave.cMonitorColor[0] == RGB(0, 0, 1))
	{
		COLORREF cColor = GetTextColor(hDC);
		SetTextColor(hDC, RGB(11, 11, 11));
		OffsetRect(lpRect, 1, 0);
		DrawText(hDC, lpString, nCount, lpRect, uFormat);
		OffsetRect(lpRect, 0, 1);
		DrawText(hDC, lpString, nCount, lpRect, uFormat);
		OffsetRect(lpRect, 1, 0);
		DrawText(hDC, lpString, nCount, lpRect, uFormat);
		OffsetRect(lpRect, 0, 1);
		DrawText(hDC, lpString, nCount, lpRect, uFormat);
		OffsetRect(lpRect, -2, -2);
		SetTextColor(hDC, cColor);
	}
	return DrawText(hDC, lpString, nCount, lpRect, uFormat);
}