lyfz_repos/经典版源码/lyfzddfClient/trunk/Client Trunk1/Global.cpp

// Global.cpp  : 应用程序的全局变量、函数源文件
//
// 代码生成在 2014年9月25日, 09:55

#include "StdAfx.h"
#include "Global.h"
#include <io.h>	// _access_s头文件;

#include "afxcoll.h"   
#include "afxtempl.h"   
#include "atlconv.h" 
#include <tlhelp32.h>
#include <WinSock.h>
#include "..\\lzari.h"
#include "..\helper\ffsco.h"

#include <shlwapi.h>
#pragma comment(lib,"shlwapi.lib")

#include <lm.h>
#pragma comment(lib,"Netapi32.lib")
#pragma comment(lib,"Advapi32.lib")

// 异地选片 [4/1/2015 lyfz]
//////////////////////////////////////////////////////////////////////////

BOOL g_bRemote = FALSE; 

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

HMODULE g_hlyfzMicroShareDLL = NULL;
lyfzCreateShare g_lyfzCreateShare = NULL;


// 升级包版本号;
WORD g_arrFileVersion[4] = { 0 };

TCHAR g_szLoginUser[MAX_PATH] = _T("");				// 当前软件的登陆用户名;
TCHAR g_szLoginPsw[MAX_PATH] = _T("");				// 当前软件的登陆密码;

TCHAR g_szModulePath[MAX_PATH] = _T("");			// 软件目录;
TCHAR g_szModuleFileName[MAX_PATH] = _T("");		// 软件全名称;
TCHAR g_szConnectString[MAX_PATH] = _T("");			// DB连接串;

// 主机信息;
TCHAR g_szHostComputerIP[MAX_PATH] = _T("");			// 服务端主机名称;
DWORD g_dwTCPChatPort;									// 服务端主机通信TCP端口;

// 数据库信息;
TCHAR g_szDBSource[MAX_PATH] = _T("");		// 数据库源(服务所在IP或计算机名);
TCHAR g_szDBSourcePort[MAX_PATH] = _T("");	// 数据库源端口;
DWORD g_dwDBServerPort = 0;					// 数据库源端口;
TCHAR g_szDBAccount[MAX_PATH] = _T("");		// 数据库登录用户;
TCHAR g_szDBPassWord[MAX_PATH] = _T("");	// 数据库登录密码;
TCHAR g_szDBName[MAX_PATH] = _T("");		// 数据库名称;	

// 相片存储目录;
TCHAR g_szShareHost[MAX_PATH] = _T("");					// 共享主机名;
TCHAR g_szOriginalFolder[MAX_PATH] = _T("");			// 原片目录;
TCHAR g_szOriginalBkFolder[MAX_PATH] = _T("");			// 原片备份目录;
TCHAR g_szEarlyRepairFolder[MAX_PATH] = _T("");			// 初修片目录;
TCHAR g_szEarlyRepairBkFolder[MAX_PATH] = _T("");		// 初修片备份目录;
TCHAR g_szFurtherRepairFolder[MAX_PATH] = _T("");		// 精修片目录;
TCHAR g_szFurtherRepairBkFolder[MAX_PATH] = _T("");		// 精修片备份目录;
TCHAR g_szDesignFolder[MAX_PATH] = _T("");				// 设计片目录;
TCHAR g_szDesignBkFolder[MAX_PATH] = _T("");			// 设计片备份目录;
TCHAR g_szTelRecordingFolder[MAX_PATH] = _T("");		// 电话录音目录;
TCHAR g_szFullDressImageFolder[MAX_PATH] = _T("");		// 礼服图片目录;

// 软件所用加密狗是否已注册;	// Jeff,应该放在SoftKey做为静态变量使用;
BOOL g_bSoftWareReg = FALSE;

// 加密狗中的字符信息S1:如 201409062003558789.ly.com
// 该全局变量在旧软件名称是：g_sdomain;
// 该变量在数据库表字段[path].[path1]中存储;
CString g_strDogMainInfo = "";

// 未知用途;
// 该全局变量在旧软件中名称是：CString g_bMain;
// 与集团版有关联性;
// 有可能是主店名称;
CString g_strMain = "";

// 分店名称数组;旧软件中名称：g_branchnamearray
CStringArray g_strArrayOfBranchName;

// ??
CStringArray g_strArrayOfBranchName2;

// 分店IP地址数组;
CStringArray g_strArrayOfBranchIPAdress;

// 分店的加密狗S1信息数组;
CStringArray g_strArrayOfBranchDogMainInfo;

// 座席版允许连接数(从加密狗中获取);
unsigned int g_nCountOfAllowToConn = 0;

DWORD g_nLeng = 0;
BYTE *g_pData = NULL;
DWORD g_nLeng2 = 0;
BYTE *g_pData2 = NULL;

SENDHEAD g_sendhead;

BOOL g_bRedSkin = 0;
COLORREF g_gridcol1 = RGB(204, 204, 204);
COLORREF g_gridcol2 = RGB(190, 190, 190);
COLORREF g_bkcol = RGB(184, 184, 184);

CString g_date;
CString g_title;
CArray<CStringArray, CStringArray>g_userarray;
CArray<CStringArray, CStringArray>g_cominfoarray;
CArray<CStringArray, CStringArray>g_cominfoarraylocal;
CArray<DWORD, DWORD>g_lengarray;
CArray<DWORD, DWORD>g_btnlengarray;
CArray<BYTE*, BYTE*>g_pointerarray;
CBrush g_editbkbrush;
DWORD g_btnleng[8];
int   g_btnlengpos = -1;
int  g_nYearpos = -1;
CString g_branchname = "";	// Jeff.集团版:????本分店名称;
CString g_branchip = "";
CString g_branchip2 = "";
BOOL g_bBranchModify = 0;


BOOL g_bShowOK = 0;	// Jeff:?
BOOL g_bStaffAchievementShow = 0;	// 此机用于员工业绩查看;
BOOL g_bSaveUploadTask1 = 0;
BOOL g_bSaveUploadTask2 = 0;
BOOL g_bSaveUploadTask3 = 0;
BOOL g_bSaveUploadTask4 = 0;
BOOL g_bSearchFilter = 0;
CString g_waiter1;
CString g_waiter2;
CString g_waiter3;
CString g_waiter4;
CString g_waiter5;
CString g_filterdate1;
CString g_filterdate2;
CString g_filterdate3;
CString g_filterdate4;
CString g_filterdate5;
CString g_filterdate6;
CString g_filterbranch;
USER g_user;
CString g_mainpath;				// 软件目录
CString g_id;					//
CString g_server;				// 服务端地址
CStringArray g_serverarray;		// 
CString g_serverbak;			// 
CString g_path1;				/* 共享目录 <客户原片(管理软件)$>			如:"\\lyfz-pc\客户原片(管理软件)$" */
CString g_path2;				/* 共享目录 <修好的片(管理软件)$>			如:"\\lyfz-pc\修好的片(管理软件)$" */
CString g_path3;				/* 共享目录 <设计好的片(管理软件$)>			如:""> */
CString g_path4;				/* 共享目录 <精修好的片(管理软件$)>			如:""> */
CString g_path5;				/* 共享目录 <礼服图片(管理软件$)>			如:""> */
CString g_path6;				/* 共享目录 <电话录音(管理软件$)>			如:""> */
CString g_path7;				/* 共享目录 <客户原片(管理软件$)\效果图>	如:""> */
CString g_path1bak;
CString g_path2bak;
CString g_path3bak;
CString g_path4bak;
CString g_path5bak;
CString g_path6bak;
CString g_path7bak;


CDatabase g_db;
DWORD g_ncount;
CFont g_titlefont;
DWORD g_nSendCode = 0;
BOOL g_bSendOK = 0;
CString g_temp;

CArray<CStringArray, CStringArray>g_hisyeararray;
CArray<CStringArray, CStringArray>g_brancharray;
CArray<CStringArray, CStringArray>g_oldclientarray;

BOOL g_bNoConnDlg = 0;

BOOL g_bInSkin = 0;
BOOL g_bGenBranchData = 0;

BOOL g_bSortAscending = FALSE;
CFont g_listctrlfont;
float g_fscalex;			// x坐标刻度
float g_fscaley;			// y坐标刻度
int g_screenwid;			// 桌面宽
int g_screenhei;			// 桌面高

float g_WidthScale2 = 1;
float g_HeightScale2 = 1;

RESDATA2 g_resdata2;
BOOL g_bAlphaWnd = 0;
BYTE g_bNeedDrawParent = 0;
BOOL g_bAllBranch = 0;
CString g_domain;
CString g_sInfo;
int g_ncot = 0;	// Jeff:订单总数(包含历史订单在内),该变量作用是当订单总数大于1000时,向公司服务器发送数据;
int g_conpos = 0;

int g_nAutoShowStaffAchievement = -1;
BOOL g_bShowBar = 1;
int g_bookingtype = 0;
BOOL g_bNoLoginLia = 0;
BOOL g_bConnLYFZ = 0;
BOOL g_bSendLYFZ = 0;
int g_ntimeout = 29000;
float g_WidthScale;
float g_HeightScale;
int g_dx = 0;
int g_dy = 0;
BOOL g_bNeedCoon = 1;		// remark by Jeff:是否需要重新连接服务端;
CStringArray g_menubranchname;
CArray<CStringArray, CStringArray>g_List1array;
CArray<CStringArray, CStringArray> g_aryOfSharePathInfo;		// NetShareInfo表记录;
/************************************************************************/
/*
Jeff：g_conntype
g_conntype == 0 :表示正常连接?(或是连接本地服务器?)
g_conntype == 1 :表示连接公司服务器(http://lijiafz.vicp.net)
g_conntype == 2 :http://www.lyfz.net/download/ip.txt
g_conntype == 3 :http://photo.bjlyfz.com/download/ip.txt
g_conntype == 4 :
*/
/************************************************************************/

int g_conntype = 0;//正常
//0 正常
//1 连接1
//2 连接2
//3 连接3
//4 连接4

//************************************//
// 数据库地址;
// 数据库端口;
// 数据库管理员账号;
// 数据库管理员密码;
// 数据库名称;
//
// [函数]：GetIniInfo
// [描述]：获取指定ini信息;
// [参数]：
//		szPath：ini所在目录;
//		szIniName：ini名;
// [返回]：void
//************************************//
int GetSysIniInfo(const char *szPath, const char *szIniName)
{
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFna[_MAX_DIR] = { 0 };
	TCHAR szExt[_MAX_DIR] = { 0 };
	::GetModuleFileName(NULL, g_szModuleFileName, sizeof(g_szModuleFileName) / sizeof(TCHAR));
	sprintf(g_szModulePath, _T("%s"), g_szModuleFileName);

	_tsplitpath(g_szModulePath, szDrive, szDir, szFna, szExt);
	_tcscpy(g_szModulePath, szDrive);
	_tcscat(g_szModulePath, szDir);

	// -----------------------------------------------------//
	TCHAR szFile[MAX_PATH + 1] = "";
	if (szPath != NULL && szIniName != NULL)
		wsprintf(szFile, _T("%s\\%s"), szPath, szIniName);
	else
		wsprintf(szFile, _T("%s\\HostInfo.ini"), g_szModulePath);

	TRACE("szFile =%s\n", szFile);

	OFSTRUCT ofStruct;
	OpenFile(szFile, &ofStruct, OF_EXIST);	// Jeff 这是为了兼容16位系统遗留的函数,不应该使用;
	if (ERROR_FILE_NOT_FOUND == GetLastError())
	{
		// 如果没找到,使用默认连接;
		strcpy(g_szHostComputerIP, _T("."));
		g_dwTCPChatPort = 5678;

		return -1;
	}

	// 获取服务器端TCP信息;
	GetPrivateProfileString(_T("HostComputerInfo"), _T("HostIP"), _T(""), g_szHostComputerIP, MAX_PATH, szFile);
	g_dwTCPChatPort = GetPrivateProfileInt(_T("HostComputerInfo"), _T("HostChatPort"), 0, szFile);

	return 0;
}

//----------------------------------------------------------
// 函数：IsFileExist
// 描述：判断某文件是否存在;
// 参数：
//		pFileFullName：	指定的文件名;
// 返回：TRUE表示文件存在;
//----------------------------------------------------------
BOOL IsFileExist(const TCHAR *pFileFullName)
{
	int err = 0;

	// Check for existence. 
	if ((err = _access(pFileFullName, 0)) == 0)
	{
		//printf_s( "File crt_access_s.c exists.\n" );

		// Check for write permission. 
		if ((err = _access(pFileFullName, 2)) == 0)
		{
			//printf_s( "File crt_access_s.c does have ""write permission.\n" );
		}
		else
		{
			//printf_s( "File crt_access_s.c does not have ""write permission.\n" );
		}
	}
	else
	{
		//printf_s( "File crt_access_s.c does not exist.\n" );
		return FALSE;
	}

	return TRUE;
}

// Pump messages while waiting for event
//----------------------------------------------------------
// 函数：WaitWithMessageLoop
// 描述：等待某内核事件触发;
// 参数：
//		hEvent：	被等待响应的内核事件对象;
//		nTimeout：	超时值;
// 返回：TRUE返回触发成功;
//----------------------------------------------------------
BOOL WaitWithMessageLoop(HANDLE hEvent, int nTimeout)
{
	DWORD dwRet = 0;

	while (1)
	{
		// wait for event or message, if it's a message, process it and return to waiting state
		dwRet = MsgWaitForMultipleObjects(1, &hEvent, FALSE, nTimeout, QS_ALLINPUT);
		if (dwRet == WAIT_OBJECT_0)
		{
			TRACE0("WaitWithMessageLoop() event triggered.\n");
			return TRUE;
		}
		else
			if (dwRet == WAIT_OBJECT_0 + 1)
			{
			// process window messages
			AfxGetApp()->PumpMessage();
			}
			else
				if (dwRet == WAIT_TIMEOUT)
				{
			// timed out !
			return FALSE;
				}
				else
				{
					// WAIT_ABANDONED_0 ...
					return TRUE;
				}
	}
}

//----------------------------------------------------------
// 函数：DeleteDirectory
// 描述：删除指定目录下的所有文件;
// 参数：strDir：指定要删除的文件目录;
// 返回：;
//----------------------------------------------------------
void DeleteDirectory(CString strDir)
{
	try
	{
		//   首先删除文件及子文件夹   
		CFileFind   ff;
		BOOL   bFound = ff.FindFile(strDir + "\\*", 0);
		while (bFound)
		{
			bFound = ff.FindNextFile();
			if (ff.GetFileName() == "." || ff.GetFileName() == "..")
				continue;
			//   去掉文件(夹)只读等属性   
			SetFileAttributes(ff.GetFilePath(), FILE_ATTRIBUTE_NORMAL);
			if (ff.IsDirectory())
			{   //   递归删除子文件夹   
				DeleteDirectory(ff.GetFilePath());
				RemoveDirectory(ff.GetFilePath());
			}
			else
			{
				DeleteFile(ff.GetFilePath());   //   删除文件   
			}
		}
		ff.Close();
		//   然后删除该文件夹   
		RemoveDirectory(strDir);
	}
	catch (...)
	{
		//WriteLogin("出错在函数deldir中");
	}
	//	int SHFileOperation( LPSHFILEOPSTRUCT   lpFileOp   );   
}

