// DLG_Corp_File.cpp : implementation file
//

#include "stdafx.h"
#include "smsmanager.h"
#include "DLG_Corp_File.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// DLG_Corp_File dialog
#include "MainFrm.h"
#include "UserDlg.h"
#include "K_Agent.h"
#include "DLG_Corp_File_Add.h"
#include "io.h"

DLG_Corp_File::DLG_Corp_File(CWnd* pParent /*=NULL*/)
	: CDialog(DLG_Corp_File::IDD, pParent)
{
	//{{AFX_DATA_INIT(DLG_Corp_File)
	m_strCorpName = _T("");
	m_strCorpID = _T("");
	//}}AFX_DATA_INIT

	m_pDlg = (CDialog  *)pParent;
	m_lDlgType = 0;
	memset( &m_FileReq , 0 , sizeof(m_FileReq) );
	m_pFileData     = NULL;
	m_lUpAllSize = 0;
	m_lUpUpSize = 0;
	m_lUpFileID =0;

	m_lDownAllSize = 0;
	m_lDownUpSize = 0;
	m_lDownFileID =0;
	m_lFileType = 0;

}


void DLG_Corp_File::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(DLG_Corp_File)
	DDX_Control(pDX, IDC_CORP_FILE_GDT, m_P_GDT);
	DDX_Control(pDX, IDC_CORP_FILE_LIST, m_wndList);
	DDX_Text(pDX, IDC_CORP_FILE_CORPNAME, m_strCorpName);
	DDX_Text(pDX, IDC_CORP_FILE_CORPID, m_strCorpID);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(DLG_Corp_File, CDialog)
	//{{AFX_MSG_MAP(DLG_Corp_File)
	ON_BN_CLICKED(IDC_CORP_FILE_ADD, OnCorpFileAdd)
	ON_NOTIFY(NM_DBLCLK, IDC_CORP_FILE_LIST, OnDblclkCorpFileList)
	ON_BN_CLICKED(IDC_CORP_FILE_MODIFY, OnCorpFileModify)
	ON_BN_CLICKED(IDC_CORP_FILE_DEL, OnCorpFileDel)
	ON_BN_CLICKED(IDC_CORP_FILE_UPLOAD, OnCorpFileUpload)
	ON_BN_CLICKED(IDC_CORP_FILE_DOWNLOAD, OnCorpFileDownload)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// DLG_Corp_File message handlers

BOOL DLG_Corp_File::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	
	m_strCorpName = m_FileReq.ret.szCorpName;
	m_strCorpID.Format( _T("%d") , m_FileReq.ret.lCorpID );
	this->UpdateData(false);
	
	//��ʼ��List
	m_Image.Create(16,16,ILC_COLOR16|ILC_MASK,5,5);
	m_Image.Add(AfxGetApp()->LoadIcon(IDI_L_CORP) );
	m_wndList.SubClassWindow2();
	m_wndList.SetHeadings(_T("���,50; �ļ�����,100; ǩ��ʱ��,90; �ϴ�ʱ��,90; �ϴ��û�,80;��С(K),70;�Ƿ�����,70;ԭʼ�ļ���,200;��ע,200;"));
	m_wndList.SetGridLines(true);
	m_wndList.SetImageList(&m_Image,LVSIL_SMALL);

	for ( int i = 0 ; i< m_FileReq.lCount ; i++ )
	{
		SetListText(m_pFileData[i],-1); //-1����
	}


	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void DLG_Corp_File::SetParam(ANS_Corp_File File, ANS_Corp_FileData *pFileData,long lDlgType)
{
	m_FileReq    = File;
	m_pFileData  = pFileData;
	m_lDlgType   = lDlgType;
}

