#include "StdAfx.h"
#include "ImgOfOriginal.h"
#include "underlyingapi.h"
#include "global.h"
#include "filehelp.h"
using namespace filehelping;

ULONG_PTR ImgOfOriginal::m_gdiplusToken;
ImgOfOriginal::ImgOfOriginal(void)
{
	GdiplusStartupInput gdiplusStartupInput;
	GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);
}

ImgOfOriginal::~ImgOfOriginal(void)
{
	Gdiplus::GdiplusShutdown(m_gdiplusToken);
}

BOOL ImgOfOriginal::InitializeEnvironment(IN LPCTSTR lpBranchId, IN IMGSHARE_VEC* pvtImgShareInfo)
{
	if (g_pBranchId && gp_vtImgShareInfo)
		return TRUE;

	g_pBranchId = lpBranchId;
	gp_vtImgShareInfo = pvtImgShareInfo;

	return TRUE;
}

#if 0
/************************************************************************/
/*
函数:AppendLocalSharepath
描述:将本机的固定的共享目录添加到指针对象pvtImgShareInfo中;
参数:
IN OUT: pvtImgShareInfo 共享路径容器;
返回:
注意: 需要获取本机的加密锁存储的域名值;
*/
/************************************************************************/
void ImgOfOriginal::AppendLocalSharepath(IN OUT IMGSHARE_VEC *pvtImgShareInfo)
{
	if (pvtImgShareInfo)
	{
		ImgShareInfo tagImgShare;
		tagImgShare.bEnable = TRUE;
		tagImgShare.byMinCapacity = 5;
		tagImgShare.byMaxCapacity = 35;
		tagImgShare.byImgType = OImgtype;
		tagImgShare.byPriority = 255;
		_stprintf_s(tagImgShare.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), OImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare));

		ImgShareInfo tagImgShare1;
		tagImgShare1.bEnable = TRUE;
		tagImgShare1.byMinCapacity = 5;
		tagImgShare1.byMaxCapacity = 35;
		tagImgShare1.byImgType = EImgtype;
		tagImgShare1.byPriority = 255;
		_stprintf_s(tagImgShare1.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare1.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), EImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare1));

		ImgShareInfo tagImgShare2;
		tagImgShare2.bEnable = TRUE;
		tagImgShare2.byMinCapacity = 5;
		tagImgShare2.byMaxCapacity = 35;
		tagImgShare2.byImgType = FImgtype;
		tagImgShare2.byPriority = 255;
		_stprintf_s(tagImgShare2.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare2.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), FImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare2));

		ImgShareInfo tagImgShare3;
		tagImgShare3.bEnable = TRUE;
		tagImgShare3.byMinCapacity = 5;
		tagImgShare3.byMaxCapacity = 35;
		tagImgShare3.byImgType = DImgtype;
		tagImgShare3.byPriority = 255;
		_stprintf_s(tagImgShare3.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare3.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), DImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare3));

		//////////////////////////////////////////////////////////////////////////
		ImgShareInfo tagImgShare4;
		tagImgShare4.bEnable = TRUE;
		tagImgShare4.byMinCapacity = 5;
		tagImgShare4.byMaxCapacity = 35;
		tagImgShare4.byImgType = OBImgtype;
		tagImgShare4.byPriority = 255;
		_stprintf_s(tagImgShare4.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare4.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), OBImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare4));

		ImgShareInfo tagImgShare5;
		tagImgShare5.bEnable = TRUE;
		tagImgShare5.byMinCapacity = 5;
		tagImgShare5.byMaxCapacity = 35;
		tagImgShare5.byImgType = EBImgtype;
		tagImgShare5.byPriority = 255;
		_stprintf_s(tagImgShare5.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare5.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), EBImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare5));

		ImgShareInfo tagImgShare6;
		tagImgShare6.bEnable = TRUE;
		tagImgShare6.byMinCapacity = 5;
		tagImgShare6.byMaxCapacity = 35;
		tagImgShare6.byImgType = FBImgtype;
		tagImgShare6.byPriority = 255;
		_stprintf_s(tagImgShare6.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare6.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), FBImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare6));

		ImgShareInfo tagImgShare7;
		tagImgShare7.bEnable = TRUE;
		tagImgShare7.byMinCapacity = 5;
		tagImgShare7.byMaxCapacity = 35;
		tagImgShare7.byImgType = DBImgtype;
		tagImgShare7.byPriority = 255;
		_stprintf_s(tagImgShare7.szBranchId, MAX_PATH, _T("%s"), _T("本机加密狗"));
		_stprintf_s(tagImgShare7.szShareDirectory, MAX_PATH, _T("\\\\%s\\%s\\"), _T("主机名"), DBImgpath);
		pvtImgShareInfo->push_back(new ImgShareInfo(tagImgShare7));
	}
}
#endif

CString ImgOfOriginal::GetFileName(IN CONST CString& strfile)
{
	CString name = _T("");
	int nIndex = strfile.ReverseFind(_T('\\'));
	if (nIndex == -1)
		return _T("");

	name = strfile.Mid(nIndex + 1);
	nIndex = name.ReverseFind(_T('.'));
	if (nIndex == -1)
		return _T("");

	name = name.Mid(0, nIndex);

	return name;
}
/************************************************************************/
/*
函数:GetFilteringImg
描述:过滤掉扩展名不符合要求的文件名;
参数:
IN:		AryImgs 要被过滤的文件名数组;
IN:		lpCopyExt 要保留的文件的扩展名;
返回:
注意:
*/
/************************************************************************/
void ImgOfOriginal::GetFilteringImg(IN CStringArray &AryImgs, IN LPCTSTR lpCopyExt)
{
	if (AryImgs.GetSize() == 0 || lpCopyExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strCopyExt(lpCopyExt);
	if (strCopyExt.find(_T("*.*")) != TString::npos) return;

	strCopyExt.append(_T("|"));
	STR_VEC vtCopyExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strCopyExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strCopyExt.substr(0, nIndex);
			strCopyExt = strCopyExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtCopyExt.push_back(strtmp);
		}
	} while (strCopyExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (int i = AryImgs.GetSize(); i > 0; i--)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtCopyExt.begin(); itExt != vtCopyExt.end(); itExt++)
		{
			if (AryImgs.ElementAt(i).MakeLower().Find(itExt->c_str()) != -1) {
				bExsit = TRUE;
				break;
			}
		}

		if (!bExsit) {
			AryImgs.RemoveAt(i);
			continue;
		}

#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
		nIndex = AryImgs.ElementAt(i).ReverseFind(_T('\\'));
		if (nIndex != -1)
		{
			strtmp = AryImgs.ElementAt(i).Mid(nIndex + 1);
			if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
				AryImgs.RemoveAt(i);
				continue;
			}
		}
#endif
	}
}

/************************************************************************/
/*
函数:GetFilteringImg
描述:过滤掉扩展名不符合要求的文件名;
参数:
IN:		AryImgs 要被过滤的文件名数组;
IN:		lpCopyExt 要保留的文件的扩展名;
返回:
注意:
*/
/************************************************************************/
void ImgOfOriginal::GetFilteringImg(IN STR_VEC &vtImgs, IN LPCTSTR lpCopyExt)
{
	if (vtImgs.size() == 0 || lpCopyExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strCopyExt(lpCopyExt);
	if (strCopyExt.find(_T("*.*")) != TString::npos) return;

	strCopyExt.append(_T("|"));
	STR_VEC vtCopyExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strCopyExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strCopyExt.substr(0, nIndex);
			strCopyExt = strCopyExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtCopyExt.push_back(strtmp);
		}
	} while (strCopyExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtImgs.begin(); it != vtImgs.end();)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtCopyExt.begin(); itExt != vtCopyExt.end(); itExt++)
		{
			if (filehelpImpl::match(itExt->c_str(), it->c_str())) {
				bExsit = TRUE;
				break;
			}
		}

		if (!bExsit) {
			it = vtImgs.erase(it);
			continue;
		}

#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
		nIndex = it->find_last_of(_T('\\'));
		if (nIndex != TString::npos) {
			strtmp = it->substr(nIndex + 1);
			if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
				it = vtImgs.erase(it);
				continue;
			}
		}
#endif
		it++;
	}
}

void ImgOfOriginal::SubgroupExt(IN STR_VEC &vtAllImgs, IN LPCTSTR lpSubgroupExt, IN CStringArray &AryImgs)
{
	if (vtAllImgs.size() == 0 || lpSubgroupExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strSubgroupExt(lpSubgroupExt);
	if (strSubgroupExt.find(_T("*.*")) != TString::npos)
	{
		for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
			AryImgs.Add(CString(it->c_str()));
		return;
	}

	strSubgroupExt.append(_T("|"));
	STR_VEC vtSubgroupExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strSubgroupExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strSubgroupExt.substr(0, nIndex);
			strSubgroupExt = strSubgroupExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtSubgroupExt.push_back(strtmp);
		}
	} while (strSubgroupExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtSubgroupExt.begin(); itExt != vtSubgroupExt.end(); itExt++)
		{
			if (filehelpImpl::match(itExt->c_str(), it->c_str()))
			{
#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
				nIndex = it->find_last_of(_T('\\'));
				if (nIndex != TString::npos)
				{
					strtmp = it->substr(nIndex + 1);
					if (strtmp[0] == _T('s') || strtmp[0] == _T('m'))
					{
						continue;
					}
				}
#endif

				AryImgs.Add(CString(it->c_str()));
				break;
			}
		}
	}
}