// Jeff.注册控件函数;2014.09.11
//----------------------------------------------------------
// 函数：RegisterOcx
// 描述：注册指定的组件文件;
// 参数：ocxfile指定要注册的组件文件名;
// 返回：TRUE表示注册成功;
//----------------------------------------------------------
BOOL RegisterOcx(LPCTSTR ocxfile)
{
	HKEY hKey;
	bool bRet;
	USES_CONVERSION;
	ITypeLib* pTypeLib;
	CString CLSIDStr;
	CLSID clsid;
	LPOLESTR wRes = NULL;
	if (LoadTypeLib(T2OLE(ocxfile), &pTypeLib) == S_OK)
	{
		TLIBATTR tlibAttr, *ptlibAttr;
		ptlibAttr = &tlibAttr;
		pTypeLib->GetLibAttr(&ptlibAttr);
		clsid = ptlibAttr->guid;
		pTypeLib->Release();
	}
	::StringFromCLSID(clsid, &wRes);
	CLSIDStr = OLE2CT(wRes);
	if ((RegOpenKeyEx(HKEY_CLASSES_ROOT, "CLSID\\" + CLSIDStr, 0, KEY_READ, &hKey) == ERROR_SUCCESS) || (RegOpenKeyEx(HKEY_CLASSES_ROOT, "Wow6432Node\\TypeLib\\" + CLSIDStr, 0, KEY_READ, &hKey) == ERROR_SUCCESS))
	{
		return true;
	}
	else
	{
		HINSTANCE hLib = LoadLibrary(ocxfile);
		if (hLib < (HINSTANCE)HINSTANCE_ERROR)
		{
			MessageBox(0, "权限不足,不能载入OCX文件！无法注册控件！", "结果", MB_OK);
			bRet = false;
		}
		else
		{
			FARPROC lpDllEntryPoint;
			lpDllEntryPoint = GetProcAddress(hLib, _T("DllRegisterServer"));
			if (lpDllEntryPoint != NULL)
			{
				if (FAILED((*lpDllEntryPoint)()))
				{
					MessageBox(0, "调用注册函数（DllRegisterServer）失败！无法注册控件！", "结果", MB_OK);
					bRet = false;
				}
				else
					bRet = true;
			}
			else
			{
				MessageBox(0, "调用注册函数（DllRegisterServer）失败！无法注册控件！", "结果", MB_OK);
				bRet = false;
			}
		}
		FreeLibrary(hLib);
		return bRet;
	}
}

// Jeff.Hacker. WINDOWS NT 以上的内核需要提权,才能对系统进行高级管理;
//----------------------------------------------------------
// 函数：GetDebugPriv
// 描述：对程序提权;
// 参数：
// 返回：TRUE表示程序提权成功;
//----------------------------------------------------------
BOOL GetDebugPriv()
{
	// 返回的访问令牌指针;
	HANDLE	hToken;
	// 接收所返回的制定特权名称的信息;
	LUID	sedebugnameValue;
	// 新特权信息的指针(结构体);
	TOKEN_PRIVILEGES tkp;
	DWORD	dwCurProcId = GetCurrentProcessId();
	// 要修改访问权限的进程句柄;
	HANDLE	hCurProc;
	hCurProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwCurProcId);

	if (!::OpenProcessToken(hCurProc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
	{
		ShowSystemErrorInfo(CString("提权OpenProcessToken失败。"), GetLastError());
		return FALSE;
	}

	if (!::LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue))
	{
		ShowSystemErrorInfo(CString("提权LookupPrivilegeValue失败。"), GetLastError());
		CloseHandle(hToken);
		return FALSE;
	}

	tkp.PrivilegeCount = 1;
	tkp.Privileges[0].Luid = sedebugnameValue;
	tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

	if (!::AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL))
	{
		ShowSystemErrorInfo(CString("提权AdjustTokenPrivileges失败。"), GetLastError());
		CloseHandle(hToken);
		return FALSE;
	}

	CloseHandle(hCurProc);
	CloseHandle(hToken);
	return TRUE;
}

//----------------------------------------------------------
// 函数：GetFileVersion
// 描述：获取指定模块的文件版本信息
// 参数：
//		hModule:	指定的模块（如果为NULL,表示获取自身文件版本信息）;
//		pBuffer：	返回的文件版本信息;
// 
// 返回：TRUE表示获取模块文件版本信息成功;
//----------------------------------------------------------
bool GetFileVersion(HMODULE hModule, WORD *pBuffer)
{
	TCHAR fname[MAX_PATH];
	VS_FIXEDFILEINFO *pVi;
	DWORD dwHandle;
	std::string str;

	if (::GetModuleFileName(hModule, fname, MAX_PATH))
	{
		int size = GetFileVersionInfoSize(fname, &dwHandle);

		if (size > 0)
		{
			BYTE *buffer = new BYTE[size];
			memset(buffer, 0, size);

			if (GetFileVersionInfo(fname, dwHandle, size, buffer))
			{
				if (VerQueryValue(buffer, _T("\\"), (LPVOID *)&pVi, (PUINT)&size))
				{
#if 0
					pBuffer[0] = HIWORD(pVi->dwFileVersionMS);
					pBuffer[1] = LOWORD(pVi->dwFileVersionMS);
					pBuffer[2] = HIWORD(pVi->dwFileVersionLS);
					pBuffer[3] = LOWORD(pVi->dwFileVersionLS);
#else
					pBuffer[0] = HIWORD(pVi->dwProductVersionMS);
					pBuffer[1] = LOWORD(pVi->dwProductVersionMS);
					pBuffer[2] = HIWORD(pVi->dwProductVersionLS);
					pBuffer[3] = LOWORD(pVi->dwProductVersionLS);
#endif

					delete buffer;
					return true;
				}
			}

			delete buffer;
		}
	}

	return false;
}

//----------------------------------------------------------
// 函数：CheckInternalIP
// 描述：判断IP(网络字节序)地址是否为外网地址;
// 参数：ip_addr:主机IP（必须为网络字节序）;
// 
// 返回：TRUE表示主机IP为外网IP; FALSE表示内网IP;
//----------------------------------------------------------
BOOL CheckInternalIPV4(const unsigned int &ip_addr)
{
	// 三段保留IP段，做为私有地址，不在在公网上使用，只作内网IP;
	// A类：10.0.0.0 ~ 10.255.255.255		= 0A.00.00.00 ~ 0A.FF.FF.FF
	// B类：172.16.0.0 ~ 172.31.255.255		= AC.10.00.00 ~ AC.1F.FF.FF
	// C类：192.168.0.0 ~ 192.168.255.255	= C0.A8.00.00 ~ C0.A8.FF.FF
	// D类：127.0.0.0 ~ 127.255.255.255		= 7F.00.00.00 ! 7F.FF.FF.FF	(环回地址)
#if 0
	//检查3类地址是否属于公网;
	if ((ip_addr >= 0x0A000000 && ip_addr <= 0x0AFFFFFF) ||
		(ip_addr >= 0xAC100000 && ip_addr <= 0xAC1FFFFF) ||
		(ip_addr >= 0xC0A80000 && ip_addr <= 0xC0A8FFFF)
		)
	{
		return FALSE;
	}
	return TRUE;
#endif

#if 0
	//检查3类地址是否属于内网;
	// 0xa -- "10.0.0.0">>24; 
	// 0xc0a8--"192.168.0.0.">>16; 
	// 0x2b0--"127.17.0.1">>22
	if ((ip_addr >> 24 == 0xa) || (ip_addr >> 16 == 0xc0a8) || (ip_addr >> 22 == 0x2b0))
		return FALSE;
	else
		return TRUE;
#endif

#if 1
	// 回环地址也算进去！
	if ((ip_addr >> 24 == 0x0A) || (ip_addr >> 20 == 0xAC1) || (ip_addr >> 16 == 0xC0A8) || (ip_addr >> 26 == 0x7))
		return FALSE;
	else
		return TRUE;
#endif

}

//----------------------------------------------------------
// 函数：IsValidIPV4
// 描述：判断字符串是否是有效的IPV4;
// 参数：szIP:主机IP;
// 
// 返回：TRUE表示字符串为有效的IPV4;
//----------------------------------------------------------
BOOL IsValidIPV4(const TCHAR *szIP)
{
	int nIndex = 0;
	int nPointCount = 0;	// "."IPV4有3个;
	int nLen = strlen(szIP);
	for (int i = 0; i < nLen; i++)
	{
		if (szIP[i] == '.')
		{
			if (i == 0 || i == nLen - 1)
			{
				return FALSE;
			}
			else
			{
				if (++nIndex != i)
				{
					nIndex = i;
					nPointCount++;
				}
				else
					return FALSE;
			}
			continue;
		}

		if (isdigit(szIP[i]) == 0)
			return FALSE;
	}

	if (nPointCount != 3)
		return FALSE;

	return TRUE;
}

//----------------------------------------------------------
// 函数：GetHostAllOfIP
// 描述：返回指定主机名称的所有IPV4地址;
// 参数：
//		pHostName:	主机名;
//		vtHostIPV4：指定主机名的所有IPV4地址;
// 
// 返回：TRUE表示字符串为有效的IPV4;
//----------------------------------------------------------
int GetHostAllOfIP(const TCHAR *pHostName, std::vector<std::string> &vtHostIPV4)
{
#if 0
	WSADATA wsa = { 0 };
	WSAStartup(MAKEWORD(2, 2), &wsa);
#endif

#if 0	// YLGL项目使用不了,因为包含了旧的系统头文件;
	addrinfo hint, *answer, *curr;
	memset(&hint, 0, sizeof(addrinfo));
	hint.ai_family = AF_INET;
	hint.ai_socktype = SOCK_STREAM;

	int nRet = GetAddrInfo(pHostName, NULL, &hint, &answer);
	//int nRet = GetAddrInfo(pHostName, "5678", &hint, &answer);
	if (nRet != 0)
	{
		DWORD dwError = GetLastError();
		return;
	}

	TCHAR szIP[MAX_PATH];
	for (curr = answer; curr != NULL; curr = curr->ai_next)
	{
		//std::string ipstr;
		memset(szIP, 0, MAX_PATH);
		inet_ntop(AF_INET, &(((sockaddr_in*)(curr->ai_addr))->sin_addr), szIP, MAX_PATH);
		vtHostIPV4.push_back(szIP);
	}

	freeaddrinfo(answer);
#endif

	return 0;
}


