// PhotoDelMgr.cpp : ʵ���ļ�
//

#include "stdafx.h"
#include "DBServer.h"
#include "PhotoDelMgr.h"
#include "Global.h"
#include "BranchInfo.h"
#include "PhotoDelLog.h"
#include "mysqldata.h"
#include "DelPhotoModel\DelFilesFactory.h"
#include "DelPhotoModel\DelFilesInterface.h"

typedef HRESULT (WINAPI *GetClassDelFileObject)(REFCLSID, REFIID, LPVOID*);

CPhotoDelMgr* g_pPhotoDelMgr;


#define MSG_SHOWPROMPTING		WM_USER + 101
// CPhotoDelMgr �Ի���

IMPLEMENT_DYNAMIC(CPhotoDelMgr, CDialog)

CPhotoDelMgr::CPhotoDelMgr(CWnd* pParent /*=NULL*/)
	: CDialog(CPhotoDelMgr::IDD, pParent)
{
	m_pFactory = NULL;
	m_pInterface = NULL;
	m_lpCurrSel = NULL;

	m_pdb = NULL;
	memset(m_szConnect, 0, sizeof(TCHAR)*MAX_PATH);
}

CPhotoDelMgr::~CPhotoDelMgr()
{
	if(m_pInterface)
		m_pInterface->Release();

	if(m_pFactory)
		m_pFactory->Release();

	m_vCurrSelLog.clear();
	CleareLog(m_vPickupLog);
	ClearBakDirInfo();

	if(m_pdb)
		delete m_pdb;
	m_pdb = NULL;
}

void CPhotoDelMgr::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_DelInfo_List, m_DelList);
	DDX_Control(pDX, IDC_DelType_LIST, m_PhotoTypeList);
	DDX_Control(pDX, IDC_Start_Date, m_StartTime);
	DDX_Control(pDX, IDC_End_Date, m_EndTime);
	DDX_Control(pDX, IDC_DELTIPS_RICHEDIT, m_DelTips);
}


BEGIN_MESSAGE_MAP(CPhotoDelMgr, CDialog)
	ON_BN_CLICKED(IDC_StartDel_Btn, &CPhotoDelMgr::OnBnClickedStartdelBtn)
	ON_BN_CLICKED(IDC_SelectAll_Btn, &CPhotoDelMgr::OnBnClickedSelectallBtn)
	ON_BN_CLICKED(IDC_DeleteLog_Btn, &CPhotoDelMgr::OnBnClickedDeletelogBtn)
	ON_BN_CLICKED(IDC_UnAllSel_Btn, &CPhotoDelMgr::OnBnClickedUnallselBtn)
	ON_BN_CLICKED(IDC_SetAutoDel_Btn, &CPhotoDelMgr::OnBnClickedSetAutodelBtn)
	ON_BN_CLICKED(IDC_Refresh_Btn, &CPhotoDelMgr::OnBnClickedRefreshBtn)
	ON_NOTIFY(NM_CLICK, IDC_DelInfo_List, &CPhotoDelMgr::OnNMClickDelinfoList)
	ON_NOTIFY(NM_CLICK, IDC_DelType_LIST, &CPhotoDelMgr::OnNMClickDeltypeList)
	ON_MESSAGE(MSG_SHOWPROMPTING, &CPhotoDelMgr::ShowPrompting)
END_MESSAGE_MAP()

BOOL CPhotoDelMgr::OnInitDialog()
{
	CDialog::OnInitDialog();
	g_pPhotoDelMgr = this;

#ifndef ENTERPRISE_VERSION
	m_DelList.InsertColumn( 0, TEXT("������"), LVCFMT_LEFT, 100 );
#else
	m_DelList.InsertColumn( 0, TEXT("����"), LVCFMT_LEFT, 100 );
#endif
	m_DelList.InsertColumn( 1, TEXT("����"), LVCFMT_LEFT, 200 );
	m_DelList.InsertColumn( 2, TEXT("������"), LVCFMT_LEFT, 70 );
	m_DelList.InsertColumn( 3, TEXT("ȡ��"), LVCFMT_LEFT, 70 );
	m_DelList.InsertColumn( 4, TEXT("ʱ��"), LVCFMT_LEFT, 70 );
	m_DelList.SetExtendedStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);

	m_PhotoTypeList.InsertColumn( 0, TEXT("����"), LVCFMT_LEFT, 100 );
	m_PhotoTypeList.InsertColumn( 1, TEXT("��ɾ��"), LVCFMT_LEFT, 70 );
	m_PhotoTypeList.SetExtendedStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);

	CTime currtime = CTime::GetCurrentTime();
	m_EndTime.SetTime(&currtime);
	CTimeSpan timespan(30,0,0,0);
	CTime endtime = currtime - timespan;
	m_StartTime.SetTime(&endtime);

	
	GetBranchInfo(m_BranchArr);
	OnBnClickedRefreshBtn();
	LoadDelPhotoModule(g_hDllInst);
	GetShareBackupDir();
	return TRUE;
}