void ImgOfOriginal::SubgroupExt(IN STR_VEC &vtAllImgs, IN LPCTSTR lpSubgroupExt, IN STR_VEC &vtImgs)
{
	if (vtAllImgs.size() == 0 || lpSubgroupExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strSubgroupExt(lpSubgroupExt);
	if (strSubgroupExt.find(_T("*.*")) != TString::npos)
	{
		for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
			vtImgs.push_back(*it);
		return;
	}

	strSubgroupExt.append(_T("|"));
	STR_VEC vtSubgroupExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strSubgroupExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strSubgroupExt.substr(0, nIndex);
			strSubgroupExt = strSubgroupExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtSubgroupExt.push_back(strtmp);
		}
	} while (strSubgroupExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtSubgroupExt.begin(); itExt != vtSubgroupExt.end(); itExt++)
		{
			if (filehelpImpl::match(itExt->c_str(), it->c_str())) {
#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
				nIndex = it->find_last_of(_T('\\'));
				if (nIndex != TString::npos) {
					strtmp = it->substr(nIndex + 1);
					if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
						continue;
					}
				}
#endif
				vtImgs.push_back(*it);
				break;
			}
		}
	}
}
/************************************************************************/
/*
函数:CopyImg2Specifiedpath
描述:拷贝相片到指定的目录;
参数:
IN:	lpExistpath 相片源目录;
IN:	lpSpecifiedpath	目标路径;
IN:	lpCopyExt	指定要复制的文件的扩展名;
IN:	dwCopyPix	复制时是否要压缩成指定像素;
IN:	bOriginalCopy	复制源相片时,是否原样复制;
IN:	bFailIfExists	目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath(IN LPCTSTR lpExistpath, IN LPCTSTR lpSpecifiedpath, IN LPCTSTR lpCopyExt, IN CONST DWORD &dwCopyPix, IN BOOL bOriginalCopy, IN BOOL bFailIfExists)
{
	// 源目录不存在,返回-1;
	if (!PathFileExists(lpExistpath)) return -1;

	// 判断目标目录是否存在,不存在创建;
	if (!PathFileExists(lpSpecifiedpath))
		if (!underlyingapi::CreateDirectoryEx(lpSpecifiedpath))
			return 0;

	// 查找源目录下全部文件;
	STR_VEC vtFiles;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpExistpath, _T("*.*"), &vtFiles);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	// 若是原名导入时,这里不应该过滤任何相片;只有导出时才需要过滤;
	GetFilteringImg(vtFiles, lpCopyExt);

	int nCount = 0;
	int nIndex = 0;
	TString strtmp;
	if (bOriginalCopy && dwCopyPix != INVALID_COPY_PIX) // 是否原样复制 且压缩;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			strtmp.append(it->substr(it->find(lpExistpath) + _tcslen(lpExistpath) + 1));
			if (PathFileExists(strtmp.c_str()) && bFailIfExists)
				continue;

			if (underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp.c_str(), 100))
			{
				// 返回压缩失败原因;
			}
			else
				nCount++;
		}
	}
	else if (bOriginalCopy && dwCopyPix == INVALID_COPY_PIX)// 原样复制,不压缩;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			strtmp.append(it->substr(it->find(lpExistpath) + _tcslen(lpExistpath) + 1));

			// 按需要创建 or // 避免多次调用创建文件函数,应该在外面一次性创建完,再执行复制操作;
again:			if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
				{
					DWORD dwError = GetLastError();
					if (dwError == ERROR_PATH_NOT_FOUND)
					{
						// 目录不存在,创建;
						underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
						goto again;
					}
				}
				else
					nCount++;
		}
	}
	else if (!bOriginalCopy && dwCopyPix != INVALID_COPY_PIX)	// 压缩,不原样复制,所有源相片放在目标根目录;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp.append(it->substr(nIndex + 1));
				if (PathFileExists(strtmp.c_str()) && bFailIfExists)
					continue;

				if (!underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp.c_str(), 100))
				{
					// 返回压缩失败原因;
					OutputDebugString(_T("压缩文件失败!\n"));
				}
				else
					nCount++;
			}
		}
	}
	else	// 不压缩,不原样;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp.append(it->substr(nIndex + 1));
				// 按需要创建 or // 避免多次调用创建文件函数,应该在外面一次性创建完,再执行复制操作;
again1:				if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
					{
						DWORD dwError = GetLastError();
						if (dwError == ERROR_PATH_NOT_FOUND)
						{
							// 目录不存在,创建;
							underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
							goto again1;
						}
					}
					else
						nCount++;
			}
		}
	}

	return nCount;
}

/************************************************************************/
/*
函数:CopyImg2Specifiedpath
描述:拷贝相片到指定的目录;
参数:
IN:	AryOfSelectedImg 源相片数组;
IN:	lpSpecifiedpath	目标路径;
IN:	lpWithExt	指定要复制的其他同名文件的扩展名;
IN:	dwCopyPix	复制时是否要压缩成指定像素;
IN:	bCopyBySubpath	复制时是否创建子目录;
IN:	lpSeparator	    复制时如何创建子目录,通过该分隔串截取源相片路径剩余路径创建子目录;
IN:	bFailIfExists	目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath(IN CStringArray& AryOfSelectedImg, IN LPCTSTR lpSpecifiedpath, IN LPCTSTR lpWithExt, IN CONST DWORD &dwCopyPix, IN BOOL bCopyBySubpath, IN LPCTSTR lpSeparator, IN BOOL bFailIfExists)
{
	// 空数组则返回;
	if (AryOfSelectedImg.GetSize() == 0) return 0;

	// 判断目标目录是否存在,不存在创建;
	if (!PathFileExists(lpSpecifiedpath))
		if (!underlyingapi::CreateDirectoryEx(lpSpecifiedpath))
			return 0;

	int nCount = 0;
	int nIndex = 0;
	STR_VEC vtWithExt;
	// 解析复制子带扩展名;
	if (lpWithExt)
	{
		// 获取复制扩展名;
		TString str;
		TString strWithExt = underlyingapi::lowercase(lpWithExt);
		if (strWithExt.find(_T("*.*")) == TString::npos)
		{
			strWithExt.append(_T("|"));
			do
			{// 将所有扩展名解析到数组里;
				nIndex = strWithExt.find(_T('|'));
				if (nIndex != TString::npos)
				{
					str = strWithExt.substr(0, nIndex);
					strWithExt = strWithExt.substr(nIndex + 1);
					vtWithExt.push_back(str.substr(1));
				}
			} while (strWithExt.find(_T('|')) != TString::npos);
		}
	}

	CString strtmp;
	int nSize = AryOfSelectedImg.GetSize();
	if (!bCopyBySubpath && dwCopyPix == INVALID_COPY_PIX) // 不创建子目录,且不压缩, 直接放在目标目录下;
	{
		for (int i = 0; i < nSize; i++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp.GetAt(strtmp.GetLength() - 1) != _T('\\'))
				strtmp += _T("\\");

			nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('\\'));
			if (nIndex != -1)
			{
				strtmp += AryOfSelectedImg.ElementAt(i).Mid(nIndex + 1);
again:			    if (!CopyFile(AryOfSelectedImg.ElementAt(i), strtmp, bFailIfExists))
					{
						// 返回复制错误信息;
						DWORD dwError = GetLastError();
						if (dwError == ERROR_PATH_NOT_FOUND)
						{
							// 目录不存在,创建;
							underlyingapi::CreateDirectoryEx(strtmp.Left(strtmp.ReverseFind(_T('\\'))));
							goto again;
						}
					}
					else
						nCount++;

					// 复制其他扩展名的相片;
					for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
					{
						CString strWithExt = AryOfSelectedImg.ElementAt(i);
						strWithExt.MakeLower();
						if (strWithExt.Find(itExt->c_str()) != -1) // 不复制本扩展名;
							continue;

						nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('.'));
						if (nIndex != -1)
						{
							strWithExt.Replace(strWithExt.Mid(nIndex), itExt->c_str());
							strtmp.Replace(strtmp.Mid(strtmp.ReverseFind(_T('.'))), itExt->c_str());
							if (!CopyFile(strWithExt, strtmp, bFailIfExists))
							{
								// 返回复制错误信息;
							}
						}
					}
			}
		}
	}
	else if (!bCopyBySubpath && dwCopyPix != INVALID_COPY_PIX) // 不创建子目录, 压缩;
	{
		for (int i = 0; i < nSize; i++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp.GetAt(strtmp.GetLength() - 1) != _T('\\'))
				strtmp += _T("\\");

			nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('\\'));
			if (nIndex != -1)
			{
				strtmp += AryOfSelectedImg.ElementAt(i).Mid(nIndex + 1);
				if (PathFileExists(strtmp) && bFailIfExists)
				{//目标相片存在,且覆盖存在相片选项真;
					continue;
				}
				else
				{
					if (!underlyingapi::ImgThumbnail(AryOfSelectedImg.ElementAt(i), dwCopyPix, strtmp, 100))
					{
						// 返回压缩失败原因;
					}
					else
						nCount++;
				}

				// 复制其他扩展名的相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					CString strWithExt = AryOfSelectedImg.ElementAt(i);
					strWithExt.MakeLower();
					if (strWithExt.Find(itExt->c_str()) != -1) // 不复制本扩展名;
						continue;

					nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('.'));
					if (nIndex != -1)
					{
						strWithExt.Replace(strWithExt.Mid(nIndex), itExt->c_str());
						strtmp.Replace(strtmp.Mid(strtmp.ReverseFind(_T('.'))), itExt->c_str());
						if (!CopyFile(strWithExt, strtmp, bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
			}
		}
	}
	else if (bCopyBySubpath && dwCopyPix == INVALID_COPY_PIX) // 创建子目录,不压缩;
	{
		if (lpSeparator == NULL)
		{
			// 分隔符为空,返回错误信息;
			return FALSE;
		}

		CString strRight;
		int nSeparatorlen = _tcslen(lpSeparator);
		for (int i = 0; i < nSize; i++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp.GetAt(strtmp.GetLength() - 1) != _T('\\'))
				strtmp += _T("\\");

			nIndex = AryOfSelectedImg.ElementAt(i).Find(lpSeparator);
			if (nIndex != -1)
			{
				strRight = AryOfSelectedImg.ElementAt(i).Mid(nIndex + nSeparatorlen);
				nIndex = strRight.Find(_T("\\"));
				if (nIndex != -1)
				{
					strRight = strRight.Mid(nIndex + 1);
					strtmp += strRight;

again1:					if (!CopyFile(AryOfSelectedImg.ElementAt(i), strtmp, bFailIfExists))
						{
							// 返回复制错误信息;
							DWORD dwError = GetLastError();
							if (dwError == ERROR_PATH_NOT_FOUND)
							{
								// 目录不存在,创建;
								underlyingapi::CreateDirectoryEx(strtmp.Left(strtmp.ReverseFind(_T('\\'))));
								goto again1;
							}
						}
						else
							nCount++;

						// 复制其他扩展名的相片;
						for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
						{
							CString strWithExt = AryOfSelectedImg.ElementAt(i);
							strWithExt.MakeLower();
							if (strWithExt.Find(itExt->c_str()) != -1) // 不复制本扩展名;
								continue;

							nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('.'));
							if (nIndex != -1)
							{
								strWithExt.Replace(strWithExt.Mid(nIndex), itExt->c_str());
								strtmp.Replace(strtmp.Mid(strtmp.ReverseFind(_T('.'))), itExt->c_str());
								if (!CopyFile(strWithExt, strtmp, bFailIfExists))
								{
									// 返回复制错误信息;
								}
							}
						}
				}
			}
		}
	}
	else if (bCopyBySubpath && dwCopyPix != INVALID_COPY_PIX) // 创建子目录,压缩;
	{
		if (lpSeparator == NULL)
		{
			// 同时返回错误信息;
			return FALSE;
		}

		CString strRight;
		int nSeparatorlen = _tcslen(lpSeparator);
		for (int i = 0; i < nSize; i++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp.GetAt(strtmp.GetLength() - 1) != _T('\\'))
				strtmp += _T("\\");

			nIndex = AryOfSelectedImg.ElementAt(i).Find(lpSeparator);
			if (nIndex != -1)
			{
				strRight = AryOfSelectedImg.ElementAt(i).Mid(nIndex + nSeparatorlen);
				nIndex = strRight.Find(_T("\\"));
				if (nIndex != -1)
				{
					strRight = strRight.Mid(nIndex + 1);
					strtmp += strRight;
					if (PathFileExists(strtmp) && bFailIfExists)
					{//目标相片存在,且覆盖存在相片选项真;
						continue;
					}
					else
					{
						if (!underlyingapi::ImgThumbnail(AryOfSelectedImg.ElementAt(i), dwCopyPix, strtmp, 100))
						{
							// 返回压缩失败原因;
						}
						else
							nCount++;
					}

					// 复制其他扩展名的相片;
					for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
					{
						CString strWithExt = AryOfSelectedImg.ElementAt(i);
						strWithExt.MakeLower();
						if (strWithExt.Find(itExt->c_str()) != -1) // 不复制本扩展名;
							continue;

						nIndex = AryOfSelectedImg.ElementAt(i).ReverseFind(_T('.'));
						if (nIndex != -1)
						{
							strWithExt.Replace(strWithExt.Mid(nIndex), itExt->c_str());
							strtmp.Replace(strtmp.Mid(strtmp.ReverseFind(_T('.'))), itExt->c_str());
							if (!CopyFile(strWithExt, strtmp, bFailIfExists))
							{
								// 返回复制错误信息;
							}
						}
					}
				}
			}
		}
	}

	return nCount;
}

/************************************************************************/
/*
函数:CopyImg2Specifiedpath
描述:拷贝相片到指定的目录;
参数:
IN:	AryOfSelectedImg 源相片数组;
IN:	lpSpecifiedpath	目标路径;
IN:	lpWithExt	指定要复制的其他同名文件的扩展名;
IN:	dwCopyPix	复制时是否要压缩成指定像素;
IN:	bCopyBySubpath	复制时是否创建子目录;
IN:	lpSeparator	    复制时如何创建子目录,通过该分隔串截取源相片路径剩余路径创建子目录;
IN:	bFailIfExists	目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath(IN STR_VEC& AryOfSelectedImg, IN LPCTSTR lpSpecifiedpath, IN LPCTSTR lpWithExt, IN CONST DWORD &dwCopyPix, IN BOOL bCopyBySubpath, IN LPCTSTR lpSeparator, IN BOOL bFailIfExists)
{
	// 空数组则返回;
	if (AryOfSelectedImg.size() == 0) return 0;

	// 判断目标目录是否存在,不存在创建;
	if (!PathFileExists(lpSpecifiedpath))
		if (!underlyingapi::CreateDirectoryEx(lpSpecifiedpath))
			return 0;

	int nCount = 0;
	int nIndex = 0;
	STR_VEC vtWithExt;
	// 解析复制子带扩展名;
	if (lpWithExt)
	{
		// 获取复制扩展名;
		TString str;
		TString strWithExt = underlyingapi::lowercase(lpWithExt);
		if (strWithExt.find(_T("*.*")) == TString::npos)
		{
			strWithExt.append(_T("|"));
			do
			{// 将所有扩展名解析到数组里;
				nIndex = strWithExt.find(_T('|'));
				if (nIndex != TString::npos)
				{
					str = strWithExt.substr(0, nIndex);
					strWithExt = strWithExt.substr(nIndex + 1);
					vtWithExt.push_back(str.substr(1));
				}
			} while (strWithExt.find(_T('|')) != TString::npos);
		}
	}

	TString strtmp;
	if (!bCopyBySubpath && dwCopyPix == INVALID_COPY_PIX) // 不创建子目录,且不压缩, 直接放在目标目录下;
	{
		for (STR_VEC::iterator it = AryOfSelectedImg.begin(); it != AryOfSelectedImg.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(strtmp.c_str()) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp += it->substr(nIndex + 1);
again:			    if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
					{
						// 返回复制错误信息;
						DWORD dwError = GetLastError();
						if (dwError == ERROR_PATH_NOT_FOUND)
						{
							// 目录不存在,创建;
							underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
							goto again;
						}
					}
					else
						nCount++;

					// 复制其他扩展名的相片;
					for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
					{
						TString strWithExt = underlyingapi::lowercase(it->c_str());
						if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
							continue;

						nIndex = it->find_last_of(_T('.'));
						if (nIndex != TString::npos)
						{
							//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
							//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
							strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
							strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
							if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
							{
								// 返回复制错误信息;
							}
						}
					}
			}
		}
	}
	else if (!bCopyBySubpath && dwCopyPix != INVALID_COPY_PIX) // 不创建子目录, 压缩;
	{
		for (STR_VEC::iterator it = AryOfSelectedImg.begin(); it != AryOfSelectedImg.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(strtmp.c_str()) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp += it->substr(nIndex + 1);
				if (PathFileExists(strtmp.c_str()) && bFailIfExists)
				{//目标相片存在,且覆盖存在相片选项真;
					continue;
				}
				else
				{
					if (!underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp, 100))
					{
						// 返回压缩失败原因;
					}
					else
						nCount++;
				}

				// 复制其他扩展名的相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					TString strWithExt = underlyingapi::lowercase(it->c_str());
					if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
						continue;

					nIndex = it->find_last_of(_T('.'));
					if (nIndex != TString::npos)
					{
						//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
						//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
						strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
						strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
						if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
			}
		}
	}
	else if (bCopyBySubpath && dwCopyPix == INVALID_COPY_PIX) // 创建子目录,不压缩;
	{
		if (lpSeparator == NULL)
		{
			// 分隔符为空,返回错误信息;
			return FALSE;
		}

		TString strRight;
		int nSeparatorlen = _tcslen(lpSeparator);
		for (STR_VEC::iterator it = AryOfSelectedImg.begin(); it != AryOfSelectedImg.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(strtmp.c_str()) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find(lpSeparator);
			if (nIndex != TString::npos)
			{
				strRight = it->substr(nIndex + nSeparatorlen);
				nIndex = strRight.find(_T("\\"));
				if (nIndex != TString::npos)
				{
					strRight = strRight.substr(nIndex + 1);
					strtmp += strRight;

again1:					if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
						{
							// 返回复制错误信息;
							DWORD dwError = GetLastError();
							if (dwError == ERROR_PATH_NOT_FOUND)
							{
								// 目录不存在,创建;
								underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
								goto again1;
							}
						}
						else
							nCount++;

						// 复制其他扩展名的相片;
						for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
						{
							TString strWithExt = underlyingapi::lowercase(it->c_str());
							if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
								continue;

							nIndex = it->find_last_of(_T('.'));
							if (nIndex != TString::npos)
							{
								//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
								//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
								strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
								strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
								if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
								{
									// 返回复制错误信息;
								}
							}
						}
				}
			}
			else
			{
				// 没有该分隔符;
				OutputDebugString(_T("没有该分隔符\n"));
			}
		}
	}
	else if (bCopyBySubpath && dwCopyPix != INVALID_COPY_PIX) // 创建子目录,压缩;
	{
		if (lpSeparator == NULL)
		{
			// 同时返回错误信息;
			return FALSE;
		}

		TString strRight;
		int nSeparatorlen = _tcslen(lpSeparator);
		for (STR_VEC::iterator it = AryOfSelectedImg.begin(); it != AryOfSelectedImg.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(strtmp.c_str()) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find(lpSeparator);
			if (nIndex != TString::npos)
			{
				strRight = it->substr(nIndex + nSeparatorlen);
				nIndex = strRight.find(_T("\\"));
				if (nIndex != TString::npos)
				{
					strRight = strRight.substr(nIndex + 1);
					strtmp += strRight;
					if (PathFileExists(strtmp.c_str()) && bFailIfExists)
					{//目标相片存在,且覆盖存在相片选项真;
						continue;
					}
					else
					{
						if (!underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp, 100))
						{
							// 返回压缩失败原因;
						}
						else
							nCount++;
					}

					// 复制其他扩展名的相片;
					for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
					{
						TString strWithExt = underlyingapi::lowercase(it->c_str());
						if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
							continue;

						nIndex = it->find_last_of(_T('.'));
						if (nIndex != -1)
						{
							//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
							//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
							strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
							strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
							if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
							{
								// 返回复制错误信息;
							}
						}
					}
				}
			}
		}
	}

	return nCount;
}

/************************************************************************/
/*
函数:CopyImg2Specifiedpath
描述:拷贝相片到指定的目录;
参数:
IN:	AryOfExistImages 源相片数组;
IN:	AryOfNewImages	 目录相片数组;
IN:	dwCopyPix		 复制时是否要压缩成指定像素;
IN:	lpWithExt		 指定要复制的其他同名文件的扩展名;
IN:	bFailIfExists	 目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath(IN CStringArray& AryOfExistImages, IN CStringArray& AryOfNewImages, IN CONST DWORD &dwCopyPix, IN LPCTSTR lpWithExt, IN BOOL bFailIfExists)
{
	if (AryOfExistImages.GetSize() == 0 || AryOfNewImages.GetSize() == 0) return 0;

	int nCount = 0;
	int nIndex = 0;
	STR_VEC vtWithExt;
	// 解析复制子带扩展名;
	if (lpWithExt)
	{
		// 获取复制扩展名;
		TString str;
		TString strWithExt = underlyingapi::lowercase(lpWithExt);

		if (strWithExt.find(_T("*.*")) == TString::npos)
		{
			strWithExt.append(_T("|"));
			do
			{// 将所有扩展名解析到数组里;
				nIndex = strWithExt.find(_T('|'));
				if (nIndex != TString::npos)
				{
					str = strWithExt.substr(0, nIndex);
					strWithExt = strWithExt.substr(nIndex + 1);
					vtWithExt.push_back(str.substr(1));
				}
			} while (strWithExt.find(_T('|')) != TString::npos);
		}
	}

	CString strExist, strNew;
	// 值最小的为准;
	int nSize = (AryOfNewImages.GetSize() > AryOfExistImages.GetSize()) ? AryOfExistImages.GetSize() : AryOfNewImages.GetSize();
	if (dwCopyPix == INVALID_COPY_PIX)
	{
		for (int i = 0; i < nSize; i++)
		{
			strNew = AryOfNewImages.ElementAt(i);
			strExist = AryOfExistImages.ElementAt(i);
again:			if (!CopyFile(strExist, strNew, bFailIfExists))
				{
					// 返回复制错误信息;
					DWORD dwError = GetLastError();
					if (dwError == ERROR_PATH_NOT_FOUND)
					{
						// 目录不存在,创建;
						underlyingapi::CreateDirectoryEx(strNew.Left(strNew.ReverseFind(_T('\\'))));
						goto again;
					}
				}
				else
					nCount++;

				strNew.MakeLower();
				// 复制子带扩展名相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					if (strNew.Find(itExt->c_str()) != -1)	// 不复制本扩展名;
						continue;

					nIndex = strExist.ReverseFind(_T('.'));
					if (nIndex != -1)
					{
						strExist.Replace(strExist.Mid(nIndex), itExt->c_str());
						strNew.Replace(strNew.Mid(strNew.ReverseFind(_T('.'))), itExt->c_str());
						if (!CopyFile(strExist, strNew, bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
		}
	}
	else
	{
		for (int i = 0; i < nSize; i++)
		{
			strNew = AryOfNewImages.ElementAt(i);
			strExist = AryOfExistImages.ElementAt(i);

			if (PathFileExists(AryOfNewImages.ElementAt(i)) && bFailIfExists)
				continue;

			if (!underlyingapi::ImgThumbnail(strExist, dwCopyPix, strNew, 100))
			{
				// 返回复制错误信息;
			}
			else
				nCount++;

			strNew.MakeLower();
			// 复制子带扩展名相片;
			for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
			{
				if (strNew.Find(itExt->c_str()) != -1)	// 不复制本扩展名;
					continue;

				nIndex = strExist.ReverseFind(_T('.'));
				if (nIndex != -1)
				{
					strExist.Replace(strExist.Mid(nIndex), itExt->c_str());
					strNew.Replace(strNew.Mid(strNew.ReverseFind(_T('.'))), itExt->c_str());
					if (!CopyFile(strExist, strNew, bFailIfExists))
					{
						// 返回复制错误信息;
					}
				}
			}
		}
	}

	return nCount;
}

/************************************************************************/
/*
函数:CopyImg2Specifiedpath
描述:拷贝相片到指定的目录;
参数:
IN:	AryOfExistImages 源相片数组;
IN:	AryOfNewImages	 目录相片数组;
IN:	dwCopyPix		 复制时是否要压缩成指定像素;
IN:	lpWithExt		 指定要复制的其他同名文件的扩展名;
IN:	bFailIfExists	 目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath(IN STR_VEC& AryOfExistImages, IN STR_VEC& AryOfNewImages, IN CONST DWORD &dwCopyPix, IN LPCTSTR lpWithExt, IN BOOL bFailIfExists)
{
	if (AryOfExistImages.size() == 0 || AryOfNewImages.size() == 0) return 0;

	int nCount = 0;
	int nIndex = 0;
	STR_VEC vtWithExt;
	// 解析复制子带扩展名;
	if (lpWithExt)
	{
		// 获取复制扩展名;
		TString str;
		TString strWithExt = underlyingapi::lowercase(lpWithExt);
		if (strWithExt.find(_T("*.*")) == TString::npos)
		{
			strWithExt.append(_T("|"));
			do
			{// 将所有扩展名解析到数组里;
				nIndex = strWithExt.find(_T('|'));
				if (nIndex != TString::npos)
				{
					str = strWithExt.substr(0, nIndex);
					strWithExt = strWithExt.substr(nIndex + 1);
					vtWithExt.push_back(str.substr(1));
				}
			} while (strWithExt.find(_T('|')) != TString::npos);
		}
	}

	TString strExist, strNew;
	// 值最小的为准;
	int nSize = (AryOfNewImages.size() > AryOfExistImages.size()) ? AryOfExistImages.size() : AryOfNewImages.size();
	if (dwCopyPix == INVALID_COPY_PIX)
	{
		for (STR_VEC::iterator itExist = AryOfExistImages.begin(), itNew = AryOfNewImages.begin();
			itExist != AryOfExistImages.end() && itNew != AryOfNewImages.end(); itExist++, itNew++)
		{
			strExist = underlyingapi::lowercase(itExist->c_str());
again:			if (!CopyFile(itExist->c_str(), itNew->c_str(), bFailIfExists))
				{
					// 返回复制错误信息;
					DWORD dwError = GetLastError();
					if (dwError == ERROR_PATH_NOT_FOUND)
					{
						// 目录不存在,创建;
						underlyingapi::CreateDirectoryEx(itNew->substr(0, itNew->find_last_of(_T('\\'))).c_str());
						goto again;
					}
				}
				else
					nCount++;

				// 复制子带扩展名相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					if (strExist.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
						continue;

					nIndex = itExist->find_last_of(_T('.'));
					if (nIndex != -1)
					{
						//strExist.replace(nIndex,itExt->size(),itExt->c_str());
						//strNew.replace(strNew.find_last_of(_T('.')), itExt->size(), itExt->c_str());
						strExist.replace(nIndex, itExist->length() - nIndex, itExt->c_str());
						strNew.replace(strNew.find_last_of(_T('.')), strNew.length() - strNew.find_last_of(_T('.')), itExt->c_str());
						if (!CopyFile(strExist.c_str(), strNew.c_str(), bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
		}
	}
	else
	{
		for (STR_VEC::iterator itExist = AryOfExistImages.begin(), itNew = AryOfNewImages.begin();
			itExist != AryOfExistImages.end() && itNew != AryOfNewImages.end(); itExist++, itNew++)
		{
			strExist = underlyingapi::lowercase(itExist->c_str());

			if (PathFileExists(strNew.c_str()) && bFailIfExists)
				continue;

			if (!underlyingapi::ImgThumbnail(strExist, dwCopyPix, strNew, 100))
			{
				// 返回复制错误信息;
			}
			else
				nCount++;

			// 复制子带扩展名相片;
			for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
			{
				if (strExist.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
					continue;

				nIndex = itExist->find_last_of(_T('.'));
				if (nIndex != -1)
				{
					//strExist.replace(nIndex,itExt->size(),itExt->c_str());
					//strNew.replace(strNew.find_last_of(_T('.')), itExt->size(), itExt->c_str());
					strExist.replace(nIndex, itExist->length() - nIndex, itExt->c_str());
					strNew.replace(strNew.find_last_of(_T('.')), strNew.length() - strNew.find_last_of(_T('.')), itExt->c_str());
					if (!CopyFile(strExist.c_str(), strNew.c_str(), bFailIfExists))
					{
						// 返回复制错误信息;
					}
				}
			}
		}
	}

	return nCount;
}

/************************************************************************/
/*
函数:CopyImg2Specifiedpath_ex
描述:拷贝相片到指定的目录;
参数:
IN:	lpExistpath 相片源目录;
IN:	lpSpecifiedpath	目标路径;
IN:	lpCopyExt	指定要复制的文件的扩展名;
IN:	lpWithExt	指定要复制的其他同名文件的扩展名;
IN:	dwCopyPix	复制时是否要压缩成指定像素;
IN:	bOriginalCopy	复制源相片时,是否原样复制;
IN:	bFailIfExists	目标文件存在是否复制;
返回: 返回成功复制的相片张数;
注意:
*/
/************************************************************************/
INT ImgOfOriginal::CopyImg2Specifiedpath_ex(IN LPCTSTR lpExistpath, IN LPCTSTR lpSpecifiedpath, IN LPCTSTR lpCopyExt, IN LPCTSTR lpWithExt, IN CONST DWORD &dwCopyPix, IN BOOL bOriginalCopy, IN BOOL bFailIfExists)
{
	// 源目录不存在,返回-1;
	if (!PathFileExists(lpExistpath)) return -1;

	// 判断目标目录是否存在,不存在创建;
	if (!PathFileExists(lpSpecifiedpath))
		if (!underlyingapi::CreateDirectoryEx(lpSpecifiedpath))
			return 0;

	// 查找源目录下全部文件;
	STR_VEC vtFiles;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpExistpath, _T("*.*"), &vtFiles);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	GetFilteringImg(vtFiles, lpCopyExt);

	int nCount = 0;
	int nIndex = 0;
	STR_VEC vtWithExt;
	// 解析复制子带扩展名;
	if (lpWithExt)
	{
		// 获取复制扩展名;
		TString str;
		TString strWithExt = underlyingapi::lowercase(lpWithExt);
		if (strWithExt.find(_T("*.*")) == TString::npos)
		{
			strWithExt.append(_T("|"));
			do
			{// 将所有扩展名解析到数组里;
				nIndex = strWithExt.find(_T('|'));
				if (nIndex != TString::npos)
				{
					str = strWithExt.substr(0, nIndex);
					strWithExt = strWithExt.substr(nIndex + 1);
					vtWithExt.push_back(str.substr(1));
				}
			} while (strWithExt.find(_T('|')) != TString::npos);
		}
	}

	TString strtmp;
	if (bOriginalCopy && dwCopyPix != INVALID_COPY_PIX) // 是否原样复制 且压缩;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			strtmp.append(it->substr(it->find(lpExistpath) + _tcslen(lpExistpath) + 1));
			if (PathFileExists(strtmp.c_str()) && bFailIfExists)
				continue;

			if (underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp.c_str(), 100))
			{
				// 返回压缩失败原因;
			}
			else
				nCount++;

			// 复制其他扩展名的相片;
			for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
			{
				TString strWithExt = underlyingapi::lowercase(it->c_str());
				if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
					continue;

				nIndex = it->find_last_of(_T('.'));
				if (nIndex != TString::npos)
				{
					//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
					//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
					strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
					strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
					if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
					{
						// 返回复制错误信息;
					}
				}
			}
		}
	}
	else if (bOriginalCopy && dwCopyPix == INVALID_COPY_PIX)// 原样复制,不压缩;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			strtmp.append(it->substr(it->find(lpExistpath) + _tcslen(lpExistpath) + 1));

			// 按需要创建 or // 避免多次调用创建文件函数,应该在外面一次性创建完,再执行复制操作;