void DataToArray(CArray<CStringArray, CStringArray>*pArrayOfString, int datapos)
{
	try
	{
		pArrayOfString->RemoveAll();
		if (g_nLeng == 0)
		{
			return;
		}

		// 1.code[0]数组：用作发送时,存储着操作指令;用作接收时,存储着接收数据大小???;
		if (g_sendhead.code[0])
		{
			// 1.1.将g_pData全局变量里保存的数据进行解压,并存储在lpszOut数组里;
			BYTE *lpszOut = NULL;
			int nOutSize = 0;
			LZARI Lzari;
			Lzari.UnCompress(g_pData, g_nLeng, lpszOut, nOutSize);

			// 1.2.将解压后的数据lpszOut附加到内存文件里;
			CMemFile memfile;
			memfile.Attach(lpszOut, nOutSize);
			Lzari.Release();

			// 1.3.将内存文件序列化保存到CArchive对象里;
			CArchive ar(&memfile, CArchive::load);
			pArrayOfString->SetSize(g_sendhead.count[0]);

			// 1.4.将CArchive对象里的数据,序列化到指定的CArray对象里;
			for (int ii = 0; ii < pArrayOfString->GetSize(); ii++)
			{
				pArrayOfString->ElementAt(ii).Serialize(ar);
			}

			// 1.5.完成数据的导出任务,释放内存;
			ar.Close();
			memfile.Detach();
		}
		else
		{
			CMemFile memfile;
			memfile.Attach(g_pData, g_nLeng);
			CArchive ar(&memfile, CArchive::load);
			pArrayOfString->SetSize(g_sendhead.count[0]);
			for (int ii = 0; ii < pArrayOfString->GetSize(); ii++)
			{
				pArrayOfString->ElementAt(ii).Serialize(ar);
			}
			ar.Close();
			memfile.Detach();
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[2] = { pArrayOfString1, pArrayOfString2 };
		DWORD bytereads = 0;
		for (int i = 0; i < 2; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)
				continue;
			if (g_sendhead.code[i])
			{
				// 1.1.将g_pData全局变量里保存的数据进行解压,并存储在lpszOut数组里;
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);

				// 1.2.将解压后的数据lpszOut附加到内存文件里;
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();

				// 1.3.将内存文件序列化保存到CArchive对象里;
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);

				// 1.4.将CArchive对象里的数据,序列化到指定的CArray对象里;
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}

				// 1.5.完成数据的导出任务,释放内存;
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[3] = { pArrayOfString1, pArrayOfString2, pArrayOfString3 };
		DWORD bytereads = 0;
		for (int i = 0; i < 3; i++)
		{
			parray[i]->RemoveAll(); if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[4] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4
		};
		DWORD bytereads = 0;
		for (int i = 0; i < 4; i++)
		{
			parray[i]->RemoveAll(); if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	CArray<CStringArray, CStringArray>*pArrayOfString5,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[5] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4,
			pArrayOfString5
		};
		DWORD bytereads = 0;
		for (int i = 0; i < 5; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)
				continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];

				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	CArray<CStringArray, CStringArray>*pArrayOfString5,
	CArray<CStringArray, CStringArray>*pArrayOfString6,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[6] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4,
			pArrayOfString5,
			pArrayOfString6
		};

		DWORD bytereads = 0;
		for (int i = 0; i < 6; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	CArray<CStringArray, CStringArray>*pArrayOfString5,
	CArray<CStringArray, CStringArray>*pArrayOfString6,
	CArray<CStringArray, CStringArray>*pArrayOfString7,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[7] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4,
			pArrayOfString5,
			pArrayOfString6,
			pArrayOfString7
		};
		DWORD bytereads = 0;
		for (int i = 0; i < 7; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	CArray<CStringArray, CStringArray>*pArrayOfString5,
	CArray<CStringArray, CStringArray>*pArrayOfString6,
	CArray<CStringArray, CStringArray>*pArrayOfString7,
	CArray<CStringArray, CStringArray>*pArrayOfString8,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[8] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4,
			pArrayOfString5,
			pArrayOfString6,
			pArrayOfString7,
			pArrayOfString8
		};

		DWORD bytereads = 0;
		for (int i = 0; i < 8; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

void DataToArray(
	CArray<CStringArray, CStringArray>*pArrayOfString1,
	CArray<CStringArray, CStringArray>*pArrayOfString2,
	CArray<CStringArray, CStringArray>*pArrayOfString3,
	CArray<CStringArray, CStringArray>*pArrayOfString4,
	CArray<CStringArray, CStringArray>*pArrayOfString5,
	CArray<CStringArray, CStringArray>*pArrayOfString6,
	CArray<CStringArray, CStringArray>*pArrayOfString7,
	CArray<CStringArray, CStringArray>*pArrayOfString8,
	CArray<CStringArray, CStringArray>*pArrayOfString9,
	CArray<CStringArray, CStringArray>*pArrayOfString10,
	int datapos)
{
	try
	{
		CArray<CStringArray, CStringArray>*parray[10] =
		{
			pArrayOfString1,
			pArrayOfString2,
			pArrayOfString3,
			pArrayOfString4,
			pArrayOfString5,
			pArrayOfString6,
			pArrayOfString7,
			pArrayOfString8,
			pArrayOfString9,
			pArrayOfString10
		};
		DWORD bytereads = 0;
		for (int i = 0; i < 10; i++)
		{
			parray[i]->RemoveAll();
			if (g_sendhead.length[i] == 0)continue;
			if (g_sendhead.code[i])
			{
				BYTE *lpszOut = NULL;
				int nOutSize = 0;
				LZARI Lzari;
				Lzari.UnCompress(g_pData + bytereads, g_sendhead.length[i], lpszOut, nOutSize);
				CMemFile memfile;
				memfile.Attach(lpszOut, nOutSize);
				Lzari.Release();
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
			else
			{
				CMemFile memfile;
				memfile.Attach(g_pData + bytereads, g_sendhead.length[i]);
				bytereads += g_sendhead.length[i];
				CArchive ar(&memfile, CArchive::load);
				parray[i]->SetSize(g_sendhead.count[i]);
				for (int ii = 0; ii < parray[i]->GetSize(); ii++)
				{
					parray[i]->ElementAt(ii).Serialize(ar);
				}
				ar.Close();
				memfile.Detach();
			}
		}
	}
	catch (...)
	{
	}
}

// 从缓存中加载图片;
void LoadImageFromBuf(Bitmap **img, BYTE *pData, DWORD leng)
{
	try
	{
		if (pData == NULL)return;
		if (*img)delete *img;
		*img = NULL;
		// Allocate global memory on which to create stream
		HGLOBAL m_hMem = GlobalAlloc(GMEM_MOVEABLE, leng);
		if (m_hMem == NULL)return;
		BYTE* pmem = (BYTE*)GlobalLock(m_hMem);
		memcpy(pmem, pData, leng);
		IStream* pstm;
		CreateStreamOnHGlobal(m_hMem, TRUE, &pstm);
		// load from stream
		*img = Gdiplus::Bitmap::FromStream(pstm);
		// free/release stuff
		GlobalUnlock(m_hMem);
		pstm->Release();
	}
	catch (...)
	{
	}
}

void LoadImageFromFile(Image **img, CString path)
{
	try
	{
		if (!PathFileExists(path))return;
		if (*img)delete *img;
		*img = NULL;
		BSTR bstr = path.AllocSysString();
		*img = Image::FromFile(bstr);
		SysFreeString(bstr);
	}
	catch (...)
	{
	}
}

void LoadImageFromFile(Bitmap **img, CString path)
{
	try
	{
		if (!PathFileExists(path))return;
		if (*img)delete *img;
		*img = NULL;
		BSTR bstr = path.AllocSysString();
		*img = Bitmap::FromFile(bstr);
		SysFreeString(bstr);
	}
	catch (...)
	{
	}
}

void LoadImageFromBuf(Image **img, BYTE *pData, DWORD leng)
{
	try
	{
		if (pData == NULL)return;
		if (*img)delete *img;
		*img = NULL;
		// Allocate global memory on which to create stream
		HGLOBAL m_hMem = GlobalAlloc(GMEM_MOVEABLE, leng);
		if (m_hMem == NULL)return;
		BYTE* pmem = (BYTE*)GlobalLock(m_hMem);
		memcpy(pmem, pData, leng);
		IStream* pstm;
		CreateStreamOnHGlobal(m_hMem, TRUE, &pstm);
		// load from stream
		*img = Gdiplus::Image::FromStream(pstm);
		// free/release stuff
		GlobalUnlock(m_hMem);
		pstm->Release();
	}
	catch (...)
	{
	}
}

void LoadImageFromBuf(Image **img, CString path)
{
	try
	{
		CFile fp;
		if (fp.Open(path, CFile::modeRead))
		{
			DWORD leng = fp.GetLength();
			BYTE *pData = new BYTE[leng];
			fp.Read(pData, leng);
			fp.Close();
			LoadImageFromBuf(img, pData, leng);
			delete[]pData;
		}
	}
	catch (...)
	{
	}
}

void LoadImageFromBuf(Bitmap **img, CString path)
{
	try
	{
		CFile fp;
		if (fp.Open(path, CFile::modeRead))
		{
			DWORD leng = fp.GetLength();
			BYTE *pData = new BYTE[leng];
			fp.Read(pData, leng);
			fp.Close();
			LoadImageFromBuf(img, pData, leng);
			delete[]pData;
		}
	}
	catch (...)
	{
	}
}

void LoadImageFromRes(Image **img, LPCTSTR lpszResourceName, LPCTSTR ResourceType)
{
	try
	{
		HGLOBAL  hGlobal = NULL;
		HRSRC  hSource = NULL;
		LPVOID  lpVoid = NULL;
		int   nSize = 0;
		BOOL  bResult = FALSE;
		hSource = FindResource(NULL, lpszResourceName, ResourceType);
		if (hSource == NULL)return;
		hGlobal = LoadResource(NULL, hSource);
		if (hGlobal == NULL)return;
		lpVoid = LockResource(hGlobal);
		if (lpVoid == NULL)return;

		nSize = (UINT)SizeofResource(NULL, hSource);
		LoadImageFromBuf(img, (BYTE*)hGlobal, nSize);
		UnlockResource(hGlobal); // 16Bit Windows Needs This
		FreeResource(hGlobal); // 16Bit Windows Needs This (32Bit - Automatic Release)
	}
	catch (...)
	{
	}
}

int GetOrientation(Image *image)
{
	try
	{
		if (image)
		{
			UINT totalBufferSize;
			UINT numProperties;
			image->GetPropertySize(&totalBufferSize, &numProperties);
			// Allocate the buffer that will receive the property items.
			PropertyItem* pAllItems = (PropertyItem*)malloc(totalBufferSize);
			// Fill the buffer.
			image->GetAllPropertyItems(totalBufferSize, numProperties, pAllItems);
			// Print the id data member of each property item.
			for (UINT j = 0; j < numProperties; ++j)
			{
				if (PropertyTagOrientation == pAllItems[j].id)
				{
					short* ptrLong = (short*)(pAllItems[j].value);
					int ret = (int)*ptrLong;
					free(pAllItems);
					return ret;
				}
			}
			free(pAllItems);
		}
	}
	catch (...)
	{
	}
	return 1;
}

int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
{
	UINT  num = 0;          // number of image encoders
	UINT  size = 0;         // size of the image encoder array in bytes

	ImageCodecInfo* pImageCodecInfo = NULL;

	GetImageEncodersSize(&num, &size);
	if (size == 0)
		return -1;  // Failure

	pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
	if (pImageCodecInfo == NULL)
		return -1;  // Failure

	GetImageEncoders(num, size, pImageCodecInfo);

	for (UINT j = 0; j < num; ++j)
	{
		if (wcscmp(pImageCodecInfo[j].MimeType, format) == 0)
		{
			*pClsid = pImageCodecInfo[j].Clsid;
			free(pImageCodecInfo);
			return j;  // Success
		}
	}
	free(pImageCodecInfo);
	return -1;  // FailureFailure
}

void SaveImageToFile(Image *img, CString path)
{
	try
	{
		if (img == NULL)return;
		CLSID   encoderClsid;
		BSTR bstr = path.AllocSysString();
		path.MakeLower();
		if (path.Right(3) == "bmp")
		{
			GetEncoderClsid(L"image/bmp", &encoderClsid);
			img->Save(bstr, &encoderClsid, NULL);
		}
		else if (path.Right(3) == "png")
		{
			GetEncoderClsid(L"image/png", &encoderClsid);
			img->Save(bstr, &encoderClsid, NULL);
		}
		else// if(path.Right (3)=="jpg")
		{
			GetEncoderClsid(L"image/jpeg", &encoderClsid);
			EncoderParameters encoderParameters;
			ULONG             quality;
			encoderParameters.Count = 1;
			encoderParameters.Parameter[0].Guid = EncoderQuality;
			encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
			encoderParameters.Parameter[0].NumberOfValues = 1;
			// Save the image as a JPEG with quality level 100.
			quality = 100;
			encoderParameters.Parameter[0].Value = &quality;
			img->Save(bstr, &encoderClsid, &encoderParameters);
		}
		SysFreeString(bstr);
	}
	catch (...)
	{
	}
}

void SaveImageToFile2(Image *img, CString path, ULONG quality)
{
	try
	{
		if (img == NULL)return;
		CLSID   encoderClsid;
		BSTR bstr = path.AllocSysString();
		path.MakeLower();
		if (path.Right(3) == "bmp")
		{
			GetEncoderClsid(L"image/bmp", &encoderClsid);
			img->Save(bstr, &encoderClsid, NULL);
		}
		else if (path.Right(3) == "png")
		{
			GetEncoderClsid(L"image/png", &encoderClsid);
			img->Save(bstr, &encoderClsid, NULL);
		}
		else// if(path.Right (3)=="jpg")
		{
			GetEncoderClsid(L"image/jpeg", &encoderClsid);
			EncoderParameters encoderParameters;
			encoderParameters.Count = 1;
			encoderParameters.Parameter[0].Guid = EncoderQuality;
			encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
			encoderParameters.Parameter[0].NumberOfValues = 1;
			// Save the image as a JPEG with quality level 100.
			encoderParameters.Parameter[0].Value = &quality;
			img->Save(bstr, &encoderClsid, &encoderParameters);
		}
		SysFreeString(bstr);
	}
	catch (...)
	{
	}
}

void IsWaiter2(CString id, CString name, CArray<CStringArray, CStringArray>*waiterarray, BOOL &bWait1, BOOL &bWait2, float &fscale1, float &fscale2, BOOL bCheckDate, CString date1, CString date2)
{
	for (int i = 0; i < waiterarray->GetSize(); i++)
	{
		if (id == waiterarray->ElementAt(i).ElementAt(0))
		{
			if (bCheckDate)
			{
				if (waiterarray->ElementAt(i).ElementAt(21) < date1 || waiterarray->ElementAt(i).ElementAt(21) > date2 || waiterarray->ElementAt(i).ElementAt(22) != "OK")
				{
					bWait1 = bWait2 = 0;
					return;
				}
			}
			if (name == waiterarray->ElementAt(i).ElementAt(1))
			{
				bWait1 = 1;
				fscale1 = atof(waiterarray->ElementAt(i).ElementAt(5)) / 100.0;
				if (fscale1 == 0)fscale1 = 1;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(2))
			{
				bWait1 = 1;
				fscale1 = atof(waiterarray->ElementAt(i).ElementAt(6)) / 100.0;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(3))
			{
				bWait1 = 1;
				fscale1 = atof(waiterarray->ElementAt(i).ElementAt(7)) / 100.0;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(4))
			{
				bWait1 = 1;
				fscale1 = atof(waiterarray->ElementAt(i).ElementAt(8)) / 100.0;
			}
			///////////////////////////////////////////////////////////////////////
			if (name == waiterarray->ElementAt(i).ElementAt(9))
			{
				bWait2 = 1;
				fscale2 = atof(waiterarray->ElementAt(i).ElementAt(13)) / 100.0;
				if (fscale2 == 0)fscale2 = 1;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(10))
			{
				bWait2 = 1;
				fscale2 = atof(waiterarray->ElementAt(i).ElementAt(14)) / 100.0;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(11))
			{
				bWait2 = 1;
				fscale2 = atof(waiterarray->ElementAt(i).ElementAt(15)) / 100.0;
			}
			else if (name == waiterarray->ElementAt(i).ElementAt(12))
			{
				bWait2 = 1;
				fscale2 = atof(waiterarray->ElementAt(i).ElementAt(16)) / 100.0;
			}
			return;
		}
	}
	return;
}

void IsWaiter3(CString id, CString name, CArray<CStringArray, CStringArray>*waiterarray, BOOL &bWait1, BOOL &bWait2, float &fscale1, float &fscale2)
{
	bWait1 = bWait2 = 0;
	for (int i = 0; i < waiterarray->GetSize(); i++)
	{
		if (id == waiterarray->ElementAt(i).ElementAt(0))
		{
			if (name == waiterarray->ElementAt(i).ElementAt(17))
			{
				bWait1 = 1;
				fscale1 = atof(waiterarray->ElementAt(i).ElementAt(19)) / 100.0;
				if (fscale1 == 0)fscale1 = 1;
			}
			///////////////////////////////////////////////////////////////////////
			if (name == waiterarray->ElementAt(i).ElementAt(18))
			{
				bWait2 = 1;
				fscale2 = atof(waiterarray->ElementAt(i).ElementAt(20)) / 100.0;
			}
			return;
		}
	}
	return;
}

//------------------------------------------------------------------------------
// Remark by Jeff;
// 函数：CheckPhoneType
// 描述：判断手机号属于哪个运营商的;
// 参数：
//		phoneno:	欲判断的手机号;
//
// 返回：返回0表示移动; 1表示联通; 2表示电信; 3表示小灵通; -1表示未知的;
//
// 注意：
// 移动:
// 139, 138, 137, 136, 135, 134, 159, 158, 152, 151, 150, 157, 188, 187, 144
// 联通:
// 130, 131, 132, 155, 156, 186, 185
// 电信 :
// 133, 153, 189, 180, 181
//------------------------------------------------------------------------------
int CheckPhoneType(CString &phoneno)
{
	if (phoneno.IsEmpty())
		return -1;
	for (int i = 0; i < phoneno.GetLength(); i++)
	{
		if (phoneno.GetAt(i) < '0' || phoneno.GetAt(i) > '9')return -1;
	}
	if (phoneno.GetAt(0) == '1')
	{
		if (phoneno.GetLength() != 11)
			return -1;
		int mobile[] = { 139, 138, 137, 136, 135, 134, 159, 158, 152, 151, 150, 157, 188, 187, 144, 182, 147, 183, 184, 178 };
		int unicom[] = { 130, 131, 132, 155, 156, 186, 185, 176 };
		int telecom[] = { 133, 153, 189, 180, 181, 177 };
		int others[] = { 170 };

		for (i = 0; i < sizeof(mobile) / sizeof(int); i++)
		{
			if (mobile[i] == atoi(phoneno.Left(3)))
			{
				return 0;
			}
		}
		for (i = 0; i < sizeof(unicom) / sizeof(int); i++)
		{
			if (unicom[i] == atoi(phoneno.Left(3)))
			{
				return 1;
			}
		}
		for (i = 0; i < sizeof(telecom) / sizeof(int); i++)
		{
			if (telecom[i] == atoi(phoneno.Left(3)))
			{
				return 2;
			}
		}
		for (i = 0; i < sizeof(others)/sizeof(int);i++)
		{
			if ( others[i] == atoi((phoneno.Left(3))))
			{
				return 3;
			}
		}
		return -1;
	}
	return -1;
}

BOOL CheckDateOK(CString &str)
{
	if (str.IsEmpty())return 1;
	CString tip;
	int i;
	CString demo = CTime::GetCurrentTime().Format("%Y-%m-%d");
	if (str.GetLength() != demo.GetLength())
		goto ll;
	//2009-01-01
	if (str.GetAt(4) != '-')
		goto ll;
	if (str.GetAt(7) != '-')
		goto ll;
	for (i = 0; i < str.GetLength(); i++)
	{
		if (i == 4 || i == 7)continue;
		if (str.GetAt(i) < '0' || str.GetAt(i) > '9')
			goto ll;
	}

	return 1;
ll:
	tip.Format("日期:%s格式错误!\r\n样板:%s", str, demo);
	AfxMessageBox(tip, MB_ICONSTOP);
	return 0;
}

BOOL CheckBadWords(CString str, BOOL bMsg)
{
	CString badwords[165] = { \
		"【call5.me】", \
		"您可拨020", \
		"88btt.com热线400611", \
		"400678165", \
		"海王星", \
		"博天堂", \
		"十八大", \
		"钓鱼岛", \
		"无限次数提款", \
		"广东地和", \
		"利来", \
		"抢劫", \
		"fa lun", \
		"强奸", \
		"dafa", \
		"falun", \
		"SIM卡抽奖", \
		"罢工", \
		"罢课", \
		"暴乱", \
		"婊子", \
		"操你", \
		"操你娘", \
		"蠢猪", \
		"达赖", \
		"打倒", \
		"大法", \
		"大纪元", \
		"弹药", \
		"钓鱼岛", \
		"东突", \
		"东突厥斯坦伊斯兰运动", \
		"发抡", \
		"发仑", \
		"发伦", \
		"发囵", \
		"发沦", \
		"发纶", \
		"发轮", \
		"发论", \
		"法 轮 功", \
		"法.轮.功", \
		"法抡", \
		"法仑", \
		"法伦", \
		"法囵", \
		"法沦", \
		"法纶", \
		"法轮", \
		"法论", \
		"反革命", \
		"反日", \
		"分裂", \
		"干你娘", \
		"功友", \
		"古怪歌", \
		"国研新闻邮件", \
		"黑庄", \
		"宏志", \
		"洪志", \
		"胡锦涛", \
		"鸡巴", \
		"鸡毛信文汇", \
		"妓女", \
		"简鸿章", \
		"江八点", \
		"江独裁", \
		"江泽民", \
		"疆独", \
		"教徒", \
		"锦涛", \
		"靖国神社", \
		"九、评", \
		"九.评", \
		"九码", \
		"九-评", \
		"拉丹", \
		"拉登", \
		"李鹏", \
		"联总之声传单", \
		"灵动卡", \
		"六合彩", \
		"六码", \
		"吕秀莲", \
		"绿色环保手机", \
		"美国之音", \
		"猛料", \
		"迷药", \
		"民运", \
		"民猪", \
		"嫖娼", \
		"迫害", \
		"枪支", \
		"强奸", \
		"窃听器", \
		"人民报", \
		"人民报讯", \
		"人民大众时事参考", \
		"人民内情真相", \
		"人民真实报道", \
		"人权", \
		"日你妈", \
		"日他", \
		"三码", \
		"三陪", \
		"色情", \
		"傻B", \
		"涉日", \
		"十六大", \
		"示威", \
		"他妈的", \
		"台*湾", \
		"特等奖", \
		"天葬", \
		"突厥斯坦", \
		"推翻", \
		"王八蛋", \
		"温家宝", \
		"无能", \
		"香港总部", \
		"小鸡鸡", \
		"新华举报", \
		"新华内情", \
		"新闻封锁", \
		"畜生", \
		"玄`机", \
		"压迫", \
		"淫秽", \
		"银行联合管理局", \
		"印尼伊斯兰祈祷团", \
		"游行", \
		"舆论", \
		"造反", \
		"真善忍", \
		"镇压", \
		"正法", \
		"政变", \
		"政治风波", \
		"中俄边界新约", \
		"中国银联", \
		"中华民国", \
		"中奖", \
		"朱容基", \
		"自焚", \
		"自由运动", \
		"达赖", \
		"套牌", \
		"情妇", \
		"监听", \
		"巴南电信", \
		"合川分公司", \
		"合川电信", \
		"死光", \
		"116114", \
		"北京宝诚", \
		"华盛投资", \
		"名门国际", \
		"利博", \
		"赤橙黄绿", \
		"免佣BJL首发", \
		"洗*码优惠", \
		"【俱乐部】", \
		"18266381922", \
		"回拨卡", \
		"号码百事通推出短信订机票！实时" };

	for (int i = 0; i < 165; i++)
	{
		g_temp = badwords[i];
		if (str.Find(g_temp) != -1)
		{
			//	AfxMessageBox("信息服务商禁止的非法字符:("+g_temp+")希望您谅解!");
			return 0;
		}
	}
	return 1;
}

BOOL CheckBadWords2(CString str, BOOL bMsg)
{
	return 1;
}

///目录是否存在的检查： 支持网络文件夹
bool  CheckFolderFileExist(CString &strPath)
{
	CString path = strPath;
	CFile fp;
	if (fp.Open(path, CFile::modeRead))
	{
		fp.Close();
		return 1;
	}

	if (strPath.Right(1) != "\\")
		path += "\\";
	path += "zaqw1234.dat";

	// 所有文件删除前先判断是否存在,不存在则退出删除;
#if JEFF_TEST_ON
	if (PathFileExists(path))
	{
		::DeleteFile(path);
	}
#else
	::DeleteFile(path);
#endif

	if (fp.Open(path, CFile::modeCreate) == 0)
		return 0;
	fp.Close();

	if (PathFileExists(path))	// Jeff 删除文件前判断文件是否存在;
		::DeleteFile(path);
	return 1;
}

int FindArray(CStringArray *pArray, const CString &Str)
{
	for (int i = 0; i < pArray->GetSize(); i++)
	{
		if (pArray->ElementAt(i) == Str)
			return i;
	}
	return -1;
}

void FillLength(CString &str, int length)
{
	while (str.GetLength() < length)
		str += " ";
}

// 查找不到年历史数据库则返回-1;
int GetYearPos(int year)
{
	for (int i = 0; i < g_hisyeararray.GetSize(); i++)
	{
		if (year == atoi(g_hisyeararray.ElementAt(i).ElementAt(0)))
			return i;
	}
	return -1;
}

BOOL GIsHalfHZ(const   CString   &str)
{
	int   len = str.GetLength();
	BOOL   IsHalf = FALSE;
	for (int i = 0; i < len; i++)
	{
		if (str.GetAt(i) < 0)   IsHalf = !IsHalf;
	}
	return   IsHalf;
}

void WriteTitle(CString str)
{
	g_title = str;
	CStdioFile fp;
	fp.Open(g_mainpath + "\\title.txt", CFile::modeWrite | CFile::modeCreate);
	fp.WriteString(str);
	fp.Close();
}

CString GetIP(CString branch)
{
	for (int i = 0; i < g_brancharray.GetSize(); i++)
	{
		if (g_domain == g_brancharray.ElementAt(i).ElementAt(2))
		{
			//if(g_serverbak.Find (".ly.com")!=-1)
			return g_server;
			CString ip = g_serverbak;
			MyGetIPByName(ip);


			return ip;
		}
		if (branch == g_brancharray.ElementAt(i).ElementAt(0))
		{
			return g_brancharray.ElementAt(i).ElementAt(1);
		}
	}
	return "";
}

BOOL IsHanZi(CString str)
{
	TBYTE ucHigh, ucLow;
	for (int i = 0; i < str.GetLength(); i++)
	{
		if ((TBYTE)str[i] < 0x80)
		{
			continue;
		}
		ucHigh = (TBYTE)str[i];
		ucLow = (TBYTE)str[i + 1];
		if (ucHigh < 0xa1 || ucLow < 0xa1)
		{
			continue;
		}
		return 1;
	}
	return 0;
}

int GetType(CString str)
{
	if (IsHanZi(str))return 0;
	BOOL bDigit = 1;
	BOOL bAlpha = 1;
	for (int i = 0; i < str.GetLength(); i++)
	{
		if (!::isdigit(str.GetAt(i)))
			//if(! ((str.GetAt (i)<='0' && str.GetAt (i)>='9' ) ))
			bDigit = 0;
		if (!((str.GetAt(i) <= 'z' && str.GetAt(i) >= 'a') || (str.GetAt(i) <= 'Z' && str.GetAt(i) >= 'A')))
			//else if(!::isalpha ( ((unsigned char)str.GetAt (i))))
			bAlpha = 0;
		if (bDigit == 0 && bAlpha == 0)return 0;
	}
	if (bDigit)
	{
		/*#ifdef SUNRAIN_VERSION
		return 0;
		#else*/
		return 0;
		//#endif
	}
	else if (bAlpha)
	{
		return 2;
	}
	else
		return 0;
}

CString FilterBZ(CString &bz)
{
	bz.Replace("'", "");
	/*	int i=bz.GetLength ()-1;
	char c;
	for(;i>=0;i--)
	{
	c=bz.GetAt (i);
	if(c<32)// && c!=10 && c!=13)
	bz.Delete (i);
	}*/
	if (bz.GetLength() > 1023)
	{
		AfxMessageBox("文字太长, 字符串将被截取!", MB_ICONSTOP);
		bz = bz.Left(1023);
	}
	return bz;
}

// GetWidth()的长度与CRect的长度是不一样的单位值,需要转换适合的比例;(一个是图片的像素尺寸,一个DC的大小尺寸)
// 将图片尺寸与设备尺寸进行转换适合的比例;
void RectFitDes(int width, int height, CRect &rc)
{
	try
	{
		if (width == 0 || height == 0)return;

		// 图片长宽比例;
		float fscale = (float)width / (float)height;

		// 设备长宽比例;
		float rcscale = ((float)rc.Width()) / ((float)rc.Height());

		int rcwid = rc.Width();
		int rchei = rc.Height();
		int dt = 0;

		// Jeff.如果设备长宽比例 <  图片长宽比例;(即相同长度下,高越大比例值越小,所以此时图片尺寸 与 显示设备的尺寸相比,要显得更长)
		if (rcscale < fscale)
		{
			// Jeff.remarks
			// 调整显示设备的大小,以使之能容纳图片尺寸;(即长宽比例上,要大于或等于图片的长宽比例)
			// 所以有两种方法使得 rcscale >= fscale 表达式成立：
			// -----------------------------------------------
			// 方法1：显示设备宽加x值,计算出下面表达式x的值即可
			// (rc.Width()+x) / rc.Height() >= width/height;
			// 方法2：显示设备高减x值,计算出下面表达式x的值即可
			// (rc.Width()) / (rc.Height()-x) >= width/height;
			//------------------------------------------------
			// 两种方法的最后表达式为：
			// x >= rc.Height() - rcWidth()*(height/width);
			// 即 x >= rc.Height() - rcWidth()/fscale;
			//------------------------------------------------
			dt = (rchei - rcwid / fscale) / 2;
			rc.top += dt;
			rc.bottom -= dt;
		}
		else
		{
			dt = (rcwid - rchei*fscale) / 2;
			rc.left += dt;
			rc.right -= dt;
		}
	}
	catch (...)
	{
	}
}


BOOL IsHasRights(int pos) // Jeff,无意义的函数;
{
	return 1;
	if (g_user.rights.GetLength() > pos)
	{
		BOOL ret = atoi(g_user.rights.Mid(pos, 1));
		if (ret == 0)AfxMessageBox("没有相关权限!", MB_ICONINFORMATION);
		return ret;
	}
	AfxMessageBox("没有相关权限!", MB_ICONINFORMATION);
	return 0;
}

BOOL IsHasRights2(int pos)// Jeff,无意义的函数;
{
	return 1;
	if (g_user.rights.GetLength() > pos)
	{
		BOOL ret = atoi(g_user.rights.Mid(pos, 1));
		return ret;
	}
	return 0;
}

BOOL IsHasRightsnew(int pos)
{
#if JEFF_TEST_OFF
	CString strTest = _T("");
	strTest.Format(_T("%d"), pos);
	AfxMessageBox(strTest);
	return TRUE;
#else
	if (g_user.rights.GetLength() > pos)
	{
		BOOL ret = atoi(g_user.rights.Mid(pos, 1));
		if (ret == 0)AfxMessageBox("没有相关权限! 请与系统管理员联系!", MB_ICONINFORMATION);
		return ret;
	}
	AfxMessageBox("没有相关权限! 请与系统管理员联系!", MB_ICONINFORMATION);
#endif
	return 0;
}

BOOL IsHasRights2new(int pos)
{
#if JEFF_TEST_OFF
	CString strTest = _T("");
	strTest.Format(_T("%d"), pos);
	AfxMessageBox(strTest);
	return TRUE;
#else
	if (g_user.rights.GetLength() > pos)
	{
		BOOL ret = atoi(g_user.rights.Mid(pos, 1));
		return ret;
	}
#endif
	return 0;

}


BOOL IsHasRightsnew2(int pos, CString rights)
{
#if JEFF_TEST_OFF
	CString strTest = _T("");
	strTest.Format(_T("%d,%s"), pos, rights);
	AfxMessageBox(strTest);
	return TRUE;
#else
	if (rights.GetLength() > pos)
	{
		BOOL ret = atoi(rights.Mid(pos, 1));
		if (ret == 0)AfxMessageBox("没有相关权限! 请与系统管理员联系!", MB_ICONINFORMATION);
		return ret;
	}
	AfxMessageBox("没有相关权限! 请与系统管理员联系!", MB_ICONINFORMATION);
#endif
	return 0;
}
/********************************************************************************************
/* Syntax
/*        void FirstLetter(int nCode, CString& strLetter)
/* Remarks:
/*        Get the first letter of pinyin according to specified Chinese character code.
/* Parameters:
/*        nCode         - the code of the chinese character.
/*        strLetter      - a CString object that is to receive the string of the first letter.
/* Return Values:
/*        None.
/* Author:
/*        lixiaosan
/* Create Date:
/*        05-26-2006
/********************************************************************************************/
void FirstLetter(int nCode, CString& strLetter)
{
	if (nCode >= 1601 && nCode < 1637) strLetter = _T("A");
	if (nCode >= 1637 && nCode < 1833) strLetter = _T("B");
	if (nCode >= 1833 && nCode < 2078) strLetter = _T("C");
	if (nCode >= 2078 && nCode < 2274) strLetter = _T("D");
	if (nCode >= 2274 && nCode < 2302) strLetter = _T("E");
	if (nCode >= 2302 && nCode < 2433) strLetter = _T("F");
	if (nCode >= 2433 && nCode < 2594) strLetter = _T("G");
	if (nCode >= 2594 && nCode < 2787) strLetter = _T("H");
	if (nCode >= 2787 && nCode < 3106) strLetter = _T("J");
	if (nCode >= 3106 && nCode < 3212) strLetter = _T("K");
	if (nCode >= 3212 && nCode < 3472) strLetter = _T("L");
	if (nCode >= 3472 && nCode < 3635) strLetter = _T("M");
	if (nCode >= 3635 && nCode < 3722) strLetter = _T("N");
	if (nCode >= 3722 && nCode < 3730) strLetter = _T("O");
	if (nCode >= 3730 && nCode < 3858) strLetter = _T("P");
	if (nCode >= 3858 && nCode < 4027) strLetter = _T("Q");
	if (nCode >= 4027 && nCode < 4086) strLetter = _T("R");
	if (nCode >= 4086 && nCode < 4390) strLetter = _T("S");
	if (nCode >= 4390 && nCode < 4558) strLetter = _T("T");
	if (nCode >= 4558 && nCode < 4684) strLetter = _T("W");
	if (nCode >= 4684 && nCode < 4925) strLetter = _T("X");
	if (nCode >= 4925 && nCode < 5249) strLetter = _T("Y");
	if (nCode >= 5249 && nCode < 5590) strLetter = _T("Z");
}

/********************************************************************************************
/* Syntax
/*        GetFirstLetter(CString strName, CString& strFirstLetter)
/* Remarks:
/*        Get the first letter of pinyin according to specified Chinese character.
/* Parameters:
/*        strName            - a CString object that is to be parsed.
/*        strFirstLetter     - a CString object that is to receive the string of the first letter.
/* Return Values:
/*        None.
/* Author:
/*        lixiaosan
/* Create Date:
/*        05-26-2006
/********************************************************************************************/
void GetFirstLetter(CString strName, CString& strFirstLetter)
{
	TBYTE ucHigh, ucLow;
	int  nCode;
	CString strRet;

	strFirstLetter.Empty();

	for (int i = 0; i < strName.GetLength(); i++)
	{
		if ((TBYTE)strName[i] < 0x80)
		{
			strRet = strName.Mid(i, 1);
			strRet.MakeUpper();
			strFirstLetter += strRet;
			continue;
		}

		ucHigh = (TBYTE)strName[i];
		ucLow = (TBYTE)strName[i + 1];
		if (ucHigh < 0xa1 || ucLow < 0xa1)
			continue;
		else
			// Treat code by section-position as an int type parameter,
			// so make following change to nCode.
			nCode = (ucHigh - 0xa0) * 100 + ucLow - 0xa0;

		FirstLetter(nCode, strRet);
		strFirstLetter += strRet;
		i++;
	}
}

CString newGUID()
{
	CString str;
	GUID guid;
	CoInitialize(NULL);
	if (S_OK == ::CoCreateGuid(&guid))
	{
		str.Format(
			"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
			guid.Data1,
			guid.Data2,
			guid.Data3,
			guid.Data4[0], guid.Data4[1],
			guid.Data4[2], guid.Data4[3],
			guid.Data4[4], guid.Data4[5],
			guid.Data4[6], guid.Data4[7]);
	}
	CoUninitialize();
	return str.Left(28);
}

CString GetNameFromDomain(CString domain)
{
	for (int i = 0; i < g_brancharray.GetSize(); i++)
	{
		if (domain == g_brancharray.ElementAt(i).ElementAt(2))
		{
			return g_brancharray.ElementAt(i).ElementAt(0);
		}
	}
	return "";
}

void ConvertToPrice(CString &str)
{
	if (str.Find('.') == -1)return;
	str.TrimRight('0');
	str.TrimRight('.');
}

int GetLengthEx(CString str)
{
	wchar_t   wstr[500];
	int   k = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, strlen(str), wstr, 500);
	return k;
}

inline int MultiByteLengthConvertToWideCharLength(/*LPCSTR*/LPCCH lpString)
{
	return MultiByteToWideChar(CP_ACP, 0, lpString, -1, NULL, 0);
}

BOOL myisdigit(CString str)
{
	for (int i = 0; i < str.GetLength(); i++)
	{
		if (!::isdigit(str.GetAt(i)))
			return 0;
	}
	return 1;
}

DWORD FindAppProcessID(CString path)
{
	try
	{
		HANDLE handle = ::CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);
		PROCESSENTRY32 Info;
		Info.dwSize = sizeof(PROCESSENTRY32);
		path.MakeLower();
		if (::Process32First(handle, &Info))
		{
			do
			{
				CString ss = Info.szExeFile;
				ss.MakeLower();
				if (ss.Find(path) != -1 || (!ss.CompareNoCase(path)))
				{
					::CloseHandle(handle);
					return Info.th32ProcessID;
				}
			} while (::Process32Next(handle, &Info));
			::CloseHandle(handle);
		}
		return -1;
	}
	catch (...)
	{
	}
}