// CPhotoDelMgr ��Ϣ��������
//��ʼɾ��
void CPhotoDelMgr::OnBnClickedStartdelBtn()
{
	if(m_pInterface && m_pInterface->IsDeleting())
	{
		MessageBox(_T("���ڴ���ɾ�������У����Ժ�����"));
		return;
	}

	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	if (AfxMessageBox("�Ƿ�ɾ��ѡ�е���ȡ����Ƭ?", MB_YESNO | MB_ICONINFORMATION) != IDYES)
		return;

	int nCount = m_DelList.GetItemCount();
	for(int i = 0; i<nCount; i++)
	{
		if(m_DelList.GetCheck(i) == TRUE)
		{
			CString strDomain = m_DelList.GetItemText(i, 1);
			CString strOrder = m_DelList.GetItemText(i, 2);

			std::vector<LPSPICKUPINFO>::iterator iter = m_vPickupLog.begin();
			for(; iter != m_vPickupLog.end();)
			{
				LPSPICKUPINFO lp = (*iter);
				if(lp != NULL && lp->bTakestatus && lp->strBranchid == strDomain && lp->strOrder == strOrder)
				{
					
					//�ѹ�ѡ�˵���ȡ���������ӵ�ɾ������
					if(lp->bOpNeedDel)
						AddDelData(strDomain, strOrder, 1);
					if(lp->bEpNeedDel)
						AddDelData(strDomain, strOrder, 2);
					if(lp->bFpNeedDel)
						AddDelData(strDomain, strOrder, 3);
					if(lp->bDpNeedDel)
						AddDelData(strDomain, strOrder, 4);
					if(lp->bOpbNeedDel)
						AddDelData(strDomain, strOrder, 5);
					if(lp->bEpbNeedDel)
						AddDelData(strDomain, strOrder, 6);
					if(lp->bFpbNeedDel)
						AddDelData(strDomain, strOrder, 7);
					if(lp->bDpbNeedDel)
						AddDelData(strDomain, strOrder, 8);
				}
				++iter;
			}
		}
	}

	//��ʼɾ����Ƭ
	if(m_pInterface && !m_pInterface->IsDeleting())
		m_pInterface->StartDelFiles(DelFinish);
}

//ȥ��ȫѡ
void CPhotoDelMgr::OnBnClickedUnallselBtn()
{
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	int nNum = m_DelList.GetItemCount();
	for(int i=0; i<nNum; i++)
		m_DelList.SetCheck(i, FALSE);
	m_vCurrSelLog.clear();
}


//ȫѡ
void CPhotoDelMgr::OnBnClickedSelectallBtn()
{
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	int nNum = m_DelList.GetItemCount();
	for(int i=0; i<nNum; i++)
		m_DelList.SetCheck(i, TRUE);

	m_vCurrSelLog.clear();
	std::vector<LPSPICKUPINFO>::iterator it = m_vPickupLog.begin();
	for(;it != m_vPickupLog.end();)
	{
		if((*it) != NULL)
			m_vCurrSelLog.push_back((*it));
		++it;
	}
}

//�鿴ɾ����¼
void CPhotoDelMgr::OnBnClickedDeletelogBtn()
{
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	PhotoDelLog dlg;
	dlg.m_pBranchArr = &m_BranchArr;
	dlg.m_pdb = m_pdb;
	dlg.m_plock = &m_lock;
	dlg.DoModal();
}

void CPhotoDelMgr::OnDestroy()
{
	
}

//���������
void CPhotoDelMgr::LoadListData()
{
	m_lock.lock();
	if(m_pdb == NULL)
	{
		m_lock.unlock();
		return;
	}

	CleareLog(m_vPickupLog);

	CString strTimeFielded = _T("");
	if(!GetTimeField(strTimeFielded))
	{
		m_lock.unlock();
		return;
	}

	//��ȡ����¼
	CString sql = _T("");
	sql = _T("SELECT [branchid],[order],[takestatus],[taketime],\
[opdel],[epdel],[fpdel],[dpdel],\
[opbdel],[epbdel],[fpbdel],[dpbdel],\
[opdeltm],[epdeltm],[fpdeltm],[dpdeltm],\
[opbdeltm],[epbdeltm],[fpbdeltm],[dpbdeltm] FROM [PhotoManager] where [takestatus]='True' and ") + strTimeFielded;

	try
	{
		CRecordset myset;
		myset.m_pDatabase = m_pdb;
		myset.Open(CRecordset::forwardOnly, sql);
		int ii = 0;
		while (!myset.IsEOF())
		{
			LPSPICKUPINFO lp = new SPICKUPINFO;
			CString strValue = _T("");
			myset.GetFieldValue(_T("branchid"), lp->strBranchid);			/* �ֵ�id ����*/
			lp->strName = CPhotoDelMgr::GetBranchNameForDomain(&m_BranchArr, lp->strBranchid);
			myset.GetFieldValue(_T("order"), lp->strOrder);						/* ����������(Ψһ) */
			myset.GetFieldValue(_T("takestatus"), strValue);				/* ȡ��״̬:0δȡ,1��ȡ */
			lp->bTakestatus = _ttoi(strValue);
			myset.GetFieldValue(_T("taketime"), lp->strTaketime);			/* ����������ȡ��ʱ�� */

			myset.GetFieldValue(_T("opdel"), strValue);						/* ԭƬɾ��״̬ */
			lp->bOpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("epdel"), strValue);						/* ����ɾ��״̬ */
			lp->bEpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("fpdel"), strValue);						/* ����ɾ��״̬ */
			lp->bFpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("dpdel"), strValue);						/* ���ɾ��״̬ */
			lp->bDpdel = _ttoi(strValue);

			myset.GetFieldValue(_T("opbdel"), strValue);					/* ԭƬ����ɾ��״̬ */
			lp->bOpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("epbdel"), strValue);					/* ���ޱ���ɾ��״̬ */
			lp->bEpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("fpbdel"), strValue);					/* ���ޱ���ɾ��״̬ */
			lp->bFpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("dpbdel"), strValue);					/* ��Ʊ���ɾ��״̬ */
			lp->bDpbdel = _ttoi(strValue);

			myset.GetFieldValue(_T("opdeltm"), lp->strOpdeltm);					/* ԭƬɾ��ʱ�� */
			myset.GetFieldValue(_T("epdeltm"), lp->strEpdeltm);					/* ����ɾ��ʱ�� */
			myset.GetFieldValue(_T("fpdeltm"), lp->strFpdeltm);					/* ����ɾ��ʱ�� */
			myset.GetFieldValue(_T("dpdeltm"), lp->strDpdeltm);					/* ���ɾ��ʱ�� */

			myset.GetFieldValue(_T("opbdeltm"), lp->strOpbdeltm);					/* ԭƬ����ɾ��ʱ�� */
			myset.GetFieldValue(_T("epbdeltm"), lp->strEpbdeltm);					/* ���ޱ���ɾ��ʱ�� */
			myset.GetFieldValue(_T("fpbdeltm"), lp->strFpbdeltm);					/* ���ޱ���ɾ��ʱ�� */
			myset.GetFieldValue(_T("dpbdeltm"), lp->strDpbdeltm);					/* ��Ʊ���ɾ��ʱ�� */

			//�Ƿ���ȡ��
			if(!lp->bTakestatus)
			{
				delete lp;
				myset.MoveNext();
				continue;
			}

			//�Ƿ�ȫ����ɾ��
			if(lp->bOpdel && lp->bEpdel && lp->bFpdel && lp->bDpdel && lp->bOpbdel && lp->bEpbdel && lp->bFpbdel && lp->bDpbdel)
			{
				delete lp;
				myset.MoveNext();
				continue;
			}

			m_vPickupLog.push_back(lp);
			myset.MoveNext();
		}
	}
	catch (CException* e)
	{
		m_lock.unlock();
		CleareLog(m_vPickupLog);

		TCHAR szError[1024] = { 0 };
		e->GetErrorMessage(szError, 1024);
		WriteLogin(CString(szError));
		e->Delete();
	}
	m_lock.unlock();
}