again:			if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
				{
					DWORD dwError = GetLastError();
					if (dwError == ERROR_PATH_NOT_FOUND)
					{
						// 目录不存在,创建;
						underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
						goto again;
					}
				}
				else
					nCount++;

				// 复制其他扩展名的相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					TString strWithExt = underlyingapi::lowercase(it->c_str());
					if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
						continue;

					nIndex = it->find_last_of(_T('.'));
					if (nIndex != TString::npos)
					{
						//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
						//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
						strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
						strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
						if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
		}
	}
	else if (!bOriginalCopy && dwCopyPix != INVALID_COPY_PIX)	// 压缩,不原样复制,所有源相片放在目标根目录;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp.append(it->substr(nIndex + 1));
				if (PathFileExists(strtmp.c_str()) && bFailIfExists)
					continue;

				if (!underlyingapi::ImgThumbnail(it->c_str(), dwCopyPix, strtmp.c_str(), 100))
				{
					// 返回压缩失败原因;
				}
				else
					nCount++;

				// 复制其他扩展名的相片;
				for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
				{
					TString strWithExt = underlyingapi::lowercase(it->c_str());
					if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
						continue;

					nIndex = it->find_last_of(_T('.'));
					if (nIndex != TString::npos)
					{
						//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
						//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
						strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
						strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
						if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
						{
							// 返回复制错误信息;
						}
					}
				}
			}
		}
	}
	else	// 不压缩,不原样;
	{
		for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
		{
			strtmp = lpSpecifiedpath;
			if (strtmp[_tcslen(lpSpecifiedpath) - 1] != _T('\\'))
				strtmp.append(_T("\\"));

			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos)
			{
				strtmp.append(it->substr(nIndex + 1));
				// 按需要创建 or // 避免多次调用创建文件函数,应该在外面一次性创建完,再执行复制操作;
again1:				if (!CopyFile(it->c_str(), strtmp.c_str(), bFailIfExists))
					{
						DWORD dwError = GetLastError();
						if (dwError == ERROR_PATH_NOT_FOUND)
						{
							// 目录不存在,创建;
							underlyingapi::CreateDirectoryEx(strtmp.substr(0, strtmp.find_last_of(_T('\\'))).c_str());
							goto again1;
						}
					}
					else
						nCount++;

					// 复制其他扩展名的相片;
					for (STR_VEC::iterator itExt = vtWithExt.begin(); itExt != vtWithExt.end(); itExt++)
					{
						TString strWithExt = underlyingapi::lowercase(it->c_str());
						if (strWithExt.find(itExt->c_str()) != TString::npos)	// 不复制本扩展名;
							continue;

						nIndex = it->find_last_of(_T('.'));
						if (nIndex != TString::npos)
						{
							//strWithExt.replace(nIndex,itExt->size(),itExt->c_str());
							//strtmp.replace(strtmp.find_last_of(_T('.')), itExt->size(), itExt->c_str());
							strWithExt.replace(nIndex, it->length() - nIndex, itExt->c_str());
							strtmp.replace(strtmp.find_last_of(_T('.')), strtmp.length() - strtmp.find_last_of(_T('.')), itExt->c_str());
							if (!CopyFile(strWithExt.c_str(), strtmp.c_str(), bFailIfExists))
							{
								// 返回复制错误信息;
							}
						}
					}
			}
		}
	}

	return nCount;
}