BOOL isInnerIP(DWORD a_ip) // Jeff.判断是否是内网?
{
	BOOL bValid = 0;
	if ((a_ip >> 24 == 0xa) || (a_ip >> 16 == 0xc0a8) || (a_ip >> 22 == 0x2b0))
	{
		bValid = 1;
	}
	return bValid;
}

void MyGetIPByName2(CString &name)
{
	CString strIP = name;
	name.Empty();
	DWORD dwServerIP = 0;
	HOSTENT   *host = gethostbyname(strIP);
	struct   in_addr   addr;
	if (host != NULL)
	{
		for (int i = 0; host->h_addr_list[i] != NULL; i++)
		{
			memset(&addr, 0, sizeof(addr));
			memcpy(&addr.S_un.S_addr, host->h_addr_list[i], host->h_length);
			dwServerIP = ntohl(addr.S_un.S_addr);
			BYTE*   pIP = (BYTE*)&dwServerIP;
			name.Format(_T("%d.%d.%d.%d"), pIP[3], pIP[2], pIP[1], pIP[0]);
		}
	}
}

void MyGetIPByName(CString &name) // Jeff.根据计算机名称获取IP地址;
{
	g_serverarray.RemoveAll();
	CString strIP = name;
	name.Empty();
	DWORD dwServerIP = 0;
	HOSTENT   *host = gethostbyname(strIP);		// Jeff.所有本机的网络适配器;
	struct   in_addr   addr;
	if (host != NULL)
	{
		// Jeff.遍历本机所有适配器的IP地址;
		for (int i = 0; host->h_addr_list[i] != NULL; i++)
		{
			memset(&addr, 0, sizeof(addr));
			memcpy(&addr.S_un.S_addr, host->h_addr_list[i], host->h_length);
			dwServerIP = ntohl(addr.S_un.S_addr);
			BYTE*   pIP = (BYTE*)&dwServerIP;
			name.Format(_T("%d.%d.%d.%d"), pIP[3], pIP[2], pIP[1], pIP[0]);
			g_serverarray.Add(name);
		}
	}
	while (g_serverarray.GetSize() > 1)
	{
		CString name;
		BOOL bFind = 0;
		for (int i = 0; i < g_serverarray.GetSize(); i++)
		{
			DWORD dwServerIP = inet_addr(g_serverarray.ElementAt(i));
			dwServerIP = htonl(dwServerIP);//加了才正确
			if (isInnerIP(dwServerIP) == 0)
			{
				//	AfxMessageBox("外部IP");
				g_serverarray.RemoveAt(i);
				bFind = 1;
				break;
			}
			//	else
			//	AfxMessageBox("内部IP");
		}
		if (bFind == 0)
		{
			break;
		}
	}
}