BOOL DLG_Corp_File::ProcessSocket(Socket_Head *pHead)
{
	//�鿴�û���¼
	if (pHead->lFuncType == SMSFUNC_CORP_FILE)
	{
		ANS_Corp_File     * pFile = (ANS_Corp_File     *)pHead->pFrame;
		ANS_Corp_FileData * pFileData = (ANS_Corp_FileData *)(pHead->pFrame+sizeof(ANS_Corp_File));
		if ( pFile->lCount < 0 )   //Ȩ�޲��㣬���ش���
			return true;

		if ( pFile->ret.lReqType == 1 ) //����
		{
			if ( pFile->bOK && pFile->lCount>0 )
			{
				SetListText(*pFileData , -1 );  //-1����
			}
		}
		if ( pFile->ret.lReqType == 2 ) //�޸�
		{
			if ( pFile->bOK && pFile->lCount>0 )
			{
				SetListText(*pFileData , -2 );  //-1Ϊ�޸�����
			}
		}
		if ( pFile->ret.lReqType == 3 ) //ɾ��
		{
			if ( pFile->bOK && pFile->lCount>0 )
			{
				long lItem=0;
				long lCount=m_wndList.GetItemCount();
				for ( int i=0 ; i<lCount ; i++ )
				{
					if ( m_wndList.GetItemData(i) == pFileData->lFileID )
					{
						lItem = i;
						break;
					}
				}
				if ( i>=lCount )
					return true;

				m_wndList.DeleteItem(lItem);
			}
		}
		if ( pFile->ret.lReqType == 4 ) //�ϴ�
		{
			if ( pFile->bOK && pFile->lCount>0 )
			{
				if ( pFile->ret.lAllSize == pFile->ret.lUpSize )  //���ϴ����
				{

					m_P_GDT.SetRange(0,0); //�ϴ���ɣ��رչ�����
					m_UpFile.Close();

					//������Ϣ
					ANS_Corp_FileData FileData={0};
					FileData.lFileID = pFile->ret.lFileID;
					FileData.lFileSize=pFile->ret.lAllSize;
					FileData.lUploadSize=pFile->ret.lUpSize;
					_tcscpy(FileData.szFileName , pFile->ret.szCorpName );
					::GetLocalTime(&FileData.tUploadTime);
					SetListText(FileData , -3 );  //-3Ϊ�����ϴ�����

					MessageBox( _T("�ļ��ϴ���ɣ�") , _T("��Ϣ") , MB_ICONINFORMATION );
					EnableCtrl(true);


				}
				else
				{
					m_P_GDT.SetPos(pFile->ret.lUpSize);
					UpFileNext();
				}
			}
		}

		if ( pFile->ret.lReqType == 5 ) //����
		{


			if ( pFile->bOK && pFile->lCount>0 )
			{
				#define MAXUPFILESIZE 32*1024 //ÿ������32K			
				//if ( pFile->ret.lSize <= pFile->ret.lUpSize )  //�յ���һ֡
				if (pFile->ret.lUpSize <= MAXUPFILESIZE)  //�յ��ĵ�һ֡
				{
					m_P_GDT.SetRange32(0,pFile->ret.lAllSize);

					BYTE cRarHead[] = { 0x52,0x61,0x72,0x21,0x1A,0x07,0x00,0xCF,0x90,0x73,0x00,0x00,0x0D,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
					long lRarHeadLen = sizeof(cRarHead);
					if (memcmp((BYTE*)pFileData, (BYTE*)cRarHead, lRarHeadLen) == 0)
					{
						m_lFileType = 0;  //rar�ļ�
					}
					else
					{
						m_lFileType = 1; //�����ļ�
					}
				}
				

				m_DownFile.Write((BYTE*)pFileData ,pFile->ret.lSize );  //д�ļ�

				if ( pFile->ret.lAllSize == pFile->ret.lUpSize )  //�������
				{
					m_P_GDT.SetRange(0,0); //�ϴ���ɣ��رչ�����
					m_DownFile.Close();

					EnableCtrl(true);
					CString strTemp=m_strDownFileName;
					strTemp.MakeUpper();
					//��ѹ���ļ���ԭ�ļ�����ѹ���ļ��ģ�ֱ�ӽ��ļ�����Ŀ���ļ���
					if (m_lFileType==1 || strTemp.Find(_T(".RAR"))>0 || strTemp.Find(_T(".ZIP"))>0 )  //ԭ���ϴ��ľ���ѹ���ļ�������Ҫ�ٽ�ѹ
					{
						if ( ! ::CopyFile(m_strDownRarFile,m_strDownFilePath +CString(_T("\\"))+ m_strDownFileName , false ) )
						{
							MessageBox(_T("�����ļ���Ŀ���ļ���ʧ��!")  , _T("����") , MB_ICONWARNING );
							return true;
						}
					}
					else
					{
						//ȡ��ǰ�ļ���
						TCHAR szPath[512]={0};
						GetCurrentPath(szPath);
						CString strRar;
						strRar.Format( _T("%srar.exe") , szPath );
						//���ļ���ѹ��Ŀ���ļ���
						STARTUPINFO si;
						PROCESS_INFORMATION pi;
						ZeroMemory( &si, sizeof(si) );
						si.cb = sizeof(si);
						ZeroMemory( &pi, sizeof(pi) );
						CString strCmd;
						strCmd.Format( _T("%s x -y \"%s\" \"%s\"") , strRar,m_strDownRarFile,m_strDownFilePath +CString(_T("\\")));

						
						BOOL b2=CreateProcess(NULL,strCmd.GetBuffer(),NULL,NULL,false,NULL,NULL,NULL,&si,&pi);
						if ( b2 )
						{
							if ( WaitForSingleObject( pi.hProcess, 50000 ) !=WAIT_TIMEOUT)   //�ȴ�20��
							{
								//���ѹ���ɹ���ɾ��ԭ�ļ�
								//::DeleteFile( strFileName );
							}
						}
						Sleep(500);  //��ʱһ��
					}
					long lRet = MessageBox(_T("�ļ�������ɣ��Ƿ���ֱ�Ӵ��ļ���"), _T("����"), MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON1);
					if (lRet == IDYES)
					{
						//������ɣ����ļ�
						ShellExecute(NULL, _T("open"), m_strDownFileName, NULL, m_strDownFilePath, SW_SHOWNORMAL);
					}

					
				}
				else
				{
					m_P_GDT.SetPos(pFile->ret.lUpSize);
				}

			}
		}

		return true;
	}

	return false;
}

void DLG_Corp_File::OnCorpFileAdd() 
{
	ANS_Corp_FileData FileData={0};
	FileData.lCorpType = m_FileReq.ret.lCorpType;
	FileData.lCorpID   = m_FileReq.ret.lCorpID;

	DLG_Corp_File_Add dlg(this);
	dlg.SetParam( FileData , true );
	if ( dlg.DoModal() == IDOK )
	{
		FileData = dlg.GetParam();
		
		long lSize = sizeof(REQ_Corp_File) + sizeof(ANS_Corp_FileData);
		BYTE * pData = new BYTE[lSize];memset(pData,0,lSize);
		REQ_Corp_File     * pPayRet     = (REQ_Corp_File *)pData;
		ANS_Corp_FileData * pPayDataRet = (ANS_Corp_FileData *)(pData+sizeof(REQ_Corp_File));

		*pPayRet = m_FileReq.ret;
		pPayRet->lReqType = 1; //����

		*pPayDataRet = FileData;

		SendFrame(SMSFUNC_CORP_FILE , pData , lSize );

	}
	
}

void DLG_Corp_File::SetListText(ANS_Corp_FileData FileData, long lType)
{
	CString str;
	long lItem=0;
	if ( lType==-1 )
	{
		lItem = m_wndList.GetItemCount();
		str.Format( _T("%d") , lItem+1 );
		m_wndList.InsertItem( lItem , str , 0 );
	}
	if ( lType==-2 || lType==-3)
	{
		long lCount=m_wndList.GetItemCount();
		for ( int i=0 ; i<lCount ; i++ )
		{
			if ( m_wndList.GetItemData(i) == FileData.lFileID )
			{
				lItem = i;
				break;
			}
		}
		if ( i>=lCount )
			return ;
	}

	int iTemp=1;
	if ( lType == -1 || lType == -2 )
	{
		m_wndList.SetItemText( lItem , iTemp++ , FileData.szFileType);
		str.Format( _T("%04d.%02d.%02d") , FileData.tFileTime.wYear,FileData.tFileTime.wMonth,FileData.tFileTime.wDay );
		m_wndList.SetItemText( lItem , iTemp++ , str );
	}
	else
	{
		iTemp += 2 ;
	}

	if ( lType==-1 || lType == -3 )
	{
		str.Format( _T("%04d.%02d.%02d") , FileData.tUploadTime.wYear,FileData.tUploadTime.wMonth,FileData.tUploadTime.wDay );
		m_wndList.SetItemText( lItem , iTemp++ , str );
		m_wndList.SetItemText( lItem , iTemp++ , FileData.szUploadUser );
		if ( FileData.lFileSize>0 )
			str.Format( _T("%d") , FileData.lFileSize/1024 );
		else
			str = _T("0");
		m_wndList.SetItemText( lItem , iTemp++ , str );
		if ( FileData.lFileSize>0 )
			str = FileData.lFileSize == FileData.lUploadSize ? _T(" ��") : _T(" ��");
		else
			str = _T(" ��");
		m_wndList.SetItemText( lItem , iTemp++ , str );
		m_wndList.SetItemText( lItem , iTemp++ , FileData.szFileName );
	}
	else
	{
		iTemp += 5;
	}

	if ( lType == -1 || lType == -2 )
	{
		m_wndList.SetItemText( lItem , iTemp++ , FileData.szBZ );
	}
	else
	{
		iTemp+=1;
	}
	
	m_wndList.SetItemData( lItem , FileData.lFileID );
}

long DLG_Corp_File::GetCurrentSelected()
{
	POSITION pos = m_wndList.GetFirstSelectedItemPosition();
	if ( pos )
	{
		return m_wndList.GetNextSelectedItem(pos);
	}
	return -1;
}

void DLG_Corp_File::OnDblclkCorpFileList(NMHDR* pNMHDR, LRESULT* pResult) 
{
	*pResult = 0;


	OnCorpFileModify();
}

void DLG_Corp_File::OnCorpFileModify() 
{
	long lItem = GetCurrentSelected();
	if ( lItem<0 )
		return ;

	ANS_Corp_FileData FileData={0};
	FileData.lCorpType = m_FileReq.ret.lCorpType;
	FileData.lCorpID   = m_FileReq.ret.lCorpID;

	FileData.lFileID = m_wndList.GetItemData(lItem);

	m_wndList.GetItemText(lItem , 1 , FileData.szFileType , sizeof(FileData.szFileType)-2 );
	m_wndList.GetItemText(lItem , 8 , FileData.szBZ       , sizeof(FileData.szBZ)-2 );

	CString str;
	str = m_wndList.GetItemText(lItem , 2 );
	COleDateTime t;
	str.Replace( _T(".") , _T("-") );
	BOOL btime = t.ParseDateTime(str,VAR_DATEVALUEONLY);
	if ( t.GetStatus() == COleDateTime::valid )
	{
		t.GetAsSystemTime(FileData.tFileTime);
	}


	DLG_Corp_File_Add dlg(this);
	dlg.SetParam( FileData , false );
	if ( dlg.DoModal() == IDOK )
	{
		FileData = dlg.GetParam();
		
		long lSize = sizeof(REQ_Corp_File) + sizeof(ANS_Corp_FileData);
		BYTE * pData = new BYTE[lSize];memset(pData,0,lSize);
		REQ_Corp_File     * pPayRet     = (REQ_Corp_File *)pData;
		ANS_Corp_FileData * pPayDataRet = (ANS_Corp_FileData *)(pData+sizeof(REQ_Corp_File));

		*pPayRet = m_FileReq.ret;
		pPayRet->lReqType = 2; //�޸�

		*pPayDataRet = FileData;

		SendFrame(SMSFUNC_CORP_FILE , pData , lSize );

	}

}

void DLG_Corp_File::OnCorpFileDel() 
{
	long lItem = GetCurrentSelected();
	if ( lItem<0 )
		return ;

	ANS_Corp_FileData FileData={0};
	FileData.lCorpType = m_FileReq.ret.lCorpType;
	FileData.lCorpID   = m_FileReq.ret.lCorpID;

	FileData.lFileID = m_wndList.GetItemData(lItem);
	CString str,str2;
	str = m_wndList.GetItemText(lItem , 1 );

	str2.Format( _T("ȷ��Ҫɾ��(%s)�ļ���") , str );
	int iRet = MessageBox(str2 , _T("����") , MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2 );
	if ( iRet != IDYES )
		return ;

	long lSize = sizeof(REQ_Corp_File) + sizeof(ANS_Corp_FileData);
	BYTE * pData = new BYTE[lSize];memset(pData,0,lSize);
	REQ_Corp_File     * pPayRet     = (REQ_Corp_File *)pData;
	ANS_Corp_FileData * pPayDataRet = (ANS_Corp_FileData *)(pData+sizeof(REQ_Corp_File));
	
	*pPayRet = m_FileReq.ret;
	pPayRet->lReqType = 3; //ɾ��
	
	*pPayDataRet = FileData;
	
	SendFrame(SMSFUNC_CORP_FILE , pData , lSize );
}

void DLG_Corp_File::OnCorpFileUpload() 
{
	long lItem = GetCurrentSelected();
	if ( lItem<0 )
		return ;

	m_lUpFileID = m_wndList.GetItemData(lItem);
	CString str = m_wndList.GetItemText(lItem ,6 );
	if ( str == _T(" ��") )
	{
		int iRet =MessageBox( _T("��ѡ���ļ����ϴ��������Ƿ������ϴ���") , _T("����") , MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON2);
		if ( iRet != IDYES )
			return ;
	}

#define FILE_FILTER_TEXT \
    TEXT("�����ļ� (*.*)\0*.*;\0\0")

	TCHAR szFile[ 256 ];
	TCHAR szFileB[ 256 ];
	*szFileB = NULL;
	_stprintf( szFile , _T("*.*") );
	
	OPENFILENAME  sOpen;
	sOpen.lStructSize = sizeof( sOpen );
	sOpen.hwndOwner = this->m_hWnd ;
	sOpen.Flags = OFN_EXPLORER|OFN_OVERWRITEPROMPT|OFN_HIDEREADONLY;
	sOpen.lpstrFilter = FILE_FILTER_TEXT;
	sOpen.lpstrDefExt = _T("*");
	sOpen.lpstrCustomFilter = NULL;
	sOpen.nMaxCustFilter    = 0;
	sOpen.lpstrFile = szFile;
	sOpen.nMaxFile  = sizeof( szFile );
	sOpen.lpstrFileTitle = szFileB;
	sOpen.nMaxFileTitle = sizeof( szFileB );
	sOpen.lpstrInitialDir = NULL;
	sOpen.lpstrTitle = _T("���ϴ����ļ�");
	if ( ::GetOpenFileName( &sOpen ) )
	{
		CString strName = sOpen.lpstrFile;
		CString strTemp = strName;
		CString strName2= strName;
		strTemp.MakeUpper();
		if ( strTemp.Find(_T(".RAR"))>0 || strTemp.Find(_T(".ZIP"))>0 )  //����ѹ���ļ���������ѹ���ϴ�
		{

		}
		else
		{
			//ѹ���ļ�
			//ȡ��ǰ�ļ���
			TCHAR szPath[512]={0};
			GetCurrentPath(szPath);
			CString strRar;
			strRar.Format( _T("%srar.exe") , szPath );
			_tcscat(szPath , _T("Temp\\") );
			::CreateDirectory(szPath,NULL); //�����ļ���
			_tcscat(szPath , _T("UpLoad.rar") );
			if ( _taccess(szPath, 0) != -1 )
			{
				if ( !::DeleteFile(szPath) )
				{
					MessageBox( _T("�ļ���ͻ���������������ԣ�") , _T("����") , MB_ICONWARNING );
					return ;
				}
			}

			CString strRarName = szPath;
			
			STARTUPINFO si;
			PROCESS_INFORMATION pi;
			ZeroMemory( &si, sizeof(si) );
			si.cb = sizeof(si);
			ZeroMemory( &pi, sizeof(pi) );
			CString strCmd;
			strCmd.Format( _T("%s a -ep1 \"%s\" \"%s\"") , strRar,strRarName,strName);

			BOOL b2=CreateProcess(NULL,strCmd.GetBuffer(),NULL,NULL,false,NULL,NULL,NULL,&si,&pi);
			if ( b2 )
			{
				if ( WaitForSingleObject( pi.hProcess, 50000 ) !=WAIT_TIMEOUT)   //�ȴ�20��
				{
					//���ѹ���ɹ���ɾ��ԭ�ļ�
					//::DeleteFile( strFileName );
				}
				Sleep(500);  //��ʱһ��
				strName2 = strRarName;
			}
			else
			{
				strCmd.Format(_T("ѹ���ļ�ʧ�ܣ�%d������ʹ��ԭ�ļ��ϴ�!\r\n%s"), ::GetLastError(),strCmd);
				MessageBox(strCmd, _T("��ʾ"), MB_ICONINFORMATION);
			}
		}
		//ȡԭʼ�ļ���
		m_strUpFileName = strName;
		long lLen = strName.GetLength();
		for ( int i=lLen-1 ; i>=0 ; i-- )
		{
			if ( strName.GetAt(i) == '\\' || strName.GetAt(i) == '/' )
			{
				m_strUpFileName = strName.Right(lLen-i-1);
				break;
			}
		}

		//��ʼ�ϴ�
		if ( !m_UpFile.Open(strName2 , CFile::modeRead) )
		{
			MessageBox( _T("���ļ����󣬽������������ԣ�") , _T("����") , MB_ICONWARNING );
			return ;
		}
		m_lUpAllSize=m_UpFile.GetLength();
		if ( m_lUpAllSize>2*1024*1024 ) //�Ƿ����2M
		{
			m_UpFile.Close();
			MessageBox( _T("�����ϴ�����2M���ļ���������С�����ϴ�!") , _T("����") , MB_ICONWARNING );
			return ;
		}
		m_lUpUpSize=0;

		EnableCtrl(false);
		m_P_GDT.SetRange32(0,m_lUpAllSize);
		UpFileNext();
	}
	
}

BOOL DLG_Corp_File::UpFileNext()
{
#define MAXUPFILESIZE 32*1024 //ÿ���ϴ�32K

	long lSize = sizeof(REQ_Corp_File) + MAXUPFILESIZE;
	BYTE * pData = new BYTE[lSize];
	memset(pData , 0 , lSize );
	REQ_Corp_File * pFile = (REQ_Corp_File * )pData;
	BYTE * pBuf = pData+sizeof(REQ_Corp_File);

	pFile->lFileID = m_lUpFileID;
	pFile->lReqType= 4; //�ϴ�
	_tcscpy(pFile->szCorpName , m_strUpFileName );
	pFile->lAllSize  = m_lUpAllSize;
	DWORD dwRead=0;
	dwRead = m_UpFile.Read(pBuf , MAXUPFILESIZE );
	if ( dwRead >0 )
	{
		m_lUpUpSize += dwRead;
		pFile->lUpSize= m_lUpUpSize;
		pFile->lSize  = dwRead;
		SendFrame(SMSFUNC_CORP_FILE , pData , lSize );
		return true;
	}
	return false;
}

void DLG_Corp_File::OnCorpFileDownload() 
{
	long lItem = GetCurrentSelected();
	if ( lItem<0 )
		return ;

	long lFileID = m_wndList.GetItemData(lItem);
	CString str = m_wndList.GetItemText(lItem ,6 );
	if ( str != _T(" ��") )
	{
		MessageBox( _T("��ѡ���ļ�δ�ϴ���������������!") , _T("����") , MB_ICONWARNING);
		return ;
	}

	//ѹ���ļ�
	//ȡ��ǰ�ļ���
	TCHAR szPath[512]={0};
	GetCurrentPath(szPath);
	_tcscat(szPath , _T("Temp\\") );
	::CreateDirectory(szPath,NULL); //�����ļ���
	_tcscat(szPath , _T("DownLoad.rar") );
	if ( _taccess(szPath, 0) != -1 )
	{
		if ( !::DeleteFile(szPath) )
		{
			MessageBox( _T("�ļ���ͻ���������������ԣ�") , _T("����") , MB_ICONWARNING );
			return ;
		}
	}
	m_strDownRarFile = szPath;

	BROWSEINFO	BInfo={0};
	BInfo.hwndOwner = this->GetSafeHwnd();
	BInfo.pszDisplayName = szPath;
	BInfo.pidlRoot=0;
	BInfo.lpszTitle = _T("��ѡ���ļ�����·����");
	BInfo.ulFlags = BIF_RETURNONLYFSDIRS; //�涨ֻ��ѡ���ļ��У�������Ч
	LPCITEMIDLIST pid = SHBrowseForFolder(&BInfo);
	if ( pid && SHGetPathFromIDList(pid,szPath) )
	{

		if ( !m_DownFile.Open(m_strDownRarFile , CFile::modeCreate|CFile::modeWrite) )
		{
			MessageBox( _T("�����ļ�ʧ�ܣ��������������ԣ�") , _T("����") , MB_ICONWARNING );
			return ;
		}

		EnableCtrl(false);

		str = m_wndList.GetItemText(lItem,7);  //ԭʼ�ļ���
		m_strDownFilePath = szPath;
		//m_strDownFileName = m_strDownFilePath + _T("\\")+ str;
		m_strDownFileName   = str;  //ԭʼ�ļ���
		m_lFileType = 0;// 0-rar�ļ���1-��ͨ�ļ�

		REQ_Corp_File * pFile = new REQ_Corp_File;
		memset(pFile , 0 , sizeof(REQ_Corp_File));
		pFile->lFileID = lFileID;
		pFile->lReqType= 5; //����
		_tcscpy(pFile->szCorpName , str );
		SendFrame(SMSFUNC_CORP_FILE , (BYTE*)pFile , sizeof(REQ_Corp_File) );
	}			
}

void DLG_Corp_File::EnableCtrl(BOOL b)
{

	GetDlgItem(IDC_CORP_FILE_LIST)->EnableWindow(b);
	GetDlgItem(IDC_CORP_FILE_ADD)->EnableWindow(b);
	GetDlgItem(IDC_CORP_FILE_MODIFY)->EnableWindow(b);
	GetDlgItem(IDC_CORP_FILE_DEL)->EnableWindow(b);
	GetDlgItem(IDC_CORP_FILE_UPLOAD)->EnableWindow(b);
	GetDlgItem(IDC_CORP_FILE_DOWNLOAD)->EnableWindow(b);
}

void DLG_Corp_File::GetCurrentPath(TCHAR *pPath)
{
	if ( m_lDlgType == 1 ) //������
	{
		((CK_Agent*)m_pDlg)->m_pMainFrame->GetCurrentPath(pPath);
	}
	else
	{
		((CUserDlg*)m_pDlg)->m_pMainFrame->GetCurrentPath(pPath);
	}

}

BOOL DLG_Corp_File::SendFrame(unsigned char lFuncType, unsigned char *pFrame, unsigned long lFrameLen)
{
	if ( m_lDlgType == 1 ) //������
	{
		return ((CK_Agent*)m_pDlg)->m_pMainFrame->SendFrame(lFuncType,pFrame,lFrameLen);
	}
	else
	{
		return ((CUserDlg*)m_pDlg)->m_pMainFrame->SendFrame(lFuncType,pFrame,lFrameLen);
	}

}