#if 0
BOOL ImgOfOriginal::GetLocalSharedirectory(IN CONST INT &nImgType, OUT LPTSTR lpResultSharedirectory, IN CONST INT &nBufSize)
{
	// 获取本地计算机名;
	DWORD dwBufLen = MAX_COMPUTERNAME_LENGTH + 1;
	TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1] = { 0 };
	if (!GetComputerName(szComputerName, &dwBufLen))
	{
		DWORD dwError = GetLastError();
		// 返回错误代码;
		return FALSE;
	}

	switch (nImgType)
	{
	case OImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s\\"), szComputerName, OImgpath);
		break;
	case EImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s\\"), szComputerName, EImgpath);
		break;
	case FImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s\\"), szComputerName, FImgpath);
		break;
	case DImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s\\"), szComputerName, DImgpath);
		break;
		// 以下为备份共享目录;
	case OBImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s"), szComputerName, OBImgpath);
		break;
	case EBImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s"), szComputerName, EBImgpath);
		break;
	case FBImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s"), szComputerName, FBImgpath);
		break;
	case DBImgtype:
		_stprintf_s(lpResultSharedirectory, nBufSize, _T("\\\\%s\\%s"), szComputerName, DBImgpath);
		break;
	default:
		break;
	}

	return TRUE;
}
#endif