int IsExistFolder(char *szPath)//可判断文件夹和文件的存在;
{
	if ((_access(szPath, 0)) != -1)
	{
		//printf("Jeff:File %s \t exists \n",szPath );
		/* Check for write permission */
		if ((_access(szPath, 2)) != -1)
		{
			//printf("Jeff:File %s \t has write permission \n",szPath );
			CString str;
			str.Format("共享文件夹<%s>:  存在！\n", szPath);
			WriteClientLog(str);

			return 1;
		}
		// 		else // 只能判断文件权限,不能判断目录;
		// 		{
		// 			CString str;
		// 			str.Format("共享文件夹<%s>:\t存在,不可写！■■■■■■■\n",szPath);
		// 			WriteClientLog(str);
		// 
		// 			return 0;
		// 		}
	}
	else
	{
		//printf("Jeff:\t File %s no exists \n",szPath );
		CString str;
		str.Format("◆共享文件夹<%s>:  不存在,请设置共享或访问权限！◆\n", szPath);
		WriteClientLog(str);

		return -1;
	}
}

CString GetW(CString str)
{
	int x = atoi(str);
	if (x > 9999)
	{
		str.Format("%d", x);
		str = str.Right(5);
		str = str.Left(1);
		return str;
	}
	return "";
}

CString GetK(CString str)
{
	int x = atoi(str);
	if (x > 999)
	{
		str.Format("%d", x);
		str = str.Right(4);
		str = str.Left(1);
		return str;
	}
	return "";
}

CString GetB(CString str)
{
	int x = atoi(str);
	if (x > 99)
	{
		str.Format("%d", x);
		str = str.Right(3);
		str = str.Left(1);
		return str;
	}
	return "";
}

CString GetS(CString str)
{
	int x = atoi(str);
	if (x > 9)
	{
		str.Format("%d", x);
		str = str.Right(2);
		str = str.Left(1);
		return str;
	}
	return "";
}

CString GetG(CString str)
{
	int x = atoi(str);
	if (x > 0)
	{
		str.Format("%d", x);
		str = str.Right(1);
		return str;
	}
	return "";
}