void CPhotoDelMgr::FillData()
{
	if(m_vPickupLog.size() == 0)
		return;

	m_DelList.DeleteAllItems();
	std::vector<LPSPICKUPINFO>::iterator iter = m_vPickupLog.begin();
	for(;iter != m_vPickupLog.end();)
	{
		LPSPICKUPINFO lp = (*iter);
		if(lp != NULL)
		{
			CString strName = GetBranchNameForDomain(&m_BranchArr, lp->strBranchid);
			int nRow = m_DelList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, strName,0,0,2,0);
			m_DelList.SetItemText(nRow, 1, lp->strBranchid);
			m_DelList.SetItemText(nRow, 2, lp->strOrder);
			m_DelList.SetItemText(nRow, 3, TEXT("��ȡ"));
			m_DelList.SetItemText(nRow, 4, lp->strTaketime);
		}
		++iter;
	}
	if(m_DelList.GetItemCount() == 0)
		return;

	//FillPhotoType(0);
}

/************************************************************************/
/* 
	����:FillPhotoType
	����:��������б�
	����:
		IN const int nIdx			��������
	����:
*/
/************************************************************************/
void CPhotoDelMgr::FillPhotoType(IN const int nIdx)
{
	LPSPICKUPINFO lp = m_vPickupLog[nIdx];
	if(lp == NULL)
		return;

	m_PhotoTypeList.DeleteAllItems();
	int nRow = 0;
	nRow = m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("ԭƬ"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("ԭƬ����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���ޱ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���ޱ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("��Ʊ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpbNeedDel);
}

/************************************************************************/
/* 
	����:FillPhotoType
	����:��������б�
	����:
		IN const LPSPICKUPINFO lp		ȡ����Ϣ
	����:
*/
/************************************************************************/
void CPhotoDelMgr::FillPhotoType(IN const LPSPICKUPINFO lp)
{
	m_PhotoTypeList.DeleteAllItems();

	if(lp == NULL)
		return;

	int nRow = 0;
	nRow = m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("ԭƬ"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("ԭƬ����"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���ޱ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("���ޱ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("��Ʊ���"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpbdel == TRUE)?_T("��ɾ"):_T("δɾ")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpbNeedDel);
}

/************************************************************************/
/* 
	����:GetTimeField
	����:��ȡ������������
	����:
		OUT CString& strField				�������
	����:
*/
/************************************************************************/
int	 CPhotoDelMgr::GetTimeField(OUT CString& strField)
{
	CTime startTime, endTime, currTime;
	CString strStart(_T("")), strEnd(_T(""));

	m_StartTime.GetTime(startTime);
	strStart = startTime.Format(_T("%Y-%m-%d"));
	m_EndTime.GetTime(endTime);
	strEnd = endTime.Format(_T("%Y-%m-%d"));

	currTime = CTime::GetCurrentTime();
	if(startTime > currTime || endTime > currTime)
	{
		MessageBox(_T("���õ����ڲ��ܱȵ�ǰ��"));
		return 0;
	}

	if(startTime > endTime)
	{
		MessageBox(_T("��ʼ���ڲ��ܱȽ�������"));
		return 0;
	}
	strField = _T("(taketime>='") + strStart + _T("' and taketime<='") + strEnd + _T("')");
	return 1;
}

/************************************************************************/
/* 
	����:CleareLog
	����:���
	����:
		N std::vector<LPSPICKUPINFO>& vLog			�����ȡ����
	����:
*/
/************************************************************************/
void CPhotoDelMgr::CleareLog(IN std::vector<LPSPICKUPINFO>& vLog)
{
	std::vector<LPSPICKUPINFO>::iterator iter = vLog.begin();
	for(;iter != vLog.end();)
	{
		if((*iter) != NULL)
			delete (*iter);
		++iter;
	}
	vLog.clear();
}

/************************************************************************/
/* 
	����:LoadDelPhotoModule
	����:����ɾ������ģ��
	����:
		IN HINSTANCE hInstance		dllʵ�����
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
int	 CPhotoDelMgr::LoadDelPhotoModule(IN HINSTANCE hInstance)
{
	if(hInstance == NULL)
		return 0;

	HRESULT hr = NULL;
	if(hInstance && m_pFactory && m_pInterface)
		return 1;

	GetClassDelFileObject getDelFileObj = NULL;
	getDelFileObj = (GetClassDelFileObject)GetProcAddress(hInstance, "GetClassDelFileObject");
	if(getDelFileObj == NULL)
	{
		OutputDebugString(_T("��GetClassDelFileObjectʧ��\n"));
		return 0;
	}

	if(m_pFactory == NULL)
	{
		hr = getDelFileObj(CLSID_SC_DELFILESINTERFACE, IID_IClassFactory, (void**)&m_pFactory);
		if(FAILED(hr))
		{
			OutputDebugString(_T("��ȡCSC_DelfilesFactoryָ��ʧ��\n"));
			return 0;
		}
	}

	if(m_pInterface == NULL)
	{
		hr = m_pFactory->CreateInstance(NULL, IID_IUnknown, (void**)&m_pInterface);
		if(FAILED(hr))
		{
			OutputDebugString(_T("����ISC_DelFilesInterfaceʧ��\n"));
			m_pFactory->Release();
			return 0;
		}
	}
	return 1;
}

/************************************************************************/
/* 
	����:OnBnClickedSetAutodelBtn
	����:�����Զ�ɾ��
	����:
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
void CPhotoDelMgr::OnBnClickedSetAutodelBtn()
{
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
}

/************************************************************************/
/* 
	����:OnBnClickedRefreshBtn
	����:ˢ����Ϣ
	����:
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
void CPhotoDelMgr::OnBnClickedRefreshBtn()
{
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	LoadListData();
	FillData();
}

/************************************************************************/
/* 
	����:OnNMClickDeltypeList
	����:���ȡ���б�
	����:
	����:
*/
/************************************************************************/
void CPhotoDelMgr::OnNMClickDelinfoList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	m_PhotoTypeList.DeleteAllItems();
	if(pNMItemActivate->iItem != -1)
	{
		//ѡȡ����ʾ��Ƭ����
		CString strDomain = m_DelList.GetItemText(pNMItemActivate->iItem, 1);
		CString strOrder = m_DelList.GetItemText(pNMItemActivate->iItem, 2);
		
		std::vector<LPSPICKUPINFO>::iterator it = m_vPickupLog.begin();
		for(;it != m_vPickupLog.end();)
		{
			if((*it) != NULL && (*it)->bTakestatus && (*it)->strBranchid == strDomain && (*it)->strOrder == strOrder)
			{
				m_lpCurrSel = (*it);
				FillPhotoType(m_lpCurrSel);
				break;
			}
			++it;
		}
	}
	else
		m_lpCurrSel = NULL;

	if(m_lpCurrSel == NULL)
	{
		*pResult = 0;
		return;
	}

	//�ж��Ƿ�����listctrl��checkbox��
	DWORD dwPos = GetMessagePos();
	CPoint point(LOWORD(dwPos), HIWORD(dwPos));
	m_DelList.ScreenToClient(&point);

	LVHITTESTINFO lvinfo;
	lvinfo.pt = point;
	lvinfo.flags = LVHT_ABOVE;

	UINT nFlag;
	int nItem = m_DelList.HitTest(point, &nFlag);

	//�ж��Ƿ����checkbox��
	if(nFlag == LVHT_ONITEMSTATEICON)
	{
		//ѡȡ����ʾ��Ƭ����
		BOOL bFind = FALSE;
		std::vector<LPSPICKUPINFO>::iterator iter = m_vCurrSelLog.begin();
		for(;iter != m_vCurrSelLog.end();)
		{
			//�Ƿ��Ѵ��ڵ�ǰѡ���ҹ�ѡ�ļ�¼��
			if(m_lpCurrSel->strBranchid == (*iter)->strBranchid && m_lpCurrSel->strOrder == (*iter)->strOrder)
			{
				//���ڲ�����
				bFind = TRUE;
				break;
			}
			++iter;
		}

		//��Ϊ��ѡ
		if(!m_DelList.GetCheck(pNMItemActivate->iItem))
		{
			//��ѡ�ϣ�������û�ҵ�������
			if(!bFind)
				m_vCurrSelLog.push_back(m_lpCurrSel);
		}
		else
		{
			//ȥ����ѡ��ͬʱ�ڵ�ǰѡ��������ɾ��
			if(bFind)
				m_vCurrSelLog.erase(iter);
		}
	}
	*pResult = 0;
}


/************************************************************************/
/* 
	����:OnNMClickDeltypeList
	����:��������б�
	����:
	����:
*/
/************************************************************************/
void CPhotoDelMgr::OnNMClickDeltypeList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO: �ڴ����ӿؼ�֪ͨ�����������
	if(!m_lpCurrSel)
	{
		*pResult = 0;
		return;
	}

	//�ж��Ƿ�����listctrl��checkbox��
	DWORD dwPos = GetMessagePos();
	CPoint point(LOWORD(dwPos), HIWORD(dwPos));
	m_PhotoTypeList.ScreenToClient(&point);

	LVHITTESTINFO lvinfo;
	lvinfo.pt = point;
	lvinfo.flags = LVHT_ABOVE;

	UINT nFlag;
	int nItem = m_PhotoTypeList.HitTest(point, &nFlag);

	//�ж��Ƿ����checkbox��
	if(nFlag == LVHT_ONITEMSTATEICON)
	{
		BOOL bDeled = FALSE;
		//�����Ƿ���Ҫɾ��
		BOOL bNeedDel = !m_PhotoTypeList.GetCheck(pNMItemActivate->iItem);
		int nType = pNMItemActivate->iItem + 1;
		switch(nType)
		{
		case 1:
			//��ѡ����ɾ��������Ƭ������Ч
			if(bNeedDel && m_lpCurrSel->bOpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bOpNeedDel = bNeedDel;
			break;
		case 2:
			if(bNeedDel && m_lpCurrSel->bEpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bEpNeedDel = bNeedDel;
			break;
		case 3:
			if(bNeedDel && m_lpCurrSel->bFpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bFpNeedDel = bNeedDel;
			break;
		case 4:
			if(bNeedDel && m_lpCurrSel->bDpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bDpNeedDel = bNeedDel;
			break;
		case 5:
			if(bNeedDel && m_lpCurrSel->bOpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bOpbNeedDel = bNeedDel;
			break;
		case 6:
			if(bNeedDel && m_lpCurrSel->bEpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bEpbNeedDel = bNeedDel;
			break;
		case 7:
			if(bNeedDel && m_lpCurrSel->bFpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bFpbNeedDel = bNeedDel;
			break;
		case 8:
			if(bNeedDel && m_lpCurrSel->bDpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bDpbNeedDel = bNeedDel;
			break;
		}

		if(bDeled)
		{
			m_PhotoTypeList.SetCheck(pNMItemActivate->iItem, TRUE);
			MessageBox(_T("��ѡ�����Ƭ��ɾ"));
		}
	}
	*pResult = 0;
}

/************************************************************************/
/* 
	����:AddDelData
	����:����ɾ������
	����:
	����:
*/
/************************************************************************/
void CPhotoDelMgr::AddDelData(IN LPCTSTR lpDomain, IN LPCTSTR lpOrder, IN const BYTE nType)
{
	if(m_pInterface == NULL)
		return;

	if(lpDomain == NULL || (_tcscmp(lpDomain, _T("")) == 0) || lpOrder == NULL || (_tcscmp(lpOrder, _T("")) == 0))
		return;

	if(nType > 4)
	{
		std::vector<LPSBAKDIRINFO>::iterator it = m_vBackupDirInfos.begin();
		for(;it != m_vBackupDirInfos.end(); ++it)
		{
			LPSBAKDIRINFO lp = (*it);
			if(lp == NULL)
				continue;
		
			if(lp->byPhotoType != nType)
				continue;

			TCHAR szDir[MAX_PATH] = {0};
			memset(szDir, 0, sizeof(TCHAR)*MAX_PATH);
#ifndef ENTERPRISE_VERSION
			if( _tcscmp(lpDomain, g_sdomain) == 0)
			_stprintf(szDir, _T("%s\\%s"), lp->strDir, lpOrder);
#else
			//����
			//������ͬΪ���궩������ͬΪ�ֵ�
			if( _tcscmp(lpDomain, g_sdomain) == 0)
				_stprintf(szDir, _T("%s\\%s"), lp->strDir, lpOrder);
			else
				_stprintf(szDir, _T("%s\\%s\\%s"), lp->strDir, lpDomain, lpOrder);
#endif //#ifndef ENTERPRISE_VERSION
			m_pInterface->AddDelData(lpDomain, lpOrder, szDir, nType, TRUE);
		}
	}
	else
	{
		//��ȡ����Ŀ¼
		vector<TblNetShareInfo*>::iterator it = CBranchInfo::GetInstance()->m_TblNetShareInfo.begin();
		for(; it != CBranchInfo::GetInstance()->m_TblNetShareInfo.end(); it++)
		{
			TblNetShareInfo* p = (*it);
			if(p != NULL)
			{
				if (p->byPhotoType != nType)
					continue;

				if(_tcscmp(_T(""), p->szBranchId) == 0)
					continue;

				TCHAR szDir[MAX_PATH] = {0};
				memset(szDir, 0, sizeof(TCHAR)*MAX_PATH);

#ifndef ENTERPRISE_VERSION
				if( _tcscmp(lpDomain, p->szBranchId) != 0)
					continue;

				_stprintf(szDir, _T("%s\\%s"), p->szShareDirectory, lpOrder);
#else
				//����
				//������ͬΪ���궩������ͬΪ�ֵ�
				if( _tcscmp(lpDomain, p->szBranchId) == 0)
					_stprintf(szDir, _T("%s\\%s"), p->szShareDirectory, lpOrder);
				else
					_stprintf(szDir, _T("%s\\%s\\%s"), p->szShareDirectory, lpDomain, lpOrder);
#endif //#ifndef ENTERPRISE_VERSION
				m_pInterface->AddDelData(lpDomain, lpOrder, szDir, nType, TRUE);
			}
		}
	}
}

/************************************************************************/
/* 
	����:GetBranchInfo
	����:��ȡ�ֵ���Ϣ
	����:
		OUT CArray<CStringArray, CStringArray>& arr		���طֵ���
	����:
*/
/************************************************************************/
void  CPhotoDelMgr::GetBranchInfo(OUT CArray<CStringArray, CStringArray>& arr)
{
#ifndef ENTERPRISE_VERSION
	arr.SetSize(1, 1);
	arr.ElementAt(0).Add(g_sdomain);
	arr.ElementAt(0).Add(g_localname);
	//����4�����ַ�ֻ��ƥ��branchinfo.dat���Եĸ�ʽ
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
#else
	try
	{
		CFile fp;
		CString path = g_mainpath + _T("\\branchinfo.dat");
		if (::PathFileExists(path) == 0)
			return;

		fp.Open(path, CFile::modeRead);

		DWORD leng = fp.GetLength();
		if (leng < sizeof(DWORD) * 2)
		{
			fp.Close();
			return;
		}

		DWORD flag = 0;
		//fp.Seek(-sizeof(DWORD), CFile::end);
		fp.Seek(-(int)sizeof(DWORD), CFile::end);
		fp.Read(&flag, sizeof(DWORD));
		if (flag != 889900)
		{
			fp.Close();
			return;
		}

		fp.SeekToBegin();

		DWORD arraysize;
		fp.Read(&arraysize, sizeof(DWORD));
		if (arraysize > 20)
		{
			fp.Close();
			return;
		}

		BYTE *pData = new BYTE[leng - sizeof(DWORD)];
		fp.Read(pData, leng - sizeof(DWORD));
		fp.Close();

		CMemFile memfile;
		memfile.Attach(pData, leng - sizeof(DWORD));
		CArchive ar(&memfile, CArchive::load);
		arr.SetSize(arraysize, 1);
		for (int ii = 0; ii < arr.GetSize(); ii++)
			arr.ElementAt(ii).Serialize(ar);

		ar.Close();
		memfile.Detach();
		delete[]pData;
	}
	catch (...)
	{
	}
#endif
}

/************************************************************************/
/* 
	����:GetBranchInfo
	����:��ȡ�ֵ���Ϣ
	����:
		IN CArray<CStringArray, CStringArray>& arr,		�ֵ���
		IN const CString& strDomain						����
	����:CString										����
*/
/************************************************************************/
CString CPhotoDelMgr::GetBranchNameForDomain(IN CArray<CStringArray, CStringArray>* pArr, IN const CString& strDomain)
{
	if(pArr == NULL)
		return _T("");

	for(int i=0; i<pArr->GetSize(); i++)
	{
		if(pArr->ElementAt(i).ElementAt(0) == strDomain)
			return pArr->ElementAt(i).ElementAt(1);
	}
	return _T("");
}

/************************************************************************/
/* 
	����:GetBranchInfo
	����:��ȡ�ֵ���Ϣ
	����:
		IN CArray<CStringArray, CStringArray>& arr,		�ֵ���
		IN const CString& strName						����
	����:CString										����
*/
/************************************************************************/
CString CPhotoDelMgr::GetDomainForBranchName(IN CArray<CStringArray, CStringArray>* pArr, IN const CString& strName)
{
	if(pArr == NULL)
		return _T("");

	for(int i=0; i<pArr->GetSize(); i++)
	{
		if(pArr->ElementAt(i).ElementAt(1) == strName)
			return pArr->ElementAt(i).ElementAt(1);
	}
	return _T("");
}

/************************************************************************/
/* 
	����:OpenDb
	����:�������ݿ�
	����:
		IN LPCTSTR lpConnect					�������ݿ��ִ�
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
int	CPhotoDelMgr::OpenDb(IN LPCTSTR lpConnect)
{
#ifdef _UNICODE
	if(lpConnect == NULL || wcscmp(lpConnect, _T("")) == 0)
		return 0;
#else
	if(lpConnect == NULL || strcmp(lpConnect, "") == 0)
		return 0;
#endif //#ifdef _UNICODE

	m_lock.lock();
	if(m_pdb)
	{
		m_lock.unlock();
		return 1;
	}
	
#ifdef _UNICODE
	wcscpy(m_szConnect, lpConnect);
#else
	strcpy(m_szConnect, lpConnect);
#endif //#ifdef _UNICODE

	if (m_pdb == NULL)
	{
		try
		{
			m_pdb = new CDatabase;
			m_pdb->OpenEx(m_szConnect, CDatabase::noOdbcDialog);
		}
		catch (CDBException* e)
		{
			//m_strConnectErrorDescriptor = e->m_strError;
			m_lock.unlock();
			delete m_pdb;
			m_pdb = NULL;

			//OutputDebugString(e->m_strError);
			//LOG4C_NO_FILENUM((LOG_NOTICE,"�����ݿ�ʧ��:%s",CW2A(e->m_strError)));
#ifdef _DEBUG
			e->ReportError();
#endif //#ifdef _DEBUG
			e->Delete();
			return FALSE;
		}
	}

	m_lock.unlock();
	return 1;
}


/************************************************************************/
/* 
	����:DelFinish
	����:ɾ����ɻص�����
	����:
		LPVOID,				�ص�����ֵ
		LPVOID,
		LPVOID,
		LPVOID,
		LPVOID
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
int CPhotoDelMgr::DelFinish(IN LPVOID lpParam1, IN LPVOID lpParam2, IN LPVOID lpParam3, IN LPVOID lpParam4, IN LPVOID lpParam5, IN LPVOID lpParam6)
{
	AfxSetResourceHandle(g_Instance);
	return g_pPhotoDelMgr->DelFinishPro(lpParam1, lpParam2, lpParam3, lpParam4, lpParam5, lpParam6);
}

/************************************************************************/
/* 
	����:DelFinishPro
	����:ɾ����ɻص�����
	����:
		LPVOID,				�ص�����ֵ
		LPVOID,
		LPVOID,
		LPVOID,
		LPVOID
	����:1�ɹ���0ʧ��
*/
/************************************************************************/
int CPhotoDelMgr::DelFinishPro(IN LPVOID lpParam1, IN LPVOID lpParam2, IN LPVOID lpParam3, IN LPVOID lpParam4, IN LPVOID lpParam5, IN LPVOID lpParam6)
{
	BYTE byType = *((BYTE*)lpParam1);
	BOOL bSuccess = *((BOOL*)lpParam5);

	TCHAR szDomain[64] = {0};
	TCHAR szOrderNum[64] = {0};
	TCHAR szDir[MAX_PATH] = {0};

	_stprintf(szDomain, _T("%s") , (TCHAR*)lpParam2);
	_stprintf(szOrderNum, _T("%s") , (TCHAR*)lpParam3);
	_stprintf(szDir, _T("%s") , (TCHAR*)lpParam4);

	CString strShow = _T("");
	if(!bSuccess)
	{
		strShow.Format(_T("%s�����ڶ���%s��ɾ��ʧ��\n"), szDir, szOrderNum);
		SendMessage(MSG_SHOWPROMPTING, (WPARAM)&strShow, 0);
		return 0;
	}

	CString updateSql = _T("");
	switch ( byType )
	{
	case 1:
		updateSql.Format(_T("update [PhotoManager] set [opdel] = 1,[opdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 2:
		updateSql.Format(_T("update [PhotoManager] set [epdel] = 1,[epdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 3:
		updateSql.Format(_T("update [PhotoManager] set [fpdel] = 1,[fpdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 4:
		updateSql.Format(_T("update [PhotoManager] set [dpdel] = 1,[dpdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
		//////////////////////////////////////////////////////////////////////////
	case 5:
		updateSql.Format(_T("update [PhotoManager] set [opbdel] = 1,[opbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 6:
		updateSql.Format(_T("update [PhotoManager] set [epbdel] = 1,[epbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 7:
		updateSql.Format(_T("update [PhotoManager] set [fpbdel] = 1,[fpbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 8:
		updateSql.Format(_T("update [PhotoManager] set [dpbdel] = 1,[dpbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	default:
		break;
	}

	try
	{
		m_lock.lock();
		//������Ƭ������
		m_pdb->ExecuteSQL(updateSql);
	}
	catch (CDBException * e)
	{
		m_lock.unlock();
		WriteError(updateSql + "�������ݿ�ʧ��" + e->m_strError);
#ifdef _DEBUG
		e->ReportError();
#endif
		e->Delete();
		return 0;
	}
	m_lock.unlock();

	//�����б�
	std::vector<LPSPICKUPINFO>::iterator it = m_vCurrSelLog.begin();
	for(;it != m_vCurrSelLog.end();)
	{
		LPSPICKUPINFO lp = (*it);
		if(lp !=  NULL)
		{
			if(lp->strBranchid.CompareNoCase(szDomain) == 0 && lp->strOrder.CompareNoCase(szOrderNum) == 0)
			{
				strShow.Format(_T("%s��%s��������ɾ��\n"), szDir, szOrderNum);
				SendMessage(MSG_SHOWPROMPTING, (WPARAM)&strShow, 0);
				switch(byType)
				{
				case 1:
					lp->bOpdel = TRUE;
					lp->bOpNeedDel = FALSE;
					break;
				case 2:
					lp->bEpdel = TRUE;
					lp->bEpNeedDel = FALSE;
					break;
				case 3:
					lp->bFpdel = TRUE;
					lp->bFpNeedDel = FALSE;
					break;
				case 4:
					lp->bDpdel = TRUE;
					lp->bDpNeedDel = FALSE;
					break;
				case 5:
					lp->bOpbdel = TRUE;
					lp->bOpbNeedDel = FALSE;
					break;
				case 6:
					lp->bEpbdel = TRUE;
					lp->bEpbNeedDel = FALSE;
					break;
				case 7:
					lp->bFpbdel = TRUE;
					lp->bFpbNeedDel = FALSE;
					break;
				case 8:
					lp->bDpbdel = TRUE;
					lp->bDpbNeedDel = FALSE;
					break;
				}
				FillPhotoType(lp);

				int nCount = m_DelList.GetItemCount();
				for(int i=0; i<nCount; i++)
				{
					if(m_DelList.GetCheck(i) == TRUE)
					{
						CString strDomain = m_DelList.GetItemText(i, 1);
						CString strOrder = m_DelList.GetItemText(i, 2);
						if(strDomain.CompareNoCase(szDomain) == 0 && strOrder.CompareNoCase(szOrderNum) == 0)
						{
							m_DelList.SetCheck(i, FALSE);
							break;
						}
					}
				}
				break;
			}
		}
		++it;
	}

	return 1;
}

/************************************************************************/
/* 
	����:GetShareBackupDir
	����:��ȡ���ݹ���Ŀ¼
	����:
	����:
*/
/************************************************************************/
void CPhotoDelMgr::GetShareBackupDir()
{
	ClearBakDirInfo();

	CAutoLock autolock(&m_lock);
	try
	{
		CRstversion rsSt;
		rsSt.m_pDatabase = m_pdb;
		rsSt.Open();
		if (!rsSt.IsEOF())
		{
			CString strPath = _T("");
			LPSBAKDIRINFO lp = new SBAKDIRINFO;
			lp->byPhotoType = 5;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver1, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 6;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver2, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 7;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver3, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 8;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver4, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);
		}
		rsSt.Close();
	}
	catch (CException* e)
	{
		TCHAR szError[1024] = {0};
		e->GetErrorMessage(szError, 1024);
		CString strError = _T("");
		strError.Format(_T("��ȡ���ݹ���Ŀ¼��%s"), szError);
		WriteLogin(strError);
		e->Delete();
	}
}

void CPhotoDelMgr::ClearBakDirInfo()
{
	std::vector<LPSBAKDIRINFO>::iterator it = m_vBackupDirInfos.begin();
	for(; it != m_vBackupDirInfos.end(); ++it)
	{
		if((*it) != NULL)
			delete (*it);
	}
	m_vBackupDirInfos.clear();
}
/************************************************************************/
/* 
	����:MakeBackupDir
	����:���ɱ���Ŀ¼
	����:
		IN CONST CString& str,				// �����ǹ����������/Ŀ¼/ip��ַ
		OUT CString& strPath				// ���ر���Ŀ¼
	����:
*/
/************************************************************************/
void CPhotoDelMgr::MakeBackupDir(IN CONST int nType, IN CONST CString& str, OUT CString& strPath)
{
	if(str == _T("")) 
		return;

	CString strTemp = str;
	strTemp.MakeLower();

	CString strFolderName = _T("");
#ifdef CHILD_VERSION
	switch(nType)
	{
	case 5:
		strFolderName = _T("�ͻ�ԭƬ����(��ͯ��������)$");
		break;
	case 6:
		strFolderName = _T("�޺õ�Ƭ����(��ͯ��������)$");
		break;
	case 7:
		strFolderName = _T("���޺õ�Ƭ����(��ͯ��������)$");
		break;
	case 8:
		strFolderName = _T("��ƺõ�Ƭ����(��ͯ��������)$");
		break;
	}
#else
	switch(nType)
	{
	case 5:
		strFolderName = _T("�ͻ�ԭƬ����(��������)$");
		break;
	case 6:
		strFolderName = _T("�޺õ�Ƭ����(��������)$");
		break;
	case 7:
		strFolderName = _T("���޺õ�Ƭ����(��������)$");
		break;
	case 8:
		strFolderName = _T("��ƺõ�Ƭ����(��������)$");
		break;
	}
#endif
	
	char szServer[50] = {0};
	DWORD leng = 50;
	::GetComputerName(szServer, &leng);
	CString strMainName = szServer;
	strMainName.MakeLower();
	if(strTemp.Find(strFolderName) != -1)				//Ŀ¼
	{
		if(strTemp.Find(_T(":\\")) != -1 || strTemp.Find(_T("\\\\")) != -1)				// ����·��: D:\...\... (���: \\...\...)
			strPath = strTemp;
	}
	else if(strTemp.CompareNoCase(strMainName) == 0)				//�Ƿ�Ϊ�������
	{
		strMainName.TrimLeft(_T("\\\\"));
		strMainName.TrimRight(_T("\\"));
		strPath = _T("\\\\") + strMainName + _T("\\") + strFolderName;
	}
	else		//ip��ַ
	{
		if(strTemp.GetLength() <= 16)
		{
			CString strip = strTemp;
			int nCount = 0;
			while(1)
			{
				int nPos = strip.Find(_T("."));
				if(nPos == -1)
					break;

				strip = strip.Right((strip.GetLength() - 1) - nPos);
				if(strip == _T(""))
					break;
				++nCount;
			}

			if(nCount == 3)
				strTemp = strPath;
		}
	}
	if(strPath != _T(""))
		strPath.MakeLower();
}

//��ʾ��Ϣ
LRESULT CPhotoDelMgr::ShowPrompting(WPARAM wParam, LPARAM lParam)
{
	int nShowType = lParam;
	CString strMSG = *(CString*)wParam;

	static CHARFORMAT cf;
	cf.cbSize = sizeof(CHARFORMAT); 

	static COleDateTime oletime;
	oletime=COleDateTime::GetCurrentTime();

	strMSG.Format(_T("%s: #%s.\r"),oletime.Format(_T("%Y/%m/%d %H:%M:%S")),strMSG);
	//strMSG += ".\r";
	if ( nShowType == 1) // ������Ϣ��ʾ
	{
		// ��ʾǰ,����������ɫ;
		//m_EditShow.GetDefaultCharFormat(cf);
		m_DelTips.GetDefaultCharFormat(cf);
		cf.dwMask=CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_BOLD; 
		cf.dwEffects = (unsigned long)~(CFE_UNDERLINE | CFE_BOLD | CFE_AUTOCOLOR);
		//cf.dwEffects ^= CFE_AUTOCOLOR;
		cf.crTextColor = RGB(255, 0, 0); 
		cf.yHeight = 180;
		memset(cf.szFaceName, 0, LF_FACESIZE);
		//	memcpy(cf.szFaceName, "����_GB2312", sizeof("����_GB2312"));
		memcpy(cf.szFaceName, _T("����"), sizeof(_T("����")));
		m_DelTips.SetSelectionCharFormat(cf);

		m_DelTips.SetSel(-1,-1);
		m_DelTips.ReplaceSel(strMSG);
	}
	else	// �ɹ���Ϣ��ʾ;
	{
		m_DelTips.GetDefaultCharFormat(cf);
		cf.dwMask=CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_BOLD; 
		cf.dwEffects = (unsigned long)~(CFE_UNDERLINE | CFE_BOLD | CFE_AUTOCOLOR);
		//cf.dwEffects ^= CFE_AUTOCOLOR;
		cf.crTextColor = RGB(0, 0, 255); 
		cf.yHeight = 180;
		memset(cf.szFaceName, 0, LF_FACESIZE);
		//	memcpy(cf.szFaceName, "����_GB2312", sizeof("����_GB2312"));
		memcpy(cf.szFaceName, _T("����"), sizeof(_T("����")));
		m_DelTips.SetSelectionCharFormat(cf);

		m_DelTips.SetSel(-1,-1);
		m_DelTips.ReplaceSel(strMSG);
	}

	m_DelTips.PostMessage(WM_VSCROLL, SB_BOTTOM,0);
	return 0;
}