BOOL ImgOfOriginal::GetLocalEnableShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, OUT LPTSTR lpEnableShareDirectory, IN CONST INT &nBufSize)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	double dTotalNum = 0.0;
	double dFreeNum = 0.0;
	BOOL bGetEnable = FALSE;
	BYTE byCurPriority = 0;

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (pImgsi->byImgType == nImgType && _tcscmp(pImgsi->szBranchId, lpBranchId) == 0)
		{
			if ( bGetEnable )
			{
				if ( byCurPriority > pImgsi->byPriority )
					continue;
			}

#if 0	// 以下代码有错,不需要判断是否本店;
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)	// 本机域名;
				_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			else	// 分店存储的规则是在本店共享目录下创建域名文件夹;
				_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
#else
			// 若分店相片也单独一个目录存储,不需要判断是否为本店;
			_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
#endif

			if (!underlyingapi::GetDiskSpaceInfo(pImgsi->szShareDirectory, dTotalNum, dFreeNum))
			{//获取硬盘容量失败,可能路径无效或硬盘损坏;
				continue;
			}

			// 如果目录存在,且安全容量值满足要求,直接返回;
			if (PathFileExists(lpEnableShareDirectory))
			{
				if (dFreeNum > pImgsi->byMinCapacity)
				{
					bGetEnable = TRUE;
					break;
				}
			}

			// 剩余容量大于更盘容量;
			if (dFreeNum > pImgsi->byMaxCapacity)
			{
				// 直至最大优先级被找到;
				if (byCurPriority < pImgsi->byPriority)
				{
					byCurPriority = pImgsi->byPriority;
					bGetEnable = TRUE;
				}
			}
		}
	}

	return bGetEnable;
}

BOOL ImgOfOriginal::GetEnableShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, OUT LPTSTR lpEnableShareDirectory, IN CONST INT &nBufSize)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	double dTotalNum = 0.0;
	double dFreeNum = 0.0;
	BOOL bGetEnable = FALSE;
	BYTE byCurPriority = 0;

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (pImgsi->byImgType == nImgType && _tcscmp(pImgsi->szBranchId, lpBranchId) == 0)
		{
			if ( bGetEnable )
			{
				if ( byCurPriority > pImgsi->byPriority )
					continue;
			}

#if 0	// 以下代码有错,不需要判断是否本店;
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)	// 本机域名;
				_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			else	// 分店存储的规则是在本店共享目录下创建域名文件夹;
				_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
#else
			// 若分店相片也单独一个目录存储,不需要判断是否为本店;
			_stprintf_s(lpEnableShareDirectory, nBufSize, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
#endif

			if (!underlyingapi::GetDiskSpaceInfo(pImgsi->szShareDirectory, dTotalNum, dFreeNum))
			{//获取硬盘容量失败,可能路径无效或硬盘损坏;
				continue;
			}

			// 如果目录存在,且安全容量值满足要求,直接返回;
			if (PathFileExists(lpEnableShareDirectory))
			{
				if (dFreeNum > pImgsi->byMinCapacity)
				{
					bGetEnable = TRUE;
					break;
				}
			}

			// 剩余容量大于更盘容量;
			if (dFreeNum > pImgsi->byMaxCapacity)
			{
				// 直至最大优先级被找到;
				if (byCurPriority < pImgsi->byPriority)
				{
					byCurPriority = pImgsi->byPriority;
					bGetEnable = TRUE;
				}
			}
		}
	}

	return bGetEnable;
}