CString GetHMoney(CString str)
{
	if (str.IsEmpty())return "";
	if (str == "0")return "零";
	if (atoi(str) < 1 || atoi(str) > 9)return "";
	CString ret[] = { "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
	return ret[atoi(str) - 1];
}

BOOL CheckDateOK2(CString str)
{
	if (str.IsEmpty())return 0;
	CString tip;
	int i;
	CString demo = CTime::GetCurrentTime().Format("%Y-%m-%d");
	if (str.GetLength() != demo.GetLength())
		goto ll;
	//2009-01-01
	if (str.GetAt(4) != '-')
		goto ll;
	if (str.GetAt(7) != '-')
		goto ll;
	for (i = 0; i < str.GetLength(); i++)
	{
		if (i == 4 || i == 7)continue;
		if (str.GetAt(i) < '0' || str.GetAt(i) > '9')
			goto ll;
	}
	return 1;
ll:
	return 0;
}

CString GetDomainFromBranch(CString branch)
{
	if (branch.IsEmpty())return "";
	for (int i = 0; i < g_brancharray.GetSize(); i++)
	{
		if (branch == g_brancharray.ElementAt(i).ElementAt(0))
		{
			return g_brancharray.ElementAt(i).ElementAt(2);
		}
	}
	return "";
}

CString GetBranchPhotoPath(CString branch)
{
	if (branch.IsEmpty())return "";
	for (int i = 0; i < g_brancharray.GetSize() - 1; i++)
	{
		if (branch == g_brancharray.ElementAt(i).ElementAt(0))
		{
			return "\\" + g_brancharray.ElementAt(i).ElementAt(2);
		}
	}
	return "";
}

CTime GetTmFromStr(CString date)
{
	try
	{
		CTime tm(atoi(date.Mid(0, 4)), atoi(date.Mid(5, 2)), atoi(date.Mid(8, 2)), 0, 0, 0);
		CString ss;
		ss.Format("%d-%d-%d", tm.GetYear(), tm.GetMonth(), tm.GetDay());
		return tm;
	}
	catch (...)
	{
		date = "1980-01-01";
		CTime tm(atoi(date.Mid(0, 4)), atoi(date.Mid(5, 2)), atoi(date.Mid(8, 2)), 0, 0, 0);
		return tm;
	}
}



//---------------------------------------------------------------------
// add by Jeff 2014.10.24
// 函数：全局函数lyfzCopyFileEx
// 描述：文件复制。
// 参数：
//		lpExistingFileName：你要拷贝的源文件名;
//		lpNewFileName：		你要拷贝的目标文件名;
//		bFailIfExists：		如果目标已经存在，不拷贝（True）并重命名，覆盖目标（false） 
// 返回：与CopyFile返回一致;
//---------------------------------------------------------------------
BOOL lyfzCopyFileEx(LPCTSTR lpExistingFileName, LPCTSTR lpNewFileName, const BOOL &bFailIfExists)
{
	// 1.如果是覆盖选项;
	if (!bFailIfExists)
		return CopyFile(lpExistingFileName, lpNewFileName, bFailIfExists);

	// 2.如果不是覆盖选项;
	TCHAR szNewFileName[_MAX_PATH] = { 0 };
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFna[_MAX_FNAME] = { 0 };
	TCHAR szExt[_MAX_EXT] = { 0 };

	sprintf(szNewFileName, "%s", lpNewFileName);
	_tsplitpath(szNewFileName, szDrive, szDir, szFna, szExt);

	int nIndex = 1;
	while (PathFileExists(szNewFileName))
	{
		sprintf(szNewFileName, "%s%s%s (%d)%s", szDrive, szDir, szFna, nIndex++, szExt);
	}

	return CopyFile(lpExistingFileName, szNewFileName, bFailIfExists);
}

//---------------------------------------------------------------------
// add by Jeff 2014.10.24
// 函数：全局函数lyfzImportImage,多字节版本，非UNICODE
// 描述：导入图片。
// 参数：
//		lpDestDirectory：	文件导入的目标目录;
//		strArrayOfImage：	要导入的图片文件数组;
//		bFailIfExists：		如果目标已经存在，不拷贝（True）并重命名，覆盖目标（false） 
// 返回：
//
// 说明:在调用lyfzImportImage前，需要对传递的参数进行有效性验证
//		1.验证形参lpDestDirectory对应的实参是否是有效的目录（有无创建目录的非法字符存在）
//		2.验证形参strArrayOfImage对应的实参数组是否大于0;
// 如果校验没有通过,应该拒绝调lyfzImportImage，以防止错误产生。
//---------------------------------------------------------------------
void lyfzImportImage(LPCTSTR lpDestDirectory, CStringArray &strArrayOfImage, const BOOL &bFailIfExists)
{
	// 传递给lyfzCreateDirectory的参数规范化;
	int nlen = strlen(lpDestDirectory);
	TCHAR szNewFileName[_MAX_PATH] = { 0 };
	TCHAR szTempDirectory[_MAX_PATH] = { 0 };
	if (lpDestDirectory[nlen - 1] != '\\')
		sprintf(szTempDirectory, "%s\\", lpDestDirectory);
	else
		sprintf(szTempDirectory, "%s", lpDestDirectory);

	// 若目录或子目录不存在创建;
	lyfzCreateDirectory(szTempDirectory);

	// 遍历复制;
	CString strImage;
	INT_PTR nSize = strArrayOfImage.GetSize();
	for (INT_PTR i = 0; i < nSize; i++)
	{
		strImage = strArrayOfImage.ElementAt(i);
		strImage = strImage.Mid(strImage.ReverseFind('\\') + 1);
		//strImage = strImage.Left(strImage.ReverseFind('.'));
		sprintf(szNewFileName, "%s%s", szTempDirectory, strImage);
		lyfzCopyFileEx(szNewFileName, strArrayOfImage.ElementAt(i), bFailIfExists);
	}
}


//---------------------------------------------------------------------
// add by Jeff 2014.10.25
// 函数：全局函数lyfzCreateDirectory,多字节版本，非UNICODE
// 描述：创建目录及子目录文件夹;
// 参数：
//		lpDestDirectory：目录,必须是"E:\lyfzdb\数据\"格式,目录最后必须有"\",否则最后一个子目录无法创建！
//		建议使用系统_tsplitpath来分隔目录,这样会保存最后一个"\"斜杠;
// 返回：成功创建返回TRUE;
//---------------------------------------------------------------------
BOOL lyfzCreateDirectory(LPCTSTR lpDestDirectory)
{
	BOOL bExists = FALSE;
	TCHAR szNewFileName[_MAX_PATH] = { 0 };
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFna[_MAX_FNAME] = { 0 };
	TCHAR szExt[_MAX_EXT] = { 0 };

	int nIndex = 0;
	do
	{
		bExists = PathFileExists(lpDestDirectory);
		if (!bExists)
		{
			memset(szDrive, 0, _MAX_DRIVE);
			memset(szDir, 0, _MAX_DIR);
			memset(szFna, 0, _MAX_FNAME);
			memset(szExt, 0, _MAX_EXT);
			lyfzSplitpath(lpDestDirectory, szDrive, szDir, ++nIndex);
			sprintf(szNewFileName, _T("%s%s"), szDrive, szDir);
			CreateDirectory(szNewFileName, NULL);
			//if (FALSE == CreateDirectory(szNewFileName, NULL))
			//{
				//ShowSystemErrorInfo(CString("创建目录出错。"), GetLastError());
				//return FALSE;
			//	continue;
			//}
		}
	} while (!bExists);

	return TRUE;
}

//---------------------------------------------------------------------
// add by Jeff 2014.10.24
// 函数：全局函数tSplitpath,多字节版本，非UNICODE
// 描述：类系统Windows C++运行库函数_tsplitpath。
// 参数：
//		
// 返回：
//---------------------------------------------------------------------
void lyfzSplitpath(const char *path, char *drive, char *dir, const int &nTimes)
{
	int nlen = strlen(path);

	int i = 0;
	int npoint = 0;	// '.'
	int nsprit = 0; // '\\'
	int ncolon = 0; // ':'
	int ntimes = -1;

	while (nlen > i++)
	{
		if (path[i] == ':')
			ncolon = i;
		else if (path[i] == '\\')
		{
			if (nTimes == ntimes++) break;
			nsprit = i;
		}
	}

	memcpy(drive, path, ncolon + 1);
	memcpy(dir, &path[ncolon + 1], nsprit - ncolon);
}

//---------------------------------------------------------------------
// Jeff add 2014.06.23;
// 函数：ShowErrorInfo
// 描述：
// 参数:
//     lpszFunction：函数名;
//     dwError：错误码; 
// 返回：
//---------------------------------------------------------------------
void ShowSystemErrorInfo(CString &strDescription, const DWORD &dwError)
{
#if 0
	LPVOID lpMsgBuf;

	FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM |
		FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		dwError,
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		(LPTSTR)&lpMsgBuf,
		0, NULL);

	// Display the error message and exit the process
	CString strDisplay;
	strDisplay.Format("失败错误码=%d,Windows内部描述:%s", dwError, lpMsgBuf);
	strDescription += strDisplay;

	AfxMessageBox(strDescription);

	LocalFree(lpMsgBuf);
#endif

	LPVOID lpMsgBuf;

	BOOL fOk = FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM |
		FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		dwError,
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		(LPTSTR)&lpMsgBuf,
		0, NULL);

	if (!fOk)
	{
		// Is it a network-related error?
		HMODULE hDll = LoadLibraryEx(TEXT("netmsg.dll"), NULL, DONT_RESOLVE_DLL_REFERENCES);

		if (hDll != NULL)
		{
			FormatMessage(
				FORMAT_MESSAGE_FROM_HMODULE |
				FORMAT_MESSAGE_FROM_SYSTEM |
				FORMAT_MESSAGE_IGNORE_INSERTS,
				hDll,
				dwError,
				MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
				(LPTSTR)&lpMsgBuf,
				0,
				NULL);

			FreeLibrary(hDll);
		}
	}

	if (lpMsgBuf != NULL)
	{
		CString strDisplay;
		strDisplay.Format("%s.错误码=%d,Windows描述:%s", strDescription, dwError, (LPCTSTR)LocalLock(lpMsgBuf));
		//WriteLogin(strDisplay);
		AfxMessageBox(strDisplay);
		LocalFree(lpMsgBuf);
	}
	else
	{
		//WriteLogin(strDescription);
		AfxMessageBox("未知道错误");
	}
}

//---------------------------------------------------------------------
// Jeff add 2014.06.23;
// 函数：WriteClientLog
// 描述：写客户端程序日志。
// 参数:
//     str：日志内容;
// 返回：
//---------------------------------------------------------------------
void WriteClientLog(const CString &strLogContent)
{
	try
	{
		CStdioFile fp;
		CString path = g_mainpath + "\\客户端日志.txt";
		if (PathFileExists(path))
		{
			fp.Open(path, CFile::modeWrite);
			int length = fp.GetLength();
			if (length > 5 * 1024 * 1024)
			{
				fp.Close();
				::DeleteFile(path);
				return;
			}
			fp.SeekToEnd();
		}
		else
			fp.Open(path, CFile::modeCreate | CFile::modeWrite);
		fp.WriteString(CTime::GetCurrentTime().Format("%Y-%m-%d %H:%M:%S") + " " + strLogContent + "\n");
		fp.Close();
	}
	catch (...)
	{
	}
}

//---------------------------------------------------------------------
// add by Jeff 2014.10.27
// 函数：全局函数IsDirectoryLegitimate,多字节版本，非UNICODE
// 描述：判断一个目录路径字符串，是否属于合法的、可创建的目录路径。
// 参数：strDirectory 被验证的路径字符串;
//		
// 返回：合法路径返回TRUE;
//---------------------------------------------------------------------
BOOL IsDirectoryLegitimate(const CString &strDirectory)
{
	if (strDirectory.Find('/') != -1 ||
		strDirectory.Find('\\') != -1 ||
		strDirectory.Find(':') != -1 ||
		strDirectory.Find('*') != -1 ||
		strDirectory.Find('?') != -1 ||
		strDirectory.Find('\"') != -1 ||
		strDirectory.Find('>') != -1 ||
		strDirectory.Find('<') != -1 ||
		strDirectory.Find('|') != -1
		)
		return FALSE;

	return TRUE;
}

//----------------------------------------------------------------------
// remark by Jeff 2014.11.08
// 函数：ExportCutImageToFile
// 描述：导出裁剪图片到指定目录;
// 参数：
//		 lpOrderCutImageInfo:订单号的裁剪相片信息;
//		 lpSrcDirectory:原图片路径;
//		 lpOrderCutImageInfo格式：相片名|裁剪方案|原片宽|原片高|裁剪left|裁剪top|裁剪bottom|裁剪rigth
// 225:5X7,1440,900,88,0,1352,900;228:5X7,1440,900,88,0,1352,900;224:5X7,1440,900,88,0,1352,900;227:10寸,1440,900,56,0,1384,900;229:10寸水晶,1440,900,570,232,870,671;
//		 lpSaveDirectory:导出相片的保存路径;
// 返回：无
//----------------------------------------------------------------------
void ExportCutImageToFile(LPCCH lpOrderCutImageInfo, LPCCH lpSrcDirectory, LPCCH lpSaveDirectory)
{
	if (FALSE == lyfzCreateDirectory(lpSaveDirectory))
		return;

	CStringArray saSrcPhoto;
	GetCountOfOrderFolderPhotoFile(lpSrcDirectory, saSrcPhoto);

	CString strImageName;		// 相片名;
	CString strCutScheme;		// 裁剪方案;
	CRect rtCut;				// 要裁剪的区域;

	CString strTemp;
	CString strImageInfo(lpOrderCutImageInfo);
	int nIndex = -1;
	do
	{
		// 225:5X7,1440,900,88,0,1352,900;
		nIndex = strImageInfo.Find(';');
		strTemp = strImageInfo.Left(nIndex);
		strImageInfo = strImageInfo.Mid(nIndex + 1);

		int SrcImageWid;
		int SrcImageHei;
		int ntempIndex = -1;
		if (nIndex != -1)
		{
			if (FALSE == AnalysisImagInfo(saSrcPhoto,lpSrcDirectory, lpSaveDirectory, strTemp, strImageName, strCutScheme, rtCut))
				continue;
		}
		else
		{
			if (strImageInfo.IsEmpty())
				break;

			AnalysisImagInfo(saSrcPhoto,lpSrcDirectory, lpSaveDirectory, strImageInfo, strImageName, strCutScheme, rtCut);
			break;
		}

	} while (nIndex != -1);
}

//----------------------------------------------------------------------
// remark by Jeff 2014.11.08
// 函数：AnalysisImagInfo
// 描述：导出裁剪图片到指定目录;
// 参数：
//		 lpOrderCutImageInfo:订单号的裁剪相片信息;
//		 lpSrcDirectory:原图片路径;
//		 lpOrderCutImageInfo格式：相片名|裁剪方案|原片宽|原片高|裁剪left|裁剪top|裁剪bottom|裁剪rigth
//		 225:5X7,1440,900,88,0,1352,900;
//		 lpSaveDirectory:导出相片的保存路径;
// 返回：无
//
// 说明：未对图片进行缩小,直接在原片上裁剪而得。
//----------------------------------------------------------------------
BOOL AnalysisImagInfo(CStringArray &saSrcPhoto, LPCCH lpSrcDirectory, LPCCH lpSaveDirectory, CString &strImageInfo, CString &strImageName, CString &strCutScheme, CRect &rtCut)
{
	int ntempIndex = -1;
	strImageName = strImageInfo.Left(3);		// 裁剪相片名;
	strImageInfo.Delete(0, 4);

	CString strSrcImagePath;
	BOOL bExist = FALSE;
	for (int i = 0; i < saSrcPhoto.GetSize(); i++)
	{
		CString strTemp = saSrcPhoto.ElementAt(i);
		strSrcImagePath = strTemp;
		_splitpath((LPCTSTR)saSrcPhoto.ElementAt(i), NULL, NULL, strTemp.GetBuffer(0), NULL);
		strTemp.ReleaseBuffer();

		if ( strTemp == strImageName)
		{
			bExist = TRUE;
			//saSrcPhoto.RemoveAt(i);
			break;
		}
	}

	if (FALSE == bExist)
		return FALSE;

	ntempIndex = strImageInfo.Find(',');
	strCutScheme = strImageInfo.Left(ntempIndex);	// 裁剪方案;

	strImageInfo.Delete(0, ntempIndex + 1);

	// 裁剪原图宽;
	ntempIndex = strImageInfo.Find(',');
	LONG SrcImageWid = _ttol(strImageInfo.Left(ntempIndex));
	strImageInfo.Delete(0, ntempIndex + 1);

	// 裁剪原图高;
	ntempIndex = strImageInfo.Find(',');
	LONG SrcImageHei = _ttol(strImageInfo.Left(ntempIndex));
	strImageInfo.Delete(0, ntempIndex + 1);

	// left坐标值;
	ntempIndex = strImageInfo.Find(',');
	rtCut.left = _ttol(strImageInfo.Left(ntempIndex));
	strImageInfo.Delete(0, ntempIndex + 1);

	// top坐标;
	ntempIndex = strImageInfo.Find(',');
	rtCut.top = _ttol(strImageInfo.Left(ntempIndex));
	strImageInfo.Delete(0, ntempIndex + 1);

	// right坐标;
	ntempIndex = strImageInfo.Find(',');
	rtCut.right = _ttol(strImageInfo.Left(ntempIndex));
	strImageInfo.Delete(0, ntempIndex + 1);

	// bottom坐标;
	rtCut.bottom = _ttol(strImageInfo.Left(ntempIndex));

	// 导出裁剪相片到指定目录;
	// 1.加载原图;
	Image *SrcImage = NULL;
	//if (FALSE == PathFileExists(CString(lpSrcDirectory + strImageName + _T(".jpg"))))
	if (FALSE == PathFileExists(strSrcImagePath))
	{
		AfxMessageBox(_T("相片源文件不存在"));
		return FALSE;
	}
	//LoadImageFromBuf(&SrcImage, CString(lpSrcDirectory + strImageName + _T(".jpg")));
	LoadImageFromBuf(&SrcImage, strSrcImagePath);

	if (SrcImage == NULL)
	{
		AfxMessageBox(_T("加载源图片失败"));
		return FALSE;
	}
	int orientation = GetOrientation(SrcImage);
	if (orientation == 8)
		SrcImage->RotateFlip(Rotate270FlipNone);
	else if (orientation == 6)
		SrcImage->RotateFlip(Rotate90FlipNone);
	if (SrcImage->GetWidth() == 0)
		return FALSE;

	float scale = 1.0;
	scale *= (float)SrcImage->GetWidth() / (float)SrcImageWid;

	rtCut.left *= scale;
	rtCut.right *= scale;
	rtCut.top *= scale;
	rtCut.bottom *= scale;

#if 0	// 保存在原图上画裁剪区域;
	Graphics graph(SrcImage);

	Pen blackPen(Color(255, 255, 0, 0), 1);
	graph.DrawRectangle(&blackPen, rtCut.left, rtCut.top, rtCut.Width(), rtCut.Height());
	SaveImageToFile(SrcImage, CString(lpSaveDirectory + strImageName + _T(".jpg")));
	delete SrcImage;
#else	// 直接保存裁剪后的图片;
	Bitmap bp(rtCut.Width(), rtCut.Height());
	Graphics *graphic = Graphics::FromImage(&bp);
	graphic->Clear(Color(255, 255, 255, 255));

	graphic->SetInterpolationMode(InterpolationModeHighQualityBicubic);
	graphic->SetSmoothingMode(SmoothingModeHighQuality);//SmoothingModeHighSpeed
	graphic->SetPixelOffsetMode(PixelOffsetModeHighQuality);
	graphic->SetCompositingMode(CompositingModeSourceOver);
	graphic->SetCompositingQuality(CompositingQualityHighQuality);
	graphic->SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
	graphic->DrawImage(SrcImage, RectF(0, 0, rtCut.Width(), rtCut.Height()), rtCut.left, rtCut.top, rtCut.Width(), rtCut.Height(), UnitPixel);

	delete SrcImage;
	delete graphic;
	//delete graphic;
	//CString strSave;
	//strSave.Format("%s%s:%s.jpg", lpSaveDirectory,strImageName,strCutScheme);
	//SaveImageToFile(&bp, strSave);
	SaveImageToFile(&bp, CString(lpSaveDirectory + strImageName + _T("：") + strCutScheme + _T(".jpg")));
#endif

	return TRUE;
}



