//------------------------------------------------------------------------------
/// 지정된 사이즈의 BmpFile인가를 체크한다.
//------------------------------------------------------------------------------
bool CClanMarkTransfer::Check_BmpFile( HANDLE hFile, SIZE size )
{
DWORD dwFileSizeHigh;
DWORD dwFileSizeLow = GetFileSize( hFile, &dwFileSizeHigh );
if( dwFileSizeLow == INVALID_FILE_SIZE || dwFileSizeHigh != 0 )
{
_RPTF1( _CRT_ASSERT,"GetFileSize Error(%d)", GetLastError() );
g_itMGR.OpenMsgBox("CClanMarkTransfer::Check_BmpFile-GetFileSize Error" );
return false;
}
///BMP 화일 최소 사이즈( 헤더사이즈) Check
const int BmpHeaderSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER );
if( dwFileSizeLow < BmpHeaderSize )
{
_RPTF1( _CRT_ASSERT,"File Size is too small(%d)", dwFileSizeLow );
g_itMGR.OpenMsgBox( CStr::Printf("%s %s",STR_CLANMARK_INVALID_FORMAT ,STR_CLANMARK_HELP_HOMEPAGE ));
return false;
}
///File Load
BYTE header_buffer[BmpHeaderSize];
DWORD NumberOfBytesRead;
if( FALSE == ReadFile( hFile, header_buffer, BmpHeaderSize, &NumberOfBytesRead, NULL ) )
{
_RPTF0( _CRT_ASSERT,"ReadFile Error:BmpFile" );
g_itMGR.OpenMsgBox( "CClanMarkTransfer::Check_BmpFile-ReadFile Error" );
return false;
}
/// 2. 포맷이 맞는지 체크
BITMAPFILEHEADER* BitmapFileHeader = (BITMAPFILEHEADER*)header_buffer;
BITMAPINFOHEADER* BitmapInfoHeader = (BITMAPINFOHEADER*)&(header_buffer[ sizeof( BITMAPFILEHEADER) ]);
const WORD DIB_HEADER_MARKER = 0x4D42;
if( BitmapFileHeader->bfType != DIB_HEADER_MARKER )
{
_RPTF0( _CRT_ASSERT,"Invalid Bmp Format File" );
g_itMGR.OpenMsgBox( CStr::Printf("%s %s",STR_CLANMARK_INVALID_FORMAT,STR_CLANMARK_HELP_HOMEPAGE ) );
return false;
}
if( size.cx > 0 && size.cy > 0 )
{
if( BitmapInfoHeader->biWidth != size.cx || BitmapInfoHeader->biHeight != size.cy )
{
_RPTF2( _CRT_ASSERT,"Invalid Canvas Size( Require - Width:20,Height:20 ) ,File (Width:%d, Height:%d)",
BitmapInfoHeader->biWidth, BitmapInfoHeader->biHeight );
g_itMGR.OpenMsgBox( CStr::Printf("%s %s",STR_CLANMARK_INVALID_SIZE ,STR_CLANMARK_HELP_HOMEPAGE ));
return false;
}
}
return true;
}
void CTransfer::OnDropped(BOOL bError)
{
CString strHost = inet_ntoa( m_pHost.sin_addr );
_RPTF1(_CRT_WARN, _T("WARNING: Dropped Connection From %s\n"), strHost);
Disconnect();
}
//--------------------------------------------------------------------------------
/// 1. 서버로 부터 받은 데이타로 임시 ZipFile생성
//--------------------------------------------------------------------------------
bool CClanMarkTransfer::SaveZipFileFromServer( const char* TempZipFileName, DWORD* pdwNumberOfBytesWritten, BYTE* pData, int iSize )
{
HANDLE hTempZipFile = CreateFile( TempZipFileName, GENERIC_WRITE, 0, 0,CREATE_ALWAYS ,FILE_ATTRIBUTE_NORMAL, NULL );
if( hTempZipFile == INVALID_HANDLE_VALUE )
{
DWORD dwErr = GetLastError();
_RPTF2( _CRT_ASSERT,"CreateFile Error:%s %d",TempZipFileName, dwErr );
g_itMGR.OpenMsgBox( "CClanMarkTransfer::SaveZipFileFromServer - CreateFile Error");
return false;
}
if( FALSE == WriteFile( hTempZipFile, pData, iSize, pdwNumberOfBytesWritten, NULL ) )
{
int iErr = GetLastError();
_RPTF1( _CRT_ASSERT,"WriteFile Error:%d", iErr );
g_itMGR.OpenMsgBox( "CClanMarkTransfer::SaverZipFileFromServer - WriteFile Error");
CloseHandle( hTempZipFile );
return false;
}
assert( iSize == *pdwNumberOfBytesWritten );
CloseHandle( hTempZipFile );
return true;
}
//--------------------------------------------------------------------------------
/// 3. Memory에 로딩하면서 바로 임시 화일에 저장
//--------------------------------------------------------------------------------
bool CClanMarkTransfer::WriteToZipFile( const char* TempZipFileName, HANDLE hBmpFile, DWORD* pdwNumberOfBytesRead )
{
gzFile zfp;
if( (zfp = gzopen( TempZipFileName, "wb9")) == NULL )
{
_RPTF0( _CRT_ASSERT,"Open Error, Temporary zip file" );
g_itMGR.OpenMsgBox( "CClanMarkTransfer::WriteToZipFile-gzopen Error");
return false;
}
BYTE read_buffer[256];
SetFilePointer( hBmpFile, 0, 0, FILE_BEGIN );//File Pointer앞으로 이동
while( ReadFile( hBmpFile,read_buffer, sizeof(read_buffer),pdwNumberOfBytesRead,NULL ) )
{
if( *pdwNumberOfBytesRead == 0 )///EOF
break;
if (gzwrite(zfp, read_buffer, *pdwNumberOfBytesRead ) < 0)
{
int lerrno = 0;
g_itMGR.OpenMsgBox( "CClanMarkTransfer::WriteToZipFile-gzwrite Error");
_RPTF1( _CRT_ASSERT,"gzwrite error:%s",gzerror(zfp,&lerrno ));
gzclose(zfp);
return false;
}
}
gzclose(zfp);
return true;
}
//--------------------------------------------------------------------------------
/// 2. CRC를 구한다.
//--------------------------------------------------------------------------------
bool CClanMarkTransfer::GetImageFileCRC( HANDLE hBmpFile, WORD* pBmpCRC16, DWORD* pdwNumberOfBytesRead, DWORD* pdwFileSizeHigh, DWORD* pdwFileSizeLow )
{
if( pdwFileSizeLow == NULL || pdwFileSizeHigh == NULL )
return false;
*pdwFileSizeLow = GetFileSize( hBmpFile, pdwFileSizeHigh );
if( *pdwFileSizeLow == INVALID_FILE_SIZE || *pdwFileSizeHigh != 0 )
{
_RPTF1( _CRT_ASSERT,"GetFileSize Error(%d)", GetLastError() );
g_itMGR.OpenMsgBox( "CClanMarkTransfer::GetImageFileCRC-GetFileSize Error" );
return false;
}
BYTE* bmp_buffer = new BYTE[*pdwFileSizeLow];
SetFilePointer( hBmpFile, 0, 0, FILE_BEGIN );
if( FALSE == ReadFile( hBmpFile, bmp_buffer, *pdwFileSizeLow, pdwNumberOfBytesRead, NULL ) )
{
g_itMGR.OpenMsgBox( "CClanMarkTransfer::GetImageFileCRC-ReadFile" );
_RPTF0( _CRT_ASSERT,"ReadFile Error:BmpFile" );
delete []bmp_buffer;
return false;
}
assert( *pdwFileSizeLow == *pdwNumberOfBytesRead );
*pBmpCRC16 = classCRC::DataCRC16( bmp_buffer, *pdwFileSizeLow );
delete []bmp_buffer;
return true;
}
//--------------------------------------------------------------------------------
/// 2. 임시 ZipFile로 실제 Bmp화일을 생성한다.
//--------------------------------------------------------------------------------
void CClanMarkTransfer::CreateImageFileFromZipFile( const char* TempZipFileName, int iClanID, DWORD* pdwNumberOfBytesWritten )
{
unsigned int server_id = CGame::GetInstance().GetSelectedServerID();
std::string strBmpFileName;
CClanMarkUserDefined::GetClanMarkFileName( CGame::GetInstance().GetSelectedServerID(), iClanID, strBmpFileName );
HANDLE hBmpFile = CreateFile( strBmpFileName.c_str(), GENERIC_WRITE, 0, 0,CREATE_ALWAYS ,FILE_ATTRIBUTE_NORMAL, NULL );
if( hBmpFile == INVALID_HANDLE_VALUE )
{
DWORD dwErr = GetLastError();
_RPTF2( _CRT_ASSERT,"CreateFile Error:%s %d", strBmpFileName.c_str(), dwErr );
g_itMGR.OpenMsgBox("CClanMarkTransfer::CreateImageFileFromZipFile-CreateFile Error");
return;
}
gzFile zfp;
if( (zfp = gzopen(TempZipFileName, "rb")) == NULL )
{
_RPTF1( _CRT_ASSERT,"gzopen error:%s", TempZipFileName );
g_itMGR.OpenMsgBox("CClanMarkTransfer::CreateImageFileFromZipFile-gzopen Error");
CloseHandle( hBmpFile );
return;
}
int read_size;
char buffer[256];
while( ( read_size = gzread( zfp, buffer, sizeof(buffer) )) > 0 )
{
if( FALSE == WriteFile( hBmpFile, buffer, read_size, pdwNumberOfBytesWritten, NULL ) )
{
_RPTF2( _CRT_ASSERT,"WriteFile Error:%s %d", strBmpFileName.c_str(), GetLastError() );
break;
}
}
if( read_size == -1 )
{
int lerrno;
_RPTF1( _CRT_ASSERT, "gzread error:%s", gzerror( zfp, &lerrno ) );
}
gzclose(zfp);
CloseHandle( hBmpFile );
}
/**
* @brief Add new option to list.
* @param [in] name Option's name.
* @param [in] defaultValue Option's initial and default value.
*/
int COptionsMgr::AddOption(LPCTSTR name, varprop::VariantValue defaultValue)
{
int retVal = OPT_OK;
COption tmpOption;
#ifdef _DEBUG
OptionsMap::const_iterator found = m_optionsMap.find(name);
if (found != m_optionsMap.end())
_RPTF1(_CRT_WARN, "Re-adding option: %s !", name);
#endif
retVal = tmpOption.Init(name, defaultValue);
if (retVal == OPT_OK)
m_optionsMap[name] = tmpOption;
else
_RPTF1(_CRT_ERROR, "Could not add option: %s!", name);
return retVal;
}
// 『今すぐすべての自動保存ファイルを削除する』
void CAutoSaveDlg::OnDeleteAllFileNow () {
// 本当にすべて削除してよいか確認
long lRet = 0;
CString strMsg;
VERIFY (strMsg.LoadString (IDS_ARE_YOU_SURE_TO_DELETE_ALL_AUTOSAVEFILE_NOW_REALLY));
lRet = AfxMessageBox (strMsg, MB_ICONQUESTION | MB_YESNOCANCEL);
if (lRet != IDYES) {
return;
}
// autosaveディレクトリ内の拡張子(*.skj)のファイルを全て削除する。
lRet = 0;
CString strFileName1;
CString strFileName2;
VERIFY (strFileName1.LoadString (IDS_AUTOSAVEFILENAME));
strFileName2 = m_strExeFilePath + strFileName1;
HANDLE hFind = NULL;
WIN32_FIND_DATA fd;
hFind = ::FindFirstFile ((LPCTSTR)strFileName2, &fd);
if (hFind != INVALID_HANDLE_VALUE) {
do {
if (_tcscmp (fd.cFileName, _T(".")) != 0 &&
_tcscmp (fd.cFileName, _T("..")) != 0) {
CString strFileName3;
CString strFileName4;
VERIFY (strFileName3.LoadString (IDS_AUTOSAVEDIRNAME));
strFileName4 = m_strExeFilePath + strFileName3 + fd.cFileName;
BOOL bRet = _tremove (strFileName4);
if (bRet == FALSE) {
_RPTF1 (_CRT_WARN, "AutoSaveFile Delete Failed. - \"%s\"\n", strFileName4);
}
else {
_RPTF1 (_CRT_WARN, "AutoSaveFile Delete Successful. - \"%s\"\n", strFileName4);
}
lRet++;
}
} while (::FindNextFile (hFind, &fd));
::FindClose (hFind);
}
}
bool CFileGroups::CreateAddFilesMenu(HWND hwndDlg, HMENU &hAddMenu,
const CFileGroups::filegroups_t &file_groups, UINT base) {
DestroyAddFilesMenu(hAddMenu);
if (file_groups.empty()) return false;
if ((hAddMenu = CreatePopupMenu()) == NULL) {
_RPTF1(_CRT_ERROR, "%s(...): CreatePopupMenu() returned NULL", __FUNCTION__);
return false;
}
AppendMenu(hAddMenu, MF_STRING, IDBROWSE, "Browse\x085");
const HMENU hGroupsMenu(CreatePopupMenu());
if (hGroupsMenu == NULL) {
DestroyMenu(hAddMenu);
_RPTF1(_CRT_ERROR, "%s(...): CreatePopupMenu() returned NULL", __FUNCTION__);
return false;
}
for (filegroups_t::const_iterator i = file_groups.begin(); i != file_groups.end(); ++i)
AppendMenu(hGroupsMenu, MF_STRING, base +
distance((filegroups_t::const_iterator)file_groups.begin(), i),
i->first.c_str());
AppendMenu(hAddMenu, MF_POPUP | MF_STRING,
reinterpret_cast<UINT>(hGroupsMenu), "Add group");
return true;
}
Parameter::Parameter(const ServiceParametersBase *pParent, DWORD dwIndex, DWORD dwType)
: m_pBase(pParent)
{
_ASSERTE(pParent != NULL); // Should never be a NULL pointer
_ASSERTE(dwIndex > 0); // Zero indexes are not allowed
_ASSERTE(dwType > REG_NONE); // Type code must be valid
m_pEntry = pParent->FindParameterEntry(dwIndex);
if(m_pEntry) {
// Check that the correct type code has been specified for the parameter
if(dwType != m_pEntry->Type) {
m_pEntry = NULL; // Reset the parameter pointer to NULL
_RPTF1(_CRT_ASSERT, "Incorrect registry value type code specified "
"for parameter with index of %d", dwIndex);
}
}
else _RPTF1(_CRT_ASSERT, "Unable to locate registry value with index %d", dwIndex);
}
/**
* @brief Get option value from list by name.
* @param [in] name Name of the option to get.
* @return Option's value as variant type.
*/
varprop::VariantValue COptionsMgr::Get(LPCTSTR name) const
{
varprop::VariantValue value;
OptionsMap::const_iterator found = m_optionsMap.find(name);
if (found != m_optionsMap.end())
{
value = found->second.Get();
}
else
{
_RPTF1(_CRT_ERROR, "Could not find option: %s!", name);
}
return value;
}
STDAPI DllCanUnloadNow(void)
{
if(g_DllRefCount > 0)
{
_RPTF1(_CRT_WARN, "RefCount=%d\n", g_DllRefCount);
for(int i=0; i<ENUM_CLASSES_LENGTH; i++)
{
if(g_references[i] > 0)
{
LPCTSTR lpszClass = GetClassName(i);
_RPTF2(_CRT_WARN, "%s has %d references\n", lpszClass, g_references[i]);
}
}
return S_FALSE;
}
return S_OK;
//return ((g_DllRefCount > 0) ? S_FALSE : S_OK);
}
/**
* @brief Set option value.
*
* Set new value for option. If automatic conversion is not allowed,
* type of value must match to type set when option was initialised.
* @param [in] value New value to set.
* @param [in] allowConversion Is automatic type conversion allowed?
* @sa COption::Init()
*/
int COption::Set(varprop::VariantValue value, bool allowConversion)
{
int retVal = OPT_OK;
// Check that type matches
varprop::VT_TYPE inType = value.GetType();
if (value.GetType() != m_value.GetType())
{
if (allowConversion)
{
if (ConvertType(value, m_value.GetType()))
return Set(value);
}
_RPTF1(_CRT_ERROR, "Wrong type for option: %s", m_strName.c_str());
return OPT_WRONG_TYPE;
}
switch (inType)
{
case varprop::VT_NULL:
retVal = OPT_UNKNOWN_TYPE;
break;
case varprop::VT_BOOL:
m_value.SetBool(value.GetBool());
break;
case varprop::VT_INT:
m_value.SetInt(value.GetInt());
break;
case varprop::VT_FLOAT:
m_value.SetFloat(value.GetFloat());
break;
case varprop::VT_STRING:
m_value.SetString(value.GetString());
break;
case varprop::VT_TIME:
m_value.SetTime(value.GetTime());
break;
default:
retVal = OPT_UNKNOWN_TYPE;
}
return retVal;
}
/**
* @brief Set new value for option.
* @param [in] name Option's name.
* @param [in] value Option's new value.
*/
int COptionsMgr::Set(LPCTSTR name, varprop::VariantValue value)
{
int retVal = OPT_OK;
OptionsMap::const_iterator found = m_optionsMap.find(name);
if (found != m_optionsMap.end())
{
// Allow automatic conversion so we don't bother callsites about this!
COption tmpOption = found->second;
retVal = tmpOption.Set(value, true);
if (retVal == OPT_OK)
m_optionsMap[name] = tmpOption;
}
else
{
_RPTF1(_CRT_ERROR, "Could not set option: %s", name);
retVal = OPT_NOTFOUND;
}
return retVal;
}
void CPrefKeyBindingsPage::TranslateHKToDS(CString& keyStr, WORD vk, WORD mod)
{
if (vk == 0) // no key?
return;
// start with a fresh string
int i;
keyStr.Empty();
// translate modifiers:
if (mod & HOTKEYF_CONTROL) keyStr += "CTRL+";
if (mod & HOTKEYF_ALT) keyStr += "ALT+";
if (mod & HOTKEYF_SHIFT) keyStr += "SHIFT+";
// translate m_vk:
if (isalnum(vk))
{
keyStr += (TCHAR)vk;
}
else
{
// use m_vk map
for (i = 0; i < vkNamesCount; i++)
{
if (VKNames[i].m_vk == vk)
break;
}
if (i >= vkNamesCount)
{
_RPTF1(_CRT_ERROR,
"Could not identify virtual key (m_vk=%d).", vk);
return;
}
keyStr += VKNames[i].m_name;
}
}
/**
* @brief Change default value for option.
*
* Set new value for option default value. If automatic conversion is not
* allowed, type of value must match to type set when option was initialised.
* @param [in] defaultValue New default value.
* @sa COption::Init()
*/
int COption::SetDefault(varprop::VariantValue defaultValue)
{
int retVal = OPT_OK;
// Check that type matches
varprop::VT_TYPE inType = defaultValue.GetType();
if (inType != m_valueDef.GetType())
{
_RPTF1(_CRT_ERROR, "Wrong type for option: %s!", m_strName.c_str());
return OPT_WRONG_TYPE;
}
switch (inType)
{
case varprop::VT_NULL:
retVal = OPT_UNKNOWN_TYPE;
break;
case varprop::VT_BOOL:
m_valueDef.SetBool(defaultValue.GetBool());
break;
case varprop::VT_INT:
m_valueDef.SetInt(defaultValue.GetInt());
break;
case varprop::VT_FLOAT:
m_valueDef.SetFloat(defaultValue.GetFloat());
break;
case varprop::VT_STRING:
m_valueDef.SetString(defaultValue.GetString());
break;
case varprop::VT_TIME:
m_valueDef.SetTime(defaultValue.GetTime());
break;
default:
retVal = OPT_UNKNOWN_TYPE;
}
return retVal;
}
//--------------------------------------------------------------------------------
/// 4. 임시저장 zip화일을 loading해서 서버로 보낸다.
//--------------------------------------------------------------------------------
bool CClanMarkTransfer::SendToServerTempZipFile( const char* TempZipFileName, WORD* pBumCRC16, DWORD* pdwFileSizeHigh, DWORD* pdwFileSizeLow )
{
HANDLE hTempZipFile = CreateFile( TempZipFileName, GENERIC_READ,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL );
if( hTempZipFile == INVALID_HANDLE_VALUE )
{
DWORD dwErr = GetLastError();
_RPTF1( _CRT_ASSERT,"CreateFile Error : Temporary ZipFile - Invalid_handle_value(%d)", dwErr );
g_itMGR.OpenMsgBox( "CClanMarkTranser::SendToServerTempZipFile - CreateFile Error" );
return false;
}
*pdwFileSizeLow = GetFileSize( hTempZipFile, pdwFileSizeHigh );
if( *pdwFileSizeLow == INVALID_FILE_SIZE )
{
DWORD dwErr = GetLastError();
if( *pdwFileSizeHigh == 0 )
{
_RPTF1( _CRT_ASSERT,"GetFileSize Error(%d)", dwErr );
}
else
{
if( dwErr != NO_ERROR )
{
_RPTF0( _CRT_ASSERT,"GetFileSize Error" );
}
}
g_itMGR.OpenMsgBox(" CClanMarkTransfer::SendToServerTempZipFile - GetFileSize Error");
}
else
{
_ASSERT( *pdwFileSizeHigh == 0 );///2^32 크기만 지원한다. 더큰 사이즈일경우는 무시한다.
if( *pdwFileSizeHigh == 0 )
{
BYTE* buffer = new BYTE[ *pdwFileSizeLow ];
DWORD NumberOfBytesReadZipFile;
if( ReadFile( hTempZipFile, buffer, *pdwFileSizeLow, &NumberOfBytesReadZipFile, NULL ) )
{
assert( *pdwFileSizeLow == NumberOfBytesReadZipFile );
assert( NumberOfBytesReadZipFile <= 1000 );
if( NumberOfBytesReadZipFile <= 1000 )
{
g_pNet->Send_cli_CLANMARK_SET( buffer, NumberOfBytesReadZipFile, *pBumCRC16 );
}
else
{
_RPTF0( _CRT_ASSERT,"Size is too big" );
g_itMGR.OpenMsgBox( CStr::Printf("%s %s",STR_CLANMARK_INVALID_SIZE,STR_CLANMARK_HELP_HOMEPAGE) );
}
}
else
{
_RPTF0( _CRT_ASSERT,"ReadFile Error:Temporary ZipFile" );
g_itMGR.OpenMsgBox( "ReadFile Error:Temporary ZipFile");
}
delete[] buffer;
}
}
CloseHandle( hTempZipFile );
return true;
}
//----------------------------------------------------------------------------------------------------/
///1. File이 있는지 체크
///2. 포맷이 맞는지 체크 --> 별도의 Class에서 확인한다
///3. File을 Load해서 temp.gz생성
///4. 임시저장 zip file을 Memory에 올린후 서버로 전송( size check - 1kbyte 이하이어야 한다 )
//----------------------------------------------------------------------------------------------------/
bool CClanMarkTransfer::RegisterMarkToServer( int iClanID, const char* pStrFileName )
{
assert( pStrFileName );
BYTE* pDATA = NULL;
int iSize = 0;
WORD bmp_crc16 = 0;
DWORD dwNumberOfBytesRead = 0;
DWORD dwFileSizeHigh = 0;
DWORD dwFileSizeLow = 0;
/// 0. BMP 파일 오픈
HANDLE hBmpFile = CreateFile( pStrFileName, GENERIC_READ,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL );
if( hBmpFile == INVALID_HANDLE_VALUE )
{
DWORD dwErr = GetLastError();
_RPTF1( _CRT_ASSERT,"CreateFile Error : Bmp File - Invalid_handle_value(%d)", dwErr );
g_itMGR.OpenMsgBox( CStr::Printf("%s %s",STR_CLANMARK_FILE_NOTFOUNT_REGISTER ,STR_CLANMARK_HELP_HOMEPAGE ) );
return false;
}
/// 1. 포맷이 맞는지 체크
if( CheckValidImage( hBmpFile ) == false )
{
//g_itMGR.OpenMsgBox( STR_CLANMARK_INVALID_FORMAT );
CloseHandle( hBmpFile );
return false;
}
/// 2. CRC를 구한다.
if( GetImageFileCRC( hBmpFile, &bmp_crc16, &dwNumberOfBytesRead, &dwFileSizeHigh, &dwFileSizeLow ) == false )
{
_RPTF0( _CRT_ASSERT,"GetImageFileCRC Error" );
CloseHandle( hBmpFile );
return false;
}
const char* TempZipFileName = "temp.gz";
/// 3. Memory에 로딩하면서 바로 임시 화일에 저장
if( WriteToZipFile( TempZipFileName, hBmpFile, &dwNumberOfBytesRead ) == false )
{
_RPTF0( _CRT_ASSERT,"WriteToZipFile Error" );
CloseHandle( hBmpFile );
return false;
}
CloseHandle( hBmpFile );
/// 4. 임시저장 zip화일을 loading해서 서버로 보낸다.
if( SendToServerTempZipFile( TempZipFileName, &bmp_crc16, &dwFileSizeHigh, &dwFileSizeLow ) == false )
return false;
return true;
}
void ResourceHandle::onRequestComplete(LPARAM lParam)
{
if (d->m_writing) {
DWORD bytesWritten;
InternetWriteFile(d->m_secondaryHandle,
d->m_formDataString + (d->m_formDataLength - d->m_bytesRemainingToWrite),
d->m_bytesRemainingToWrite,
&bytesWritten);
d->m_bytesRemainingToWrite -= bytesWritten;
if (!d->m_bytesRemainingToWrite) {
// End the request.
d->m_writing = false;
HttpEndRequest(d->m_secondaryHandle, 0, 0, (DWORD_PTR)d->m_jobId);
free(d->m_formDataString);
d->m_formDataString = 0;
}
return;
}
HINTERNET handle = (method() == "POST") ? d->m_secondaryHandle : d->m_resourceHandle;
BOOL ok = FALSE;
static const int bufferSize = 32768;
char buffer[bufferSize];
INTERNET_BUFFERSA buffers;
buffers.dwStructSize = sizeof(INTERNET_BUFFERSA);
buffers.lpvBuffer = buffer;
buffers.dwBufferLength = bufferSize;
bool receivedAnyData = false;
while ((ok = InternetReadFileExA(handle, &buffers, IRF_NO_WAIT, (DWORD_PTR)this)) && buffers.dwBufferLength) {
if (!hasReceivedResponse()) {
setHasReceivedResponse();
ResourceResponse response;
client()->didReceiveResponse(this, response);
}
client()->didReceiveData(this, buffer, buffers.dwBufferLength, 0);
buffers.dwBufferLength = bufferSize;
}
PlatformDataStruct platformData;
platformData.errorString = 0;
platformData.error = 0;
platformData.loaded = ok;
if (!ok) {
int error = GetLastError();
if (error == ERROR_IO_PENDING)
return;
DWORD errorStringChars = 0;
if (!InternetGetLastResponseInfo(&platformData.error, 0, &errorStringChars)) {
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
platformData.errorString = new TCHAR[errorStringChars];
InternetGetLastResponseInfo(&platformData.error, platformData.errorString, &errorStringChars);
}
}
_RPTF1(_CRT_WARN, "Load error: %i\n", error);
}
if (d->m_secondaryHandle)
InternetCloseHandle(d->m_secondaryHandle);
InternetCloseHandle(d->m_resourceHandle);
client()->didFinishLoading(this);
delete this;
}
void CPrefKeyBindingsPage::TranslateDSToHK(CString keyStr, WORD& vk, WORD& mod)
{
mod = 0;
vk = 0;
if (keyStr.IsEmpty())
return;
// Build the modifier by cycling through the + symbols.
int lastPlusPos = 0;
int plusPos = keyStr.Find('+', lastPlusPos);
while (plusPos != -1)
{
CString str = keyStr.Mid(lastPlusPos, plusPos - lastPlusPos);
str.MakeUpper();
if (str == "CTRL")
mod |= HOTKEYF_CONTROL;
else if (str == "ALT")
mod |= HOTKEYF_ALT;
else if (str == "SHIFT")
mod |= HOTKEYF_SHIFT;
lastPlusPos = plusPos + 1;
plusPos = keyStr.Find('+', lastPlusPos);
}
// Now, build the virtual key code.
CString vkStr = keyStr.Mid(lastPlusPos);
// Potentially a letter or number.
if (vkStr.GetLength() == 1)
{
if (isalnum(vkStr[0]))
vk = (WORD)vkStr[0];
}
// Translated yet?
if (vk == 0)
{
// use m_vk map
int i;
for (i = 0; i < vkNamesCount; i++)
{
if (vkStr.CompareNoCase(VKNames[i].m_name) == 0)
break;
}
if (i >= vkNamesCount)
{
_RPTF1(_CRT_ERROR,
"Could not identify virtual key (m_vk=%d).", vk);
return;
}
vk = VKNames[i].m_vk;
// Is it extended?
mod |= (VKNames[i].m_extended ? HOTKEYF_EXT : 0);
// UINT scanCode = MapVirtualKey(vk, 0);
// scanCode = scanCode;
}
}
/**
* @brief Compare two files (as earlier specified).
* @return DIFFCODE as a result of compare.
*/
int DiffUtils::diffutils_compare_files()
{
int bin_flag = 0;
int bin_file = 0; // bitmap for binary files
// Do the actual comparison (generating a change script)
struct change *script = NULL;
bool success = Diff2Files(&script, 0, &bin_flag, false, &bin_file);
if (!success)
{
return DIFFCODE::FILE | DIFFCODE::TEXT | DIFFCODE::CMPERR;
}
UINT code = DIFFCODE::FILE | DIFFCODE::TEXT | DIFFCODE::SAME;
// make sure to start counting diffs at 0
// (usually it is -1 at this point, for unknown)
m_ndiffs = 0;
m_ntrivialdiffs = 0;
if (script)
{
struct change *next = script;
struct change *thisob = 0, *end = 0;
String asLwrCaseExt;
String LowerCaseExt = CA2T(m_inf[0].name);
int PosOfDot = LowerCaseExt.rfind('.');
if (PosOfDot != -1)
{
LowerCaseExt.erase(0, PosOfDot + 1);
CharLower(&*LowerCaseExt.begin());
asLwrCaseExt = LowerCaseExt;
}
while (next)
{
/* Find a set of changes that belong together. */
thisob = next;
end = find_change(next);
/* Disconnect them from the rest of the changes,
making them a hunk, and remember the rest for next iteration. */
next = end->link;
end->link = 0;
#ifdef _DEBUG
debug_script(thisob);
#endif
{
/* Determine range of line numbers involved in each file. */
int first0 = 0, last0 = 0, first1 = 0, last1 = 0, deletes = 0, inserts = 0;
analyze_hunk(thisob, &first0, &last0, &first1, &last1, &deletes, &inserts);
if (deletes || inserts || thisob->trivial)
{
/* Print the lines that the first file has. */
int trans_a0 = 0, trans_b0 = 0, trans_a1 = 0, trans_b1 = 0;
translate_range(&m_inf[0], first0, last0, &trans_a0, &trans_b0);
translate_range(&m_inf[1], first1, last1, &trans_a1, &trans_b1);
//Determine quantity of lines in this block for both sides
int QtyLinesLeft = (trans_b0 - trans_a0);
int QtyLinesRight = (trans_b1 - trans_a1);
if(m_pOptions->m_filterCommentsLines || m_pOptions->m_bIgnoreBlankLines || m_pOptions->m_bIgnoreCase)
{
OP_TYPE op = OP_NONE;
if (!deletes && !inserts)
op = OP_TRIVIAL;
else
op = OP_DIFF;
DIFFOPTIONS options = {0};
options.nIgnoreWhitespace = m_pOptions->m_ignoreWhitespace;
options.bIgnoreBlankLines = m_pOptions->m_bIgnoreBlankLines;
options.bFilterCommentsLines = m_pOptions->m_filterCommentsLines;
options.bIgnoreCase = m_pOptions->m_bIgnoreCase;
options.bIgnoreEol = m_pOptions->m_bIgnoreEOLDifference;
m_pDiffWrapper->SetOptions(&options);
m_pDiffWrapper->PostFilter(thisob->line0, QtyLinesLeft+1, thisob->line1, QtyLinesRight+1, op, *m_FilterCommentsManager, asLwrCaseExt.c_str());
if(op == OP_TRIVIAL)
{
thisob->trivial = 1;
}
}
// Match lines against regular expression filters
// Our strategy is that every line in both sides must
// match regexp before we mark difference as ignored.
if(m_pFilterList && m_pFilterList->HasRegExps())
{
bool match2 = false;
bool match1 = RegExpFilter(thisob->line0, thisob->line0 + QtyLinesLeft, 0);
if (match1)
match2 = RegExpFilter(thisob->line1, thisob->line1 + QtyLinesRight, 1);
if (match1 && match2)
thisob->trivial = 1;
}
}
/* Reconnect the script so it will all be freed properly. */
end->link = next;
}
}
}
// Free change script (which we don't want)
if (script != NULL)
{
struct change *p, *e;
for (e = script; e; e = p)
{
if (!e->trivial)
++m_ndiffs;
else
++m_ntrivialdiffs;
p = e->link;
free(e);
}
if (m_ndiffs > 0)
code = code & ~DIFFCODE::SAME | DIFFCODE::DIFF;
}
// diff_2_files set bin_flag to -1 if different binary
// diff_2_files set bin_flag to +1 if same binary
if (bin_flag != 0)
{
// Clear text-flag, set binary flag
// We don't know diff counts for binary files
code = code & ~DIFFCODE::TEXT;
switch (bin_file)
{
case BINFILE_SIDE1:
code |= DIFFCODE::BINSIDE1;
break;
case BINFILE_SIDE2:
code |= DIFFCODE::BINSIDE2;
break;
case BINFILE_SIDE1 | BINFILE_SIDE2:
code |= DIFFCODE::BIN;
break;
default:
_RPTF1(_CRT_ERROR, "Invalid bin_file value: %d", bin_file);
break;
}
m_ndiffs = CDiffContext::DIFFS_UNKNOWN;
}
if (bin_flag < 0)
{
// Clear same-flag, set diff-flag
code = code & ~DIFFCODE::SAME | DIFFCODE::DIFF;
}
return code;
}