//////////////////////////////////////////////////////////////////////////
BOOL ImgOfOriginal::LoadSpecifiedpathImages(IN LPCTSTR lpSepcifiedpath, IN LPCTSTR lpLoadExt, OUT CStringArray &AryOfSpecifiedpathImages)
{
	if (!lpSepcifiedpath || !PathFileExists(lpSepcifiedpath))
		return FALSE;

	if (!filehelpImpl::iscorrectext(lpLoadExt)) return FALSE;

	// 查找源目录下全部文件;
	STR_VEC vtFiles;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpSepcifiedpath, _T("*.*"), &vtFiles);

	// 过滤不符合扩展名的图像,注意该函数的使用方向;
	GetFilteringImg(vtFiles, lpLoadExt);

	for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
	{
		AryOfSpecifiedpathImages.Add(it->c_str());
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSpecifiedpathImages(IN LPCTSTR lpSepcifiedpath, IN LPCTSTR lpLoadExt, OUT STR_VEC &AryOfSpecifiedpathImages)
{
	if (!lpSepcifiedpath || !PathFileExists(lpSepcifiedpath))
		return FALSE;

	// 查找源目录下全部文件;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpSepcifiedpath, _T("*.*"), &AryOfSpecifiedpathImages);

	// 过滤不符合扩展名的图像,注意该函数的使用方向;
	GetFilteringImg(AryOfSpecifiedpathImages, lpLoadExt);

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesFromSpecifiedpath(IN LPCTSTR lpSepcifiedpath, IN LPCTSTR lpLoadExt, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, OUT CStringArray &AryOfSelectedImagepaths)
{
	// 判断目录有效性;
	if (!lpSepcifiedpath || !underlyingapi::IsValidpath(lpSepcifiedpath) || !PathFileExists(lpSepcifiedpath)) return FALSE;

	// 查找源目录下全部文件;
	STR_VEC vtFiles;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpSepcifiedpath, _T("*.*"), &vtFiles);

	// 过滤不符合扩展名的图像,注意该函数的使用方向;
	GetFilteringImg(vtFiles, lpLoadExt);

	// 再度过滤未存在的相片;
	TCHAR path_buffer[_MAX_PATH] = { 0 };
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFname[_MAX_FNAME] = { 0 };
	TCHAR szExt[_MAX_EXT] = { 0 };

	CString strImgpath;
	for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
	{
		_tsplitpath_s(it->c_str(), szDrive, szDir, szFname, szExt);
		for (int i = 0; i < AryOfSelectedIamges.GetSize(); i++)
		{
			if (AryOfSelectedIamges.ElementAt(i).CompareNoCase(szFname) == 0)
			{
				strImgpath = it->c_str();
				AryOfSelectedImagepaths.Add(strImgpath);
				//AryOfSelectedIamges.RemoveAt(i);// 会删除不同扩展名的文件,如 (扩展名:*.jpg|*.jpeg) 001.jpg 和 001.jpeg 有一个会没有记录到;
				break;
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesFromSpecifiedpath(IN LPCTSTR lpSepcifiedpath, IN LPCTSTR lpLoadExt, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, OUT STR_VEC &AryOfSelectedImagepaths)
{
	// 判断目录有效性;
	if (!lpSepcifiedpath || !underlyingapi::IsValidpath(lpSepcifiedpath) || !PathFileExists(lpSepcifiedpath)) return FALSE;

	// 查找源目录下全部文件;
	STR_VEC vtFiles;
	filehelpImpl lf;
	lf.getfiles_findin_subfolder(lpSepcifiedpath, _T("*.*"), &vtFiles);

	// 过滤不符合扩展名的图像,注意该函数的使用方向;
	GetFilteringImg(vtFiles, lpLoadExt);

	// 再度过滤未存在的相片;
	TCHAR path_buffer[_MAX_PATH] = { 0 };
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFname[_MAX_FNAME] = { 0 };
	TCHAR szExt[_MAX_EXT] = { 0 };

	for (STR_VEC::iterator it = vtFiles.begin(); it != vtFiles.end(); it++)
	{
		_tsplitpath_s(it->c_str(), szDrive, szDir, szFname, szExt);
		for (STR_VEC::iterator itImg = AryOfSelectedIamges.begin(); itImg != AryOfSelectedIamges.end(); itImg++)
		{
			TString strImgpath = szFname;
			filehelpImpl::uppercase(strImgpath);
			filehelpImpl::uppercase(*itImg);

			if (itImg->compare(strImgpath) == 0)
			{
				strImgpath = it->c_str();
				AryOfSelectedImagepaths.push_back(strImgpath);
				//AryOfSelectedIamges.erase(itImg);	// 会删除不同扩展名的文件,如 (扩展名:*.jpg|*.jpeg) 001.jpg 和 001.jpeg 有一个会没有记录到;
				break;
			}
		}
	}
	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamges(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, OUT CStringArray &AryOfSelectedImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };
	TCHAR szShareDirectory[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				LoadSelectedIamgesFromSpecifiedpath(szOrderpath, lpLoadExt, AryOfSelectedIamges, AryOfNoExistIamges, AryOfSelectedImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamges(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, OUT STR_VEC &AryOfSelectedImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				LoadSelectedIamgesFromSpecifiedpath(szOrderpath, lpLoadExt, AryOfSelectedIamges, AryOfNoExistIamges, AryOfSelectedImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamges2(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, OUT CStringArray &AryOfSelectedImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };
	TCHAR szShareDirectory[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				for (int i = 0; i < AryOfSelectedIamges.GetSize(); i++)
				{
					strImage.Format(_T("%s\\%s.jpg"), szOrderpath, AryOfSelectedIamges.ElementAt(i));
					if (PathFileExists(strImage))
					{
						AryOfSelectedImagepaths.Add(strImage);
					}
				}
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamges2(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, OUT STR_VEC &AryOfSelectedImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	TString strImage;
	TCHAR szOrderpath[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				for (STR_VEC::iterator itImg = AryOfSelectedIamges.begin(); itImg != AryOfSelectedIamges.end(); itImg++)
				{
					strImage = szOrderpath;
					strImage.append(_T("\\"));
					strImage.append(itImg->c_str());
					strImage.append(_T(".jpg"));
					if (PathFileExists(strImage.c_str()))
					{
						AryOfSelectedImagepaths.push_back(strImage);
					}
				}
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesInOrder(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, OUT CStringArray &AryOfSelectedImagepaths)
{
	CStringArray tmpselectedImg;
	CStringArray tmpselectedImgpaths;
	if (!LoadSelectedIamges(nImgType, lpBranchId, lpOrderNum, lpLoadExt, tmpselectedImg, AryOfNoExistIamges, tmpselectedImgpaths)) return FALSE;

	tmpselectedImg.Copy(AryOfSelectedIamges);
	tmpselectedImgpaths.Copy(AryOfSelectedImagepaths);

	CString strImage = _T("");
	// 再按顺序加入AryOfSelectedImagePaths;
	for (int i = 0; i < AryOfSelectedIamges.GetSize(); i++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (int n = 0; n < tmpselectedImgpaths.GetSize(); n++)
		{
			strImage = tmpselectedImgpaths.ElementAt(n).Mid(tmpselectedImgpaths.ElementAt(n).ReverseFind('\\') + 1);
			strImage = strImage.Left(strImage.Find('.'));
			if (AryOfSelectedIamges.ElementAt(i).CompareNoCase(strImage) == 0)
			{
				bGetImage = TRUE;
				AryOfSelectedImagepaths.Add(tmpselectedImgpaths.ElementAt(n));
				break;
			}
		}

		if (!bGetImage)
		{
			AryOfSelectedImagepaths.Add(_T(""));
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesInOrder(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, OUT STR_VEC &AryOfSelectedImagepaths)
{
	STR_VEC tmpselectedImg;
	STR_VEC tmpselectedImgpaths;

	if (!LoadSelectedIamges(nImgType, lpBranchId, lpOrderNum, lpLoadExt, tmpselectedImg, AryOfNoExistIamges, tmpselectedImgpaths)) return FALSE;

	for (STR_VEC::iterator it = AryOfSelectedIamges.begin(); it != AryOfSelectedIamges.end(); it++)
	{
		tmpselectedImg.push_back(it->c_str());
	}

	for (STR_VEC::iterator it = AryOfSelectedImagepaths.begin(); it != AryOfSelectedImagepaths.end(); it++)
	{
		tmpselectedImgpaths.push_back(it->c_str());
	}

	int nIndex = 0;
	TString strImage = _T("");
	// 再按顺序加入AryOfSelectedImagePaths;
	for (STR_VEC::iterator itName = AryOfSelectedIamges.begin(); itName != AryOfSelectedIamges.end(); itName++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (STR_VEC::iterator itpath = tmpselectedImgpaths.begin(); itpath != tmpselectedImgpaths.end(); itpath++)
		{
			if ((nIndex = itpath->find_last_of(_T('\\'))) != TString::npos)
			{
				strImage = itpath->substr(nIndex + 1);
				if ((nIndex = strImage.find_last_of(_T('.'))) != TString::npos)
				{
					strImage = strImage.substr(nIndex);
					filehelpImpl::uppercase(strImage);
					filehelpImpl::uppercase(*itName);
					if (itName->compare(strImage) == 0)
					{
						bGetImage = TRUE;
						AryOfSelectedImagepaths.push_back(itpath->c_str());
						break;
					}
				}
			}
		}

		if (!bGetImage)
		{
			AryOfSelectedImagepaths.push_back(_T(""));
		}
	}

	// 重新排序;

	return TRUE;
}

BOOL ImgOfOriginal::LoadSceneryImages(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, IN LPCTSTR lpLoadExt, OUT CStringArray& AryOfSceneryImagepaths, OUT CStringArray* pAryOfSceneryDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };

	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfSceneryDirectory)
					pAryOfSceneryDirectory->Add(szOrderpath);
				LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfSceneryImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSceneryImages(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, IN LPCTSTR lpLoadExt, OUT STR_VEC& AryOfSceneryImagepaths, OUT STR_VEC* pAryOfSceneryDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfSceneryDirectory)
					pAryOfSceneryDirectory->push_back(szOrderpath);
				LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfSceneryImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadOrderImages(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, OUT CStringArray& AryOfOrderImagePaths, OUT CStringArray* pAryOfOrderDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfOrderDirectory)
					pAryOfOrderDirectory->Add(szOrderpath);
				LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfOrderImagePaths);
			}
		}
	}
	return TRUE;
}

BOOL ImgOfOriginal::LoadOrderImages(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpLoadExt, OUT STR_VEC& AryOfOrderImagePaths, OUT STR_VEC* pAryOfOrderDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfOrderDirectory)
					pAryOfOrderDirectory->push_back(szOrderpath);
				LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfOrderImagePaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::GetOrderAllShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, OUT CStringArray& AryOfOrderAllShareDirectory)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	TCHAR szOrderpath[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				AryOfOrderAllShareDirectory.Add(szOrderpath);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::GetOrderAllShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, OUT STR_VEC& AryOfOrderAllShareDirectory)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	TCHAR szOrderpath[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				AryOfOrderAllShareDirectory.push_back(szOrderpath);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::GetSceneryAllShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, OUT CStringArray &AryOfSceneryAllShareDirectory)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	TCHAR szOrderpath[MAX_PATH] = { 0 };
	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				AryOfSceneryAllShareDirectory.Add(szOrderpath);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::GetSceneryAllShareDirectory(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, OUT STR_VEC &AryOfSceneryAllShareDirectory)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	TCHAR szOrderpath[MAX_PATH] = { 0 };
	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				AryOfSceneryAllShareDirectory.push_back(szOrderpath);
			}
		}
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
BOOL ImgOfOriginal::LoadSpecifiedpathImagesEx(IN LPCTSTR lpSepcifiedpath, IN BOOL bLoadInSubfolder, IN LPCTSTR lpLoadExt, OUT CStringArray &AryOfLoadImgs, IN LPCTSTR lpWithExt, OUT CStringArray &AryOfWithImgs)
{
	// 指定目录是否存在;
	if (!PathFileExists(lpSepcifiedpath)) return FALSE;

	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpLoadExt)) return FALSE;

#if 0
	// 合并扩展名;
	TString findext = lpLoadExt;
	if (findext[findext.length() - 1] != _T('|'))
	{
		findext.append(_T("|"));
	}

	findext.append(lpWithExt);
	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpWithExt)) return FALSE;
#else
	TString findext;
	if (!underlyingapi::extmerge(lpLoadExt, lpWithExt,findext))
		return FALSE;
#endif

	STR_VEC vtFiles;
	filehelpImpl lf;

	if (bLoadInSubfolder)
	{
		lf.getfiles_findin_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}
	else
	{
		lf.getfiles_findout_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}

	// 分组扩展名;
	SubgroupExt(vtFiles, lpLoadExt, AryOfLoadImgs);
	SubgroupExt(vtFiles, lpWithExt, AryOfWithImgs);

	return TRUE;
}

BOOL ImgOfOriginal::LoadSpecifiedpathImagesEx(IN LPCTSTR lpSepcifiedpath, IN BOOL bLoadInSubfolder, IN LPCTSTR lpLoadExt, OUT STR_VEC &AryOfLoadImgs, IN LPCTSTR lpWithExt, OUT STR_VEC &AryOfWithImgs)
{
	// 指定目录是否存在;
	if (!PathFileExists(lpSepcifiedpath)) return FALSE;

	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpLoadExt)) return FALSE;

#if 0
	// 合并扩展名;
	TString findext = lpLoadExt;
	if (findext[findext.length() - 1] != _T('|'))
	{
		findext.append(_T("|"));
	}

	findext.append(lpWithExt);
	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpWithExt)) return FALSE;