// 相片后缀：jpg、raw、cr2、NEF 四种常用后缀
//--------------------------------------------------------------------------------
// Remark by Jeff 2014.11.10
// 函数：GetCountOfOrderFolderPhotoFile
// 描述：获取订单文件夹下所有相片文件,不含"m"和"s"开头的小图;
// 参数：pOrderFolder:订单文件路径;
// 返回：
//
//--------------------------------------------------------------------------------
int GetCountOfOrderFolderPhotoFile( const TCHAR *pOrderFolder,  CStringArray &StrPhotoArray)
{
	CStringArray StrSubFoloderArray;
	using namespace helper_coffs;
	ffsco o;
	o.dirs(1);	// Jeff.1:查找子目录;
	o.find(LPCTSTR(pOrderFolder), LPCTSTR(_T("*.*")));	// 可能存在m和s开头的缩略图,需要过滤掉;

	if (o.count() == 0)
		return 0;

	// 获取子目录数;
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_dir();
	for (it = coo.begin(); it != coo.end(); it++)
	{
		if (FindArray(&StrSubFoloderArray, (*it).c_str()) == -1)
			StrSubFoloderArray.Add((*it).c_str());
	}

	int nIndex = -1;
	CString strOrderNumberImage;
	// 获取子目录下的文件数;
	//CStringArray StrPhotoArray;
	for (int n = 0; n < StrSubFoloderArray.GetSize(); n++)
	{
		ffsco op;
		op.dirs(0);
		op.find(LPCTSTR(StrSubFoloderArray.ElementAt(n)), LPCTSTR(_T("*.jpg")));
		ffsco::typeT coo;
		ffsco::typeT::iterator itp;
		coo = op.co_file();

		for (itp = coo.begin(); itp != coo.end(); itp++)
		{
			strOrderNumberImage = (*itp).c_str();
			nIndex = strOrderNumberImage.ReverseFind('\\');
			strOrderNumberImage = strOrderNumberImage.Right(strOrderNumberImage.GetLength() - nIndex -1);
			if (strOrderNumberImage.Left(1) != _T("m") && strOrderNumberImage.Left(1) != _T("s"))
			{
				StrPhotoArray.Add((*itp).c_str());
			}
		}
	}

	return 0;
}


//---------------------------------------------------------------------
// Jeff add 2015.03.26;
// 函数：GetFileNameFromFullPath
// 描述：从全路径中获取文件名。
// 参数:
//     lpFullPath：全路径;
// 返回：
//---------------------------------------------------------------------
VOID GetFileNameFromFullPath(CONST CString &strFullPath, CString &strRet)
{
	// 如果参数空或如果路径不存在;
	if (strFullPath.IsEmpty() || !PathFileExists(strFullPath)) return;

	INT nIndex = strFullPath.ReverseFind(_T('\\'));
	
}


BOOL LoadMicroShareLibrary()
{
	if (g_hlyfzMicroShareDLL == NULL)
		g_hlyfzMicroShareDLL = LoadLibrary(_T("lyfzMicroShare.dll"));

	if (g_hlyfzMicroShareDLL == NULL)
	{
		AfxMessageBox(_T("加载微共享模块失败！"));
		return FALSE;
	}

	g_lyfzCreateShare = (lyfzCreateShare)::GetProcAddress(g_hlyfzMicroShareDLL, "lyfzCreateShare");

	if (!g_lyfzCreateShare)
	{
		FreeLibrary(g_hlyfzMicroShareDLL);
		g_hlyfzMicroShareDLL = NULL;
		AfxMessageBox(_T("加载导入导出模块接口失败！"));
		return FALSE;
	}

	return TRUE;
}

void FreeMicroShareLibrary()
{
	if (g_hlyfzMicroShareDLL)
		FreeLibrary(g_hlyfzMicroShareDLL);
	g_hlyfzMicroShareDLL = NULL;
	g_lyfzCreateShare = NULL;
}

// BOOL GetRemoteConfig()
// {
// 	// 读取remotecfg.dat;
// 	if (strcmp(g_szModulePath, _T("")) == 0)
// 		return FALSE;
// 	
// 	TCHAR szRemoteFile[MAX_PATH] = {_T("")};
// 	//_stprintf_s(szRemoteFile,_T("%s%s"),g_szModulePath,_T("remotecfg.dat"));
// 	sprintf(szRemoteFile, _T("%s%s"), g_szModulePath, _T("remotecfg.dat"));
// 	
// 	// 没找到文件;
// 	if (!PathFileExists(szRemoteFile)) return FALSE;
// 	
// 	// 打开文件,读取内容;
// 	CFile cf;
// 	CFileException e;
// 	if (!cf.Open(szRemoteFile, CFile::modeRead, &e))
// 	{
// 		// 打开文件失败;
// 		//e.ReportError();
// 		return FALSE;
// 	}
// 
// 	// 清空STRemoteInfo结构;
// 	ZeroMemory(&g_STRemoteInfo,sizeof(STRemoteInfo));
// 
// 	INT nCount = cf.Read(&g_STRemoteInfo, sizeof(STRemoteInfo));
// 	if (nCount != sizeof(STRemoteInfo))
// 	{
// 		cf.Close();
// 		return FALSE;
// 	}
// 
// 	// 清除资源;
// 	cf.Close();
// 
// 	return TRUE;
// }

BOOL OpenShareDirectory()
{
	// 读取remotecfg.dat;
	if (strcmp(g_szModulePath, _T("")) == 0)
		return FALSE;

	TCHAR szdbcfgFile[MAX_PATH] = { _T("") };
	sprintf(szdbcfgFile, _T("%s%s"), g_szModulePath, _T("dbconfig.dat"));

	// 没找到文件;
	if (!PathFileExists(szdbcfgFile)) return FALSE;

	// 打开文件,读取内容;
	CFile cf;
	CFileException e;
	if (!cf.Open(szdbcfgFile, CFile::modeRead, &e))
	{
		// 打开文件失败;
		e.ReportError();
		return FALSE;
	}

	DBSAVE dbcfg;
	// 清空STRemoteInfo结构;
	ZeroMemory(&dbcfg, sizeof(DBSAVE));

	INT nCount = cf.Read(&dbcfg, sizeof(DBSAVE));
	if (nCount != sizeof(DBSAVE))
	{
		cf.Close();
		return FALSE;
	}

	// 清除资源;
	cf.Close();

	// 解析数据;
	TCHAR szHost[51] = {0};
	for (int i = 0; i < 50; i++)
	{
		if (dbcfg.server[i])
			szHost[i] = 500 - dbcfg.server[i];// = 500 - dbcfg.server[i];
		if (dbcfg.user[i])
			dbcfg.user[i] = 500 - dbcfg.user[i];
		if (dbcfg.psw[i])
			dbcfg.psw[i] = 500 - dbcfg.psw[i];
	}

	CString strHost = _T("");
	strHost.Format(_T("%s"),szHost);

	strHost.TrimLeft();
	strHost.TrimRight(".");
	strHost.TrimRight();
	if (strHost.Find(".ly.com") == -1 && strHost.Find("192.168.") == -1)
		MyGetIPByName(strHost);

	// 尝试打开共享目录;
	TCHAR szShareOriginal[MAX_PATH] = {_T("")};
	TCHAR szShareEarly[MAX_PATH] = { _T("") };
	TCHAR szShareFurther[MAX_PATH] = { _T("") };
	TCHAR szShareDesign[MAX_PATH] = { _T("") };

	sprintf(szShareOriginal, _T("\\\\%s\\%s"), strHost, _T("客户原片(管理软件)$"));
	sprintf(szShareEarly, _T("\\\\%s\\%s"), strHost, _T("修好的片(管理软件)$"));
	sprintf(szShareFurther, _T("\\\\%s\\%s"), strHost, _T("精修好的片(管理软件)$"));
	sprintf(szShareDesign, _T("\\\\%s\\%s"), strHost, _T("设计好的片(管理软件)$"));

	if (!PathFileExists(szShareOriginal) || !PathFileExists(szShareEarly) ||
		!PathFileExists(szShareFurther)  || !PathFileExists(szShareDesign) )
		return FALSE;

	return TRUE;
}



/************************************************************************/
/*
	Date:	2015-04-08
	Author:	Jeff
	函数：GetDiskSpaceInfo
	描述：获取指定目录或盘符的容量信息;
	参数：
		IN:	lpRootPathName 根目录名称;
		INOUT: dTotalNum  总容量;
		INOUT: dFreeNum 可用容量;
	返回：
	注意：
		GetDiskFreeSpace函数不能满足当前超过2T的硬盘容量,因为里面的数据类型是UINT,最大支持32位(4G);
		GetDiskFreeSpaceEx支持64位(16384P=1024*16384T)
	只能获取本机硬盘信息,且路径必须包含":"冒号;
	调用约定：
*/
/************************************************************************/
BOOL GetDiskSpaceInfo(IN LPCTSTR lpRootPathName,IN OUT double &dTotalNum, IN OUT double &dFreeNum)
{
	// 校验参数有效性;
	if(lpRootPathName == NULL || _tcscmp(lpRootPathName,_T("")) == 0)
	{
		//_tprintf_s(_T("根目录为空!"));
		return FALSE;
	}

	// 如果长度==1;
	int nlen = _tcslen(lpRootPathName);
	if((1 == nlen) || ( 2 == nlen && lpRootPathName[nlen-1] != _T(':')))
	{
		//_tprintf_s(_T("根目录无效!\n"));
		return FALSE;
	}

	if ( !PathFileExists(lpRootPathName))
	{
		//_tprintf_s(_T("根目录不存在!\n"));
		return FALSE;
	}

 	BOOL fResult = FALSE;
	DWORD dwSectPerClust;	// 每簇的扇区数;
	DWORD dwBytesPerSect;	// 每个扇区的字节数;
	DWORD dwFreeClusters;	// 可用簇数;
	DWORD dwTotalClusters;	// 总簇数;

	typedef BOOL (WINAPI *P_GDFSE)(LPCTSTR, PULARGE_INTEGER,PULARGE_INTEGER, PULARGE_INTEGER);
	P_GDFSE pGetDiskFreeSpaceEx = NULL;

	/*unsigned*/ __int64 i64FreeBytesToCaller;
	/*unsigned*/ __int64 i64TotalBytes;
	/*unsigned*/ __int64 i64FreeBytes;

	// 调用GetDiskFreeSpaceEx失败则调用GetDiskSpace;
#ifdef UNICODE
	pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress(GetModuleHandle(_T("kernel32.dll")),"GetDiskFreeSpaceExW");
#else
	pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetDiskFreeSpaceExA");
#endif

	if ( pGetDiskFreeSpaceEx )
	{
		fResult = pGetDiskFreeSpaceEx(lpRootPathName,
			(PULARGE_INTEGER)&i64FreeBytesToCaller,
			(PULARGE_INTEGER)&i64TotalBytes,
			(PULARGE_INTEGER)&i64FreeBytes);

		if ( fResult )
		{
			// 将单位由byte转为G byte;
			dTotalNum = (double)i64TotalBytes/1024/1024/1024;
			dFreeNum = (double)i64FreeBytes/1024/1024/1024;
		}
	}
	else
	{
		fResult = GetDiskFreeSpace(lpRootPathName,
			&dwSectPerClust,
			&dwBytesPerSect,
			&dwFreeClusters,
			&dwTotalClusters);

		if ( fResult )
		{
			// 成功获得容量信息;
			i64TotalBytes = (__int64)dwTotalClusters * dwSectPerClust * dwBytesPerSect;
			i64FreeBytes = (__int64)dwFreeClusters * dwSectPerClust * dwBytesPerSect;

			// 将单位由byte转为G byte;
			dTotalNum = (double)i64TotalBytes/1024/1024/1024;
			dFreeNum = (double)i64FreeBytes/1024/1024/1024;
		}
	}

	return fResult;
}

/************************************************************************/
/*
	Date:	2015-04-08
	Author:	Jeff
	函数：GetNetShareInfo
	描述：获取指定目录或盘符的容量信息;
	参数：
		IN:	lpszServer DNS或NETBOIS远程计算机名,NULL时表示本机;This string must begin with \\.
		IN: lpszShare  要获取信息的共享名称(可以是共享文件夹、打印机等任何设备);
	返回：成功返回TRUE;
	注意：非本机的网络设备访问需要权限,否则res返回ERROR_ACCESS_DENIED;
	调用约定：
*/
/************************************************************************/
BOOL GetNetShareInfo(IN LPCTSTR lpszServer, IN LPCTSTR lpszShare, OUT LPTSTR lpPath)
{
	PSHARE_INFO_502 psi502 = NULL;
	NET_API_STATUS res;

	WCHAR szServer[MAX_PATH] = {0};
	WCHAR szShare[MAX_PATH] = {0};
	MultiByteToWideChar(CP_ACP, 0, lpszServer, -1, szServer, MAX_PATH);
	MultiByteToWideChar(CP_ACP, 0, lpszShare, -1, szShare, MAX_PATH);
	if ((res = NetShareGetInfo((char*)szServer,(char*)szShare,502,(LPBYTE*)&psi502)) == ERROR_SUCCESS)
		wsprintf((char*)lpPath,"%S",psi502->shi502_path);

	// 释放资源;
	NetApiBufferFree(psi502);

	return (res==ERROR_SUCCESS)?TRUE:FALSE;
}