#else
	TString findext;
	if (!underlyingapi::extmerge(lpLoadExt, lpWithExt, findext))
		return FALSE;
#endif

	STR_VEC vtFiles;
	filehelpImpl lf;

	if (bLoadInSubfolder)
	{
		lf.getfiles_findin_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}
	else
	{
		lf.getfiles_findout_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}

	// 分组扩展名;
	SubgroupExt(vtFiles, lpLoadExt, AryOfLoadImgs);
	SubgroupExt(vtFiles, lpWithExt, AryOfWithImgs);

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesFromSpecifiedpathEx(IN LPCTSTR lpSepcifiedpath, IN BOOL bLoadInSubfolder, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT CStringArray &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT CStringArray &AryOfWithImagepaths)
{
	// 指定目录是否存在;
	if (!PathFileExists(lpSepcifiedpath)) return FALSE;

	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpLoadExt)) return FALSE;

#if 0
	// 合并扩展名;
	TString findext = lpLoadExt;
	if (findext[findext.length() - 1] != _T('|'))
	{
		findext.append(_T("|"));
	}

	findext.append(lpWithExt);
	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpWithExt)) return FALSE;
#else
	TString findext;
	if (!underlyingapi::extmerge(lpLoadExt, lpWithExt, findext))
		return FALSE;
#endif

	STR_VEC vtFiles;
	filehelpImpl lf;

	if (bLoadInSubfolder)
	{
		lf.getfiles_findin_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}
	else
	{
		lf.getfiles_findout_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}

#if 0
	// 分组扩展名;
	CStringArray AryLoad;
	CStringArray AryWith;
	SubgroupExt(vtFiles, lpLoadExt, AryLoad);
	SubgroupExt(vtFiles, lpWithExt, AryWith);

	// 过滤不存在的文件名;
	BOOL bExist;
	CString strname;
	int nSize = AryOfSelectedIamges.GetSize();

	for (int i = 0; i < nSize; i++)
	{
		bExist = FALSE;
		for (int n = 0; n < AryLoad.GetSize(); n++)
		{
			strname = GetFileName(AryLoad.ElementAt(n));
			if (strname.CompareNoCase(AryOfSelectedIamges.ElementAt(i)) == 0)
			{
				bExist = TRUE;
				AryOfLoadImagepaths.Add(AryLoad.ElementAt(n));
				//break; //不能break,否则其他扩展名会加载不了;
			}
		}

		for (int j = 0; j < AryWith.GetSize(); j++)
		{
			strname = GetFileName(AryWith.ElementAt(j));
			if (strname.CompareNoCase(AryOfSelectedIamges.ElementAt(i)) == 0)
			{
				AryOfWithImagepaths.Add(AryWith.ElementAt(j));
				//break; 同理;
			}
		}

		if (!bExist)
		{
			AryOfNoExistIamges.Add(AryOfSelectedIamges.ElementAt(i));
		}
	}
#else // 以下做法,无法获取不存在文件的相片名; 但是使用另一变量来保存存在的相片名,再与原相片名相减;
	SubgroupExt(vtFiles, lpLoadExt, AryOfLoadImagepaths);
	SubgroupExt(vtFiles, lpWithExt, AryOfWithImagepaths);

	// 过滤不存在的文件名;
	BOOL bExist;
	CString strname;
	int nSize = AryOfSelectedIamges.GetSize();

	CStringArray AryExistImg;	// 存在文件的相片名;
	for (int i = AryOfLoadImagepaths.GetSize() - 1; i > 0; i--)
	{
		bExist = FALSE;
		strname = GetFileName(AryOfLoadImagepaths.ElementAt(i));
		for (int n = 0; n < nSize; n++)
		{
			if (strname.CompareNoCase(AryOfSelectedIamges.ElementAt(n)) == 0)
			{
				bExist = TRUE;
				if (!underlyingapi::IsStringExistNoCase(strname, AryExistImg))
					AryExistImg.Add(strname);
				// 不能break;因为如果加载多个扩展名的话,会加载后面的失败;
			}
		}

		if (!bExist)
		{
			AryOfLoadImagepaths.RemoveAt(i);
		}
	}

	for (int i = AryOfWithImagepaths.GetSize() - 1; i > 0; i--)
	{
		bExist = FALSE;
		strname = GetFileName(AryOfWithImagepaths.ElementAt(i));
		for (int n = 0; n < nSize; n++)
		{
			if (strname.CompareNoCase(AryOfSelectedIamges.ElementAt(n)) == 0)
			{
				bExist = TRUE;
			}
		}

		if (!bExist)
		{
			AryOfWithImagepaths.RemoveAt(i);
		}
	}

	// 减去存在的相片名;
#if 0
	for (int i = AryOfSelectedIamges.GetSize() - 1; i > 0; i--)
	{
		for (int n = AryExistImg.GetSize() - 1; n > 0; n-- )
		{
			if (AryExistImg.ElementAt(n).CompareNoCase(AryOfSelectedIamges.ElementAt(i)) == 0)
			{
				AryOfSelectedIamges.RemoveAt(i);
				break;
			}
		}
	}
#else
	for (int i = AryOfSelectedIamges.GetSize() - 1; i > 0; i--)
	{
		bExist = FALSE;
		for (int n = AryExistImg.GetSize() - 1; n > 0; n-- )
		{
			if (AryExistImg.ElementAt(n).CompareNoCase(AryOfSelectedIamges.ElementAt(i)) == 0)
			{
				bExist = TRUE;
				break;
			}
		}

		if ( !bExist )
		{
			AryOfNoExistIamges.Add(AryOfSelectedIamges.ElementAt(i));
		}
	}
#endif
#endif

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesFromSpecifiedpathEx(IN LPCTSTR lpSepcifiedpath, IN BOOL bLoadInSubfolder, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT STR_VEC &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT STR_VEC &AryOfWithImagepaths)
{
	// 指定目录是否存在;
	if (!PathFileExists(lpSepcifiedpath)) return FALSE;

	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpLoadExt)) return FALSE;

#if 0
	// 合并扩展名;
	TString findext = lpLoadExt;
	if (findext[findext.length() - 1] != _T('|'))
	{
		findext.append(_T("|"));
	}

	findext.append(lpWithExt);
	// 扩展名是否有效;
	if (!filehelpImpl::iscorrectext(lpWithExt)) return FALSE;
#else
	TString findext;
	if (!underlyingapi::extmerge(lpLoadExt, lpWithExt, findext))
		return FALSE;