/************************************************************************/
/*
	Date:	2015-04-10
	Author:	Jeff
	函数:GetEnableShareDirectory
	描述:返回指定相片类型可用的共享目录;
	参数:
		IN:		nPhotoType	相片类型;
		IN:		lpOrderNum  订单号;
		IN:		lpDomain    分店域名;
		OUT:	lpEnableShareDirectory	可用的共享目录;
	返回:成功返回TRUE;
	注意:用于导入相片,最后返回的共享目录,使用MakeSuerDirectoryPathExists函数创建目录;
	调用约定:#
*/
/************************************************************************/
BOOL GetEnableShareDirectory(IN const int &nPhotoType, IN LPCTSTR lpOrderNum, IN LPCTSTR lpDomain, OUT LPTSTR lpEnableShareDirectory)
{
	// 需要判断域名有效性;
	if (lpDomain && strcmp(lpDomain, "") != 0)
	{
		TCHAR *szResult = strstr(lpDomain,".ly.com");
		if(szResult == NULL)
		{
			// 传入的域名有误;
			return FALSE;
		}
	}

	// 1.先判断当前局域网原始共享目录可用大小(是否小于20G);
	TCHAR szShare[MAX_PATH] = {0};
	switch( nPhotoType )
	{
	case 1:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片(管理软件)$");
		break;
	case 2:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "修好的片(管理软件)$");
		break;
	case 3:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "精修好的片(管理软件)$");
		break;
	case 4:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "设计好的片(管理软件)$");
		break;
#ifdef ENTERPRISE_VERSION
#ifndef CHILD_VERSION
	case 5:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片备份(管理软件)$");
		break;
	case 6:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "修好的片备份(管理软件)$");
		break;
	case 7:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "精修好的片备份(管理软件)$");
		break;
	case 8:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "设计好的片备份(管理软件)$");
		break;
#else
	case 5:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片备份(儿童管理软件)$");
		break;
	case 6:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "修好的片备份(儿童管理软件)$");
		break;
	case 7:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "精修好的片备份(儿童管理软件)$");
		break;
	case 8:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "设计好的片备份(儿童管理软件)$");
		break;
#endif
#endif
	
	default:
		break;
	}
	
	// 如果订单号存在原始共享目录中,判断目录容量是否有5G大小,如果有则存入,否则存入到别的优先级高的共享目录;
	TCHAR szOrderNum[MAX_PATH] = {0};
	if ( lpDomain == NULL || strcmp(lpDomain,"") == 0)
	{
		// 分店域名为空,则为本店;
		sprintf(szOrderNum,"%s\\%s", szShare, lpOrderNum);
	}
	else
	{// 分店域名不为空;
		
		if ( strcmp(lpDomain, g_domain) == 0)
		{
			// 本店域名;
			sprintf(szOrderNum,"%s\\%s", szShare, lpOrderNum);
		}
		else
		{
			sprintf(szOrderNum,"%s\\%s\\%s", szShare, lpDomain, lpOrderNum);
		}
	}

	double dTotalNum = 0.0;
	double dFreeNum = 0.0;
	if ( !GetDiskSpaceInfo(szShare,dTotalNum,dFreeNum) )
	{
		// 获取硬盘大小失败;
		return FALSE;
	}

	// 订单文件夹存在且原始共享目录可用大小>5G;
	if ( (PathFileExists(szOrderNum) && dFreeNum > MINI_CAPACITY) || dFreeNum > 400)
	{
		// 返回原始共享目录;
		sprintf(lpEnableShareDirectory,"%s",szOrderNum);
		return TRUE;
	}

	//////////////////////////////////////////////////////////////////////////
	// 原始共享目录不可用,使用其他高优先级共享目录;
	if ( g_aryOfSharePathInfo.GetSize() == 0)
	{
		// 记录为空,则仍旧使用原始共享目录;
		
		AfxMessageBox(_T("硬盘容量小于30G,请添加新共享硬盘!"));
		sprintf(lpEnableShareDirectory,"%s",szOrderNum);
		//return FALSE;
		return TRUE;
	}

	typedef struct _STNetSharePathInfo__
	{
		BYTE byPhotType;
		BYTE byCapacity;
		BYTE byPriority;
		CString strShareHost;
		CString strSharePath;
	}STNetSharePathInfo,*pSTNetSharePathInfo;

	//STNetSharePathInfo tagNetShareInfo;
	//ZeroMemory(&tagNetShareInfo,sizeof(STNetSharePathInfo));

	BYTE byCurPriority = 0;
	int nSize = g_aryOfSharePathInfo.GetSize();
	for ( int i = 0; i < nSize; i++)
	{
		STNetSharePathInfo tempNetShaerInfo;
		ZeroMemory(&tempNetShaerInfo,sizeof(STNetSharePathInfo));
		// 获取高优先级共享目录,依次取低优先级目录,直到获取可用目录为止;
		tempNetShaerInfo.byPhotType = atoi(g_aryOfSharePathInfo.ElementAt(i).ElementAt(4));
		tempNetShaerInfo.byCapacity = atoi(g_aryOfSharePathInfo.ElementAt(i).ElementAt(3));
		tempNetShaerInfo.byPriority = atoi(g_aryOfSharePathInfo.ElementAt(i).ElementAt(5));
		tempNetShaerInfo.strShareHost = g_aryOfSharePathInfo.ElementAt(i).ElementAt(1);
		tempNetShaerInfo.strSharePath = g_aryOfSharePathInfo.ElementAt(i).ElementAt(2);

		//////////////////////////////////////////////////////////////////////////
		// 判断目录下是否有订单文件夹;
		sprintf(szShare,"\\\\%s\\%s",tempNetShaerInfo.strShareHost,tempNetShaerInfo.strSharePath);
		if (lpDomain && strcmp(lpDomain,"") != 0)
		{
			sprintf(szOrderNum,"%s\\%s\\%s",szShare, lpDomain ,lpOrderNum);
		}
		else
		{
			sprintf(szOrderNum,"%s\\%s",szShare, lpOrderNum);
		}

		// 存在且目录容量仍大于5G可用;
		if ( PathFileExists(szOrderNum) )
		{
			if ( !GetDiskSpaceInfo(szShare,dTotalNum,dFreeNum) )
			{
				// 获取硬盘大小失败;
				continue;
			}

			if ( dFreeNum > MINI_CAPACITY)
			{
				break;
			}
		}

		//////////////////////////////////////////////////////////////////////////
		// 第一次,tag优先值==0,小于任何表记录优先级;
		if( byCurPriority > tempNetShaerInfo.byPriority )
			continue;

		if (tempNetShaerInfo.byPhotType == nPhotoType)
		{
			// 判断共享路径是否可用;
			sprintf(szShare,"\\\\%s\\%s",tempNetShaerInfo.strShareHost,tempNetShaerInfo.strSharePath);
			if ( GetDiskSpaceInfo(szShare,dTotalNum,dFreeNum) )
			{
				if ( dFreeNum > tempNetShaerInfo.byCapacity )
				{
					// 可用;
					// 获取高优先级共享目录,依次取低优先级目录,直到获取可用目录为止;
					if (lpDomain && strcmp(lpDomain,"") != 0)
					{
						sprintf(szOrderNum,"%s\\%s\\%s",szShare,lpDomain, lpOrderNum);
					}
					else
					{
						sprintf(szOrderNum,"%s\\%s",szShare, lpOrderNum);
					}
				}
			}
		}
	}


	//////////////////////////////////////////////////////////////////////////
	// 返回结果;
	sprintf(lpEnableShareDirectory,"%s",szOrderNum);

	return TRUE;
}

/************************************************************************/
/*
	Date:	2015-04-11
	Author:	Jeff
	函数：GetExistsShareDirectory
	描述：获取指定相片信息的所有共享目录;
	参数：
		IN:		nPhotoType	相片类型;
		IN:		lpOrderNum  订单号;
		IN:		lpDomain    分店域名;
		OUT:	strArray	存在订单的所有共享目录;
	返回：成功返回TRUE;
	注意：#;
	调用约定：#
*/
/************************************************************************/
BOOL GetExistsShareDirectory(IN const int &nPhotoType, IN LPCTSTR lpOrderNum, IN LPCTSTR lpDomain, OUT CStringArray &strArray)
{
	//////////////////////////////////////////////////////////////////////////
	// 1.首先查找原始共享目录;
	//////////////////////////////////////////////////////////////////////////

	// 需要判断域名有效性;
	if (lpDomain && strcmp(lpDomain, "") != 0)
	{
		TCHAR *szResult = strstr(lpDomain,".ly.com");
		if(szResult == NULL)
		{
			// 传入的域名有误;
			return FALSE;
		}
	}

	// 1.先判断当前局域网原始共享目录可用大小(是否小于20G);
	TCHAR szShare[MAX_PATH] = {0};
	switch( nPhotoType )
	{
	case 1:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片(管理软件)$");
		break;
	case 2:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "修好的片(管理软件)$");
		break;
	case 3:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "精修好的片(管理软件)$");
		break;
	case 4:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "设计好的片(管理软件)$");
		break;
#ifdef ENTERPRISE_VERSION
#ifndef CHILD_VERSION
	case 5:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片备份(管理软件)$");
		break;
	case 6:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "修好的片备份(管理软件)$");
		break;
	case 7:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "精修好的片备份(管理软件)$");
		break;
	case 8:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "设计好的片备份(管理软件)$");
		break;
#else
	case 5:
		sprintf(szShare, "\\\\%s\\%s", g_serverbak, "客户原片备份(儿童管理软件)$");
		break;
	case 6:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "修好的片备份(儿童管理软件)$");
		break;
	case 7:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "精修好的片备份(儿童管理软件)$");
		break;
	case 8:
		sprintf(szShare,"\\\\%s\\%s", g_serverbak, "设计好的片备份(儿童管理软件)$");
		break;
#endif
#endif

	default:
		break;
	}

	TCHAR szOrderNum[MAX_PATH] = {0};
	if ( lpDomain == NULL || strcmp(lpDomain,"") == 0)
	{
		// 分店域名为空,则为本店;
		sprintf(szOrderNum,"%s\\%s", szShare, lpOrderNum);
	}
	else
	{// 分店域名不为空;

		if ( strcmp(lpDomain, g_domain) == 0)
		{
			// 本店域名;
			sprintf(szOrderNum,"%s\\%s", szShare, lpOrderNum);
		}
		else
		{
			sprintf(szOrderNum,"%s\\%s\\%s", szShare, lpDomain, lpOrderNum);
		}
	}

	if ( PathFileExists(szOrderNum) )
	{
		strArray.Add(CString(szOrderNum));
	}

	//////////////////////////////////////////////////////////////////////////
	// 2.再查找其他共享目录;
	//////////////////////////////////////////////////////////////////////////
	int nSize = g_aryOfSharePathInfo.GetSize();
	for (int i = 0; i < nSize; i++)
	{
		sprintf(szShare,"\\\\%s\\%s",g_aryOfSharePathInfo.ElementAt(i).ElementAt(1),g_aryOfSharePathInfo.ElementAt(i).ElementAt(2));
		if (lpDomain && strcmp(lpDomain,"") != 0)
		{
			sprintf(szOrderNum,"%s\\%s\\%s",szShare,lpDomain, lpOrderNum);
		}
		else
		{
			sprintf(szOrderNum,"%s\\%s",szShare, lpOrderNum);
		}

		if ( PathFileExists(szOrderNum) )
		{
			strArray.Add(CString(szOrderNum));
		}
	}
}

/************************************************************************/
/*  函数：WriteTextLog[7/28/2016 IT];
/*  描述：写文本日志;
/*  参数：;
/*  	[IN] ：;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void WriteTextLog(const TCHAR *format, ...)
{
	try
	{
		// 解析出日志路径;
		TCHAR szlogpath[MAX_PATH] = {0};
		static TCHAR szModulePath[MAX_PATH] = {0};
		static TCHAR szFna[_MAX_DIR] = { 0 };
		if ( szModulePath[0] == _T('\0') )
		{
			TCHAR szDrive[_MAX_DRIVE] = { 0 };
			TCHAR szDir[_MAX_DIR] = { 0 };
			TCHAR szExt[_MAX_DIR] = { 0 };
			::GetModuleFileName(NULL, szModulePath, sizeof(szModulePath) / sizeof(TCHAR));
			_splitpath(szModulePath, szDrive, szDir, szFna, szExt);
			strcpy(szModulePath, szDrive);
			strcat(szModulePath, szDir);
		}

		sprintf(szlogpath, _T("%s客户端日志.txt"), szModulePath);

		// 打开或创建文件;
		CStdioFile fp;
		if (PathFileExists(szlogpath))
		{
			if ( !fp.Open(szlogpath, CFile::modeWrite) )
			{
				return;
			}
			fp.SeekToEnd();
		}
		else
		{
			if ( !fp.Open(szlogpath, CFile::modeCreate | CFile::modeWrite) )
				return;
		}

		// 格式化前设置语言区域;
		TCHAR* old_locale = _tcsdup(_tsetlocale(LC_CTYPE, NULL));
		_tsetlocale(LC_CTYPE, _T("chs"));//设定中文;

		// 格式化日志内容;
		va_list		args = NULL;
		int			len = 0;
#if defined(VC70) || defined(VC60)
		static TCHAR buffer[8192] = {0};
		va_start( args, format );
		memset(buffer, 0, 8192);
		vsprintf( buffer, format, args ); // C4996

		// 将日志内容输入到文件中;
		fp.WriteString( CTime::GetCurrentTime().Format(_T("%Y-%m-%d %H:%M:%S ")) );
		fp.WriteString(buffer);
		fp.WriteString(_T("\n"));
#else
		TCHAR *buffer = NULL;
		va_start( args, format );
		// _vscprintf doesn't count. terminating '\0'
		len = _vsctprintf_p( format, args );
		if ( len == -1 )
		{
			goto clear;
		}

		len++;
		buffer = (TCHAR*)malloc( len * sizeof(TCHAR) );
		_vstprintf_s( buffer, len, format, args ); // C4996

		// Note: vsprintf is deprecated; consider using vsprintf_s instead
		// 将日志内容输入到文件中;
		fp.WriteString( CTime::GetCurrentTime().Format(_T("%Y-%m-%d %H:%M:%S ")) );
		fp.WriteString(buffer);
		fp.WriteString(_T("\n"));

		free( buffer );
#endif
		// 关闭文件，释放资源并设置回原语言区域;
		//free( buffer );
clear:
		_tsetlocale(LC_CTYPE, old_locale);
		free(old_locale);//还原区域设定;
		fp.Close();
	}
	catch (CException *e)
	{
		e->ReportError();
		e->Delete();
	}
}