#endif

	STR_VEC vtFiles;
	filehelpImpl lf;

	if (bLoadInSubfolder)
	{
		lf.getfiles_findin_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}
	else
	{
		lf.getfiles_findout_subfolder(lpSepcifiedpath, findext.c_str(), &vtFiles);
	}

	// 分组扩展名;
	SubgroupExt(vtFiles, lpLoadExt, AryOfLoadImagepaths);
	SubgroupExt(vtFiles, lpWithExt, AryOfWithImagepaths);

	TString name;
	TString name1;
	BOOL bExist = FALSE;
	STR_VEC vtExistImg;
	// 过滤无用文件名;
	for (STR_VEC::iterator it = AryOfLoadImagepaths.begin(); it != AryOfLoadImagepaths.end(); )
	{
		bExist = FALSE;
		name = filehelpImpl::getfilename(*it);
		filehelpImpl::uppercase(name);
		for (STR_VEC::iterator itn = AryOfSelectedIamges.begin(); itn != AryOfSelectedIamges.end(); itn++)
		{
			filehelpImpl::uppercase(*itn);
			if ( name.compare(*itn) == 0 )
			{
				bExist = TRUE;
				it++;
				vtExistImg.push_back(name);
				break;
			}
		}

		if ( !bExist )
		{
			it = AryOfLoadImagepaths.erase(it);
		}
	}

	// 过滤无用文件名;
	for (STR_VEC::iterator it = AryOfWithImagepaths.begin(); it != AryOfWithImagepaths.end(); )
	{
		bExist = FALSE;
		name = filehelpImpl::getfilename(*it);
		filehelpImpl::uppercase(name);
		for (STR_VEC::iterator itn = AryOfSelectedIamges.begin(); itn != AryOfSelectedIamges.end(); itn++)
		{
			filehelpImpl::uppercase(*itn);
			if ( name.compare(*itn) == 0 )
			{
				bExist = TRUE;
				it++;
				vtExistImg.push_back(name);
				break;
			}
		}

		if ( !bExist )
		{
			it = AryOfWithImagepaths.erase(it);
		}
	}

	// 减去存在的相片名;
	for ( STR_VEC::iterator it = AryOfSelectedIamges.begin(); it != AryOfSelectedIamges.end(); )
	{
		bExist = FALSE;
		for ( STR_VEC::iterator ite = vtExistImg.begin(); ite != vtExistImg.end(); ite++ )
		{
			if ( ite->compare(*it) == 0 )
			{
				bExist = TRUE;
				break;
			}
		}

		if ( !bExist )
		{
			AryOfNoExistIamges.push_back(*it);
		}
		it++;
	}
	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT CStringArray &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT CStringArray &AryOfWithImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };
	TCHAR szShareDirectory[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				LoadSelectedIamgesFromSpecifiedpathEx(szOrderpath, bLoadInSubfolder, AryOfSelectedIamges, AryOfNoExistIamges, lpLoadExt, AryOfLoadImagepaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT STR_VEC &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT STR_VEC &AryOfWithImagepaths)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				LoadSelectedIamgesFromSpecifiedpathEx(szOrderpath, bLoadInSubfolder, AryOfSelectedIamges, AryOfNoExistIamges, lpLoadExt, AryOfLoadImagepaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesInOrderEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN CStringArray &AryOfSelectedIamges, OUT CStringArray &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT CStringArray &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT CStringArray &AryOfWithImagepaths)
{
	CStringArray tmpLoadImgpaths;
	CStringArray tmpWithImgpaths;
	if ( !LoadSelectedIamgesEx(nImgType, lpBranchId, lpOrderNum, bLoadInSubfolder, AryOfSelectedIamges, AryOfNoExistIamges, lpLoadExt, tmpLoadImgpaths, lpWithExt, tmpWithImgpaths)) 
		return FALSE;

	CString strImage = _T("");
	// 再按顺序加入AryOfSelectedImagePaths;
	for (int i = 0; i < AryOfSelectedIamges.GetSize(); i++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (int n = 0; n < tmpLoadImgpaths.GetSize(); n++)
		{
			strImage = tmpLoadImgpaths.ElementAt(n).Mid(tmpLoadImgpaths.ElementAt(n).ReverseFind('\\') + 1);
			strImage = strImage.Left(strImage.Find('.'));
			if (AryOfSelectedIamges.ElementAt(i).CompareNoCase(strImage) == 0)
			{
				bGetImage = TRUE;
				AryOfLoadImagepaths.Add(tmpLoadImgpaths.ElementAt(n));
				break;
			}
		}

		if (!bGetImage)
		{
			AryOfLoadImagepaths.Add(_T(""));
		}
	}

	for (int i = 0; i < AryOfSelectedIamges.GetSize(); i++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (int n = 0; n < tmpWithImgpaths.GetSize(); n++)
		{
			strImage = tmpWithImgpaths.ElementAt(n).Mid(tmpWithImgpaths.ElementAt(n).ReverseFind('\\') + 1);
			strImage = strImage.Left(strImage.Find('.'));
			if (AryOfWithImagepaths.ElementAt(i).CompareNoCase(strImage) == 0)
			{
				bGetImage = TRUE;
				AryOfWithImagepaths.Add(tmpWithImgpaths.ElementAt(n));
				break;
			}
		}

		if (!bGetImage)
		{
			AryOfWithImagepaths.Add(_T(""));
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSelectedIamgesInOrderEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN STR_VEC &AryOfSelectedIamges, OUT STR_VEC &AryOfNoExistIamges, IN LPCTSTR lpLoadExt, OUT STR_VEC &AryOfLoadImagepaths, IN LPCTSTR lpWithExt, OUT STR_VEC &AryOfWithImagepaths)
{
	STR_VEC tmpLoadImg;
	STR_VEC tmpWithImg;

	if (!LoadSelectedIamgesEx(nImgType, lpBranchId, lpOrderNum, bLoadInSubfolder, AryOfSelectedIamges, AryOfNoExistIamges, lpLoadExt, tmpLoadImg, lpWithExt, tmpWithImg))
		return FALSE;

	int nIndex = 0;
	TString strImage = _T("");
	// 再按顺序加入AryOfSelectedImagePaths;
	for (STR_VEC::iterator itName = AryOfSelectedIamges.begin(); itName != AryOfSelectedIamges.end(); itName++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (STR_VEC::iterator itpath = tmpLoadImg.begin(); itpath != tmpLoadImg.end(); itpath++)
		{
			if ((nIndex = itpath->find_last_of(_T('\\'))) != TString::npos)
			{
				strImage = itpath->substr(nIndex + 1);
				if ((nIndex = strImage.find_last_of(_T('.'))) != TString::npos)
				{
					strImage = strImage.substr(nIndex);
					filehelpImpl::uppercase(strImage);
					filehelpImpl::uppercase(*itName);
					if (itName->compare(strImage) == 0)
					{
						bGetImage = TRUE;
						AryOfLoadImagepaths.push_back(itpath->c_str());
						break;
					}
				}
			}
		}

		if (!bGetImage)
		{
			AryOfLoadImagepaths.push_back(_T(""));
		}
	}

	for (STR_VEC::iterator itName = AryOfSelectedIamges.begin(); itName != AryOfSelectedIamges.end(); itName++)
	{
		// 如果某张相片没有找到对应的文件,赋空;
		BOOL bGetImage = FALSE;
		for (STR_VEC::iterator itpath = tmpLoadImg.begin(); itpath != tmpLoadImg.end(); itpath++)
		{
			if ((nIndex = itpath->find_last_of(_T('\\'))) != TString::npos)
			{
				strImage = itpath->substr(nIndex + 1);
				if ((nIndex = strImage.find_last_of(_T('.'))) != TString::npos)
				{
					strImage = strImage.substr(nIndex);
					filehelpImpl::uppercase(strImage);
					filehelpImpl::uppercase(*itName);
					if (itName->compare(strImage) == 0)
					{
						bGetImage = TRUE;
						AryOfWithImagepaths.push_back(itpath->c_str());
						break;
					}
				}
			}
		}

		if (!bGetImage)
		{
			AryOfWithImagepaths.push_back(_T(""));
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSceneryImagesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, IN LPCTSTR lpLoadExt, OUT CStringArray& AryOfLoadImagepaths, IN LPCTSTR lpWithExt, IN CStringArray& AryOfWithImagepaths, OUT CStringArray* pAryOfSceneryDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szOrderpath[MAX_PATH] = { 0 };

	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfSceneryDirectory)
					pAryOfSceneryDirectory->Add(szOrderpath);
				//LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfSceneryImagepaths);
				LoadSpecifiedpathImagesEx(szOrderpath, FALSE, lpLoadExt, AryOfLoadImagepaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadSceneryImagesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpScenery, IN LPCTSTR lpLoadExt, OUT STR_VEC& AryOfLoadImagepaths, IN LPCTSTR lpWithExt, IN STR_VEC& AryOfWithImagepaths, OUT STR_VEC* pAryOfSceneryDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");
	TCHAR szScenery[MAX_PATH] = { 0 };
	if (lpScenery == NULL || (_tcscmp(lpScenery, _T("")) == 0 || _tcscmp(lpScenery, _T("全部")) == 0))
		_stprintf_s(szScenery, _T("%s"), _T(""));
	else
		_stprintf_s(szScenery, _T("%s"), lpScenery);

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpOrderNum, szScenery);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum, szScenery);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfSceneryDirectory)
					pAryOfSceneryDirectory->push_back(szOrderpath);
				//LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfSceneryImagepaths);
				LoadSpecifiedpathImagesEx(szOrderpath, FALSE, lpLoadExt, AryOfLoadImagepaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadOrderImagesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN LPCTSTR lpLoadExt, OUT CStringArray& AryOfOrderImagePaths, IN LPCTSTR lpWithExt, IN CStringArray& AryOfWithImagepaths, OUT CStringArray* pAryOfOrderDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfOrderDirectory)
					pAryOfOrderDirectory->Add(szOrderpath);
				//LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfOrderImagePaths);
				LoadSpecifiedpathImagesEx(szOrderpath, FALSE, lpLoadExt, AryOfOrderImagePaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}

BOOL ImgOfOriginal::LoadOrderImagesEx(IN CONST INT &nImgType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN BOOL bLoadInSubfolder, IN LPCTSTR lpLoadExt, OUT STR_VEC& AryOfOrderImagePaths, IN LPCTSTR lpWithExt, IN STR_VEC& AryOfWithImagepaths, OUT STR_VEC* pAryOfOrderDirectory /* = NULL */)
{
	// 判断域名有效性;
	if (lpBranchId == NULL || _tcscmp(lpBranchId, _T("")) == 0) return FALSE;	// 传入的域名空;
	if (_tcsstr(lpBranchId, _T(".ly.com")) == NULL) return FALSE;		// 域名有错;
	if (gp_vtImgShareInfo || gp_vtImgShareInfo->size() == 0) return FALSE;		// 共享路径无;
	if (g_pBranchId == NULL) return FALSE;	// 本机域名出错;

	int nSize = 0;
	CString strImage = _T("");

	for (IMGSHARE_VEC::iterator it = gp_vtImgShareInfo->begin(); it != gp_vtImgShareInfo->end(); it++)
	{
		ImgShareInfo *pImgsi = *it;
		TCHAR szOrderpath[MAX_PATH] = { 0 };
		if (nImgType == pImgsi->byImgType && _tcscmp(lpBranchId, pImgsi->szBranchId) == 0)
		{
			if (_tcscmp(lpBranchId, g_pBranchId) == 0)
			{//本机域名;
				_stprintf_s(szOrderpath, _T("%s\\%s"), pImgsi->szShareDirectory, lpOrderNum);
			}
			else
			{
				_stprintf_s(szOrderpath, _T("%s\\%s\\%s"), pImgsi->szShareDirectory, lpBranchId, lpOrderNum);
			}

			if (PathFileExists(szOrderpath))
			{
				if (pAryOfOrderDirectory)
					pAryOfOrderDirectory->push_back(szOrderpath);
				//LoadSpecifiedpathImages(szOrderpath, lpLoadExt, AryOfOrderImagePaths);
				LoadSpecifiedpathImagesEx(szOrderpath, FALSE, lpLoadExt, AryOfOrderImagePaths, lpWithExt, AryOfWithImagepaths);
			}
		}
	}

	return TRUE;
}