void CSerialConfig::OnRestore232()
{
CString sTemp;
char cTemp[100];
bGet232Serial = FALSE;
if(!CLIENT_GetDevConfig(m_Device->LoginID, DEV_GET_RS232CFG, 0, &rs232cfg, sizeof(NET_DEV_RS232CFG), &dwReturned, CONFIG_WAITTIME))
{
AfxMessageBox(ConvertString("232error"));
}
else
{
m_baud232sel.SetCurSel(rs232cfg.dwBaudRate);
m_databit232sel.SetCurSel(rs232cfg.byDataBit);
m_stopbit232sel.SetCurSel(rs232cfg.byStopBit);
m_checkbit232sel.SetCurSel(rs232cfg.byParity);
m_flow232sel.SetCurSel(rs232cfg.byFlowcontrol);
m_operatemodesel.SetCurSel(rs232cfg.dwWorkMode);
if(rs232cfg.dwWorkMode == 0)
{
m_PPPmodesel.SetCurSel(rs232cfg.struPPPConfig.byPPPMode);
m_dbmodesel.SetCurSel(rs232cfg.struPPPConfig.byRedialMode);
m_bDialBack = rs232cfg.struPPPConfig.byRedial;
m_bEncrypt = rs232cfg.struPPPConfig.byDataEncrypt;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sUsername, NAME_LEN);
m_username.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_userpsw.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_verifypsw.Format("%s", cTemp);
m_remoteIP = rs232cfg.struPPPConfig.sRemoteIP;
m_localIP = rs232cfg.struPPPConfig.sLocalIP;
m_IPmask = rs232cfg.struPPPConfig.sLocalIPMask;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sTelephoneNumber, PHONENUMBER_LEN);
m_phoneNo.Format("%s", cTemp);
}
else if(rs232cfg.dwWorkMode == 1)
{
SwitchMode(FALSE);
}
else if(rs232cfg.dwWorkMode == 2)
{
SwitchMode(FALSE);
}
bGet232Serial = TRUE;
GetDlgItem(IDC_APPLY232)->EnableWindow(TRUE);
}
UpdateData(FALSE);
}
void NNTPServerHandler::HandleCommand(const std::deque<std::string> & command)
{
auto cmd = command[0];
std::transform(cmd.begin(), cmd.end(), cmd.begin(),
[](unsigned char ch) { return std::toupper(ch); });
std::size_t cmdlen = command.size();
std::cerr << "handle command [" << cmd << "] " << (int) cmdlen << std::endl;
if (cmd == "QUIT") {
Quit();
return;
} else if (cmd == "MODE" ) {
if(cmdlen == 1) {
// set mode
SwitchMode(command[1]);
} else if(cmdlen) {
// too many arguments
} else {
// get mode
}
} else {
// unknown command
QueueLine("500 Unknown Command");
}
}
void OptionWindow::Think(float dt)
{
GUIWindow::Think(dt);
CenterLocation(ENGINEMANAGER.GetScreenDimension(), 0, 0);
SwitchMode();
if(NULL != current) current->Think(dt);
}
void CWeaponMagazinedWGrenade::net_Import (NET_Packet& P)
{
bool NewMode = FALSE;
NewMode = !!P.r_u8();
if (NewMode != m_bGrenadeMode)
SwitchMode ();
inherited::net_Import (P);
}
inline FX_BOOL CFDE_CSSSyntaxParser::RestoreMode() {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL) {
return FALSE;
}
SwitchMode(*pMode);
m_ModeStack.Pop();
return TRUE;
}
void GetPatch(void)
{
int xoff,yoff,i,k,x,y,PNum;
long lll,l;
x=(320-Tx)/2; y=(200-Ty)/2;
SwitchMode(1);
DoomPalette();
if (WinPal==2) Window(0xa000,0,x,y,Tx,Ty);
for (i=0;i<Tn;i++) {
_read(fileno(f),&xoff,2); _read(fileno(f),&yoff,2);
_read(fileno(f),&PNum,2); l=ftell(f);
Entry=E; Entry+=PName[PNum].Num;
lll=Entry->RStart;
TakePic(lll,x,y,xoff,yoff,x+Tx-1,y+Ty-1,0xa000,0); fseek(f,l,0);
_read(fileno(f),&k,2); _read(fileno(f),&k,2);
}
getch();
SwitchMode(0); ScreenAufbau(); DisplayPatch();
}
void CSerialConfig::OnSelchangeOperatemodesel()
{
char cTemp[100];
if (!UpdateData(TRUE))
{
return;
}
int OperateSel = m_operatemodesel.GetCurSel();
if(OperateSel == 0)
{
SwitchMode(TRUE);
m_PPPmodesel.SetCurSel(rs232cfg.struPPPConfig.byPPPMode);
m_dbmodesel.SetCurSel(rs232cfg.struPPPConfig.byRedialMode);
m_bDialBack = rs232cfg.struPPPConfig.byRedial;
m_bEncrypt = rs232cfg.struPPPConfig.byDataEncrypt;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sUsername, NAME_LEN);
m_username.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_userpsw.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_verifypsw.Format("%s", cTemp);
m_remoteIP = rs232cfg.struPPPConfig.sRemoteIP;
m_localIP = rs232cfg.struPPPConfig.sLocalIP;
m_IPmask = rs232cfg.struPPPConfig.sLocalIPMask;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sTelephoneNumber, PHONENUMBER_LEN);
m_phoneNo.Format("%s", cTemp);
}
else if(OperateSel == 1)
{
SwitchMode(FALSE);
}
else if(OperateSel == 2)
{
SwitchMode(FALSE);
}
}
/**
* @brief Switches AutoZoom state
*
* @param vswitch Switch value:
* - -1 - switch current state
* - 0 - disable
* - 1 - enable
*/
void MapWindow::Zoom::EventAutoZoom(int vswitch)
{
bool lastAutoZoom = _autoZoom;
if(vswitch== -1)
_autoZoom = !_autoZoom;
else
_autoZoom = vswitch;
if(_autoZoom)
// backup current zoom
_modeScale[SCALE_AUTO_ZOOM] = _modeScale[SCALE_CRUISE];
if(_autoZoom != lastAutoZoom)
SwitchMode();
}
bool ZipFile::LoadList()
{
ClearList();
if(!SwitchMode(ZipFile::OPEN))
return false;
int ret = unzGoToFirstFile(uzFile);
if(ret != UNZ_OK)
return false;
char filename[1024];
unz_file_info cur_file_info;
RealArchiveItemCount = 0;
do
{
if(unzGetCurrentFileInfo(uzFile, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) == UNZ_OK)
{
bool isDir = false;
if(filename[strlen(filename)-1] == '/')
{
isDir = true;
filename[strlen(filename)-1] = '\0';
}
int strlength = strlen(filename)+1;
ArchiveFileStruct * CurArcFile = new ArchiveFileStruct;
CurArcFile->filename = new char[strlength];
strcpy(CurArcFile->filename, filename);
CurArcFile->length = cur_file_info.uncompressed_size;
CurArcFile->comp_length = cur_file_info.compressed_size;
CurArcFile->isdir = isDir;
CurArcFile->fileindex = RealArchiveItemCount;
CurArcFile->ModTime = (u64) cur_file_info.dosDate;
CurArcFile->archiveType = ZIP;
ZipStructure.push_back(CurArcFile);
}
++RealArchiveItemCount;
}
while(unzGoToNextFile(uzFile) == UNZ_OK);
PathControl();
return true;
}
//--------------------------------------------------------------------------------
void GameWorld::Run()
{
mRun = true;
while (mRun)
{
System::Log::Flush();
EasySteam::Interface::Run();
SetRendering(clock());
uint32_t delta = uint32_t(mTimer.elapsed() * 1000);
mTimer.restart();
{
boost::mutex::scoped_lock _(mInputGuard);
Overlay::TheSystem->MouseMove(mX,mY,mZ);
for(auto itor = mButtons.begin(), end = mButtons.end(); itor != end; ++itor)
{
if(itor->mouse)
{
if(!mMode)
Overlay::TheSystem->InjectMouse(itor->key,itor->pressed);
}
else
{
if(mCurrentState && mCurrentState->IsSwitchingAllowed())
{
if(itor->key == DIK_F3 && itor->pressed == false)
{
SwitchMode();
}
}
if(!mMode)
Overlay::TheSystem->Inject(itor->key, itor->pressed);
}
}
mButtons.clear();
}
TheMassiveMessageMgr->Update();
if(mCurrentState)
mCurrentState->OnUpdate(delta);
Wait(0);
}
}
void CWeaponMagazinedWGrenade::OnStateSwitch(u32 S)
{
switch (S)
{
case eSwitch:
{
if( !SwitchMode() ){
SwitchState(eIdle);
return;
}
}break;
}
inherited::OnStateSwitch(S);
UpdateGrenadeVisibility(!!iAmmoElapsed || S == eReload);
}
void CWeaponMagazinedWGrenade::load(IReader &input_packet)
{
inherited::load (input_packet);
bool b;
load_data (b, input_packet);
if(b!=m_bGrenadeMode)
SwitchMode ();
u32 sz;
load_data (sz, input_packet);
CCartridge l_cartridge;
l_cartridge.Load (*m_ammoTypes2[m_ammoType2], u8(m_ammoType2));
while (sz > m_magazine2.size())
m_magazine2.push_back(l_cartridge);
}
/**
* @brief Resets Map Zoom to initial values
*/
void MapWindow::Zoom::Reset()
{
switch(AircraftCategory) {
case umGlider:
case umGAaircraft:
_modeScale[SCALE_CRUISE] = SCALE_CRUISE_INIT;
_modeScale[SCALE_CIRCLING] = SCALE_CIRCLING_INIT;
_modeScale[SCALE_PANORAMA] = SCALE_PANORAMA_INIT;
break;
case umParaglider:
case umCar:
_modeScale[SCALE_CRUISE] = GetPgCruiseZoomInitValue(PGCruiseZoom);
_modeScale[SCALE_CIRCLING] = GetPgClimbZoomInitValue(PGClimbZoom);
_modeScale[SCALE_PANORAMA] = SCALE_PG_PANORAMA_INIT;
break;
default:
// make it an evident problem
_modeScale[SCALE_CRUISE] = _modeScale[SCALE_CIRCLING] = _modeScale[SCALE_PANORAMA] = SCALE_INVALID_INIT;
break;
}
// Correct _modeScale[] values for internal use
// You have to give values in user units (km,mi, what is selected), we need to divide it by 1.4
// because of the size of the mapscale symbol
_modeScale[SCALE_CRUISE] /= 1.4;
_modeScale[SCALE_CIRCLING] /= 1.4;
_modeScale[SCALE_PANORAMA] /= 1.4;
if(_autoZoom)
_modeScale[SCALE_AUTO_ZOOM] = _modeScale[SCALE_CRUISE];
_requestedScale = &_modeScale[SCALE_CRUISE];
_scale = *_requestedScale;
_scaleOverDistanceModify = *_requestedScale / DISTANCEMODIFY;
_realscale = *_requestedScale/DISTANCEMODIFY/1000;
_inited = true;
SwitchMode();
}
bool ZipFile::SeekFile(int ind)
{
if(ind < 0 || ind >= (int) ZipStructure.size())
return false;
if(!SwitchMode(ZipFile::OPEN))
return false;
int ret = unzGoToFirstFile(uzFile);
if(ret != UNZ_OK)
return false;
while(ind > 0)
{
if(unzGoToNextFile(uzFile) != UNZ_OK)
return false;
--ind;
}
return true;
}
/**
* @brief Resets Map Zoom to initial values
*/
void MapWindow::Zoom::Reset()
{
switch(AircraftCategory) {
case umGlider:
case umGAaircraft:
case umCar:
_modeScale[SCALE_CRUISE] = SCALE_CRUISE_INIT;
_modeScale[SCALE_CIRCLING] = SCALE_CIRCLING_INIT;
_modeScale[SCALE_PANORAMA] = SCALE_PANORAMA_INIT;
break;
case umParaglider:
switch(PGCruiseZoom) { // 091108
case 0:
_modeScale[SCALE_CRUISE] = 0.10; // 088
break;
case 1:
_modeScale[SCALE_CRUISE] = 0.12; // 117
break;
case 2:
_modeScale[SCALE_CRUISE] = 0.14; // 205
break;
case 3:
_modeScale[SCALE_CRUISE] = 0.16; // 293
break;
case 4:
_modeScale[SCALE_CRUISE] = 0.18;
break;
case 5:
_modeScale[SCALE_CRUISE] = 0.20;
break;
case 6:
_modeScale[SCALE_CRUISE] = 0.23;
break;
case 7:
_modeScale[SCALE_CRUISE] = 0.25;
break;
case 8:
default:
_modeScale[SCALE_CRUISE] = 0.3;
break;
}
switch(PGClimbZoom) {
case 0:
_modeScale[SCALE_CIRCLING] = 0.05;
break;
case 1:
_modeScale[SCALE_CIRCLING] = 0.07;
break;
case 2:
_modeScale[SCALE_CIRCLING] = 0.09;
break;
case 3:
_modeScale[SCALE_CIRCLING] = 0.14;
break;
case 4:
default:
_modeScale[SCALE_CIRCLING] = 0.03;
break;
}
_modeScale[SCALE_PANORAMA] = SCALE_PG_PANORAMA_INIT;
break;
default:
// make it an evident problem
_modeScale[SCALE_CRUISE] = _modeScale[SCALE_CIRCLING] = _modeScale[SCALE_PANORAMA] = SCALE_INVALID_INIT;
break;
}
if(_autoZoom)
_modeScale[SCALE_AUTO_ZOOM] = _modeScale[SCALE_CRUISE];
_requestedScale = &_modeScale[SCALE_CRUISE];
_scale = *_requestedScale;
_scaleOverDistanceModify = *_requestedScale / DISTANCEMODIFY;
_inited = true;
SwitchMode();
}
BOOL CSerialConfig::OnInitDialog()
{
CDialog::OnInitDialog();
g_SetWndStaticText(this);
CRect rc(0, 0, 0, 0);
GetParent()->GetClientRect(&rc);
((CTabCtrl*)GetParent())->AdjustRect(FALSE, &rc);
MoveWindow(&rc);
//初始化界面
m_checkbit232sel.InsertString(0, ConvertString(MSG_SERIALCFG_NONE));
m_checkbit232sel.InsertString(1, ConvertString(MSG_SERIALCFG_ODD));
m_checkbit232sel.InsertString(2, ConvertString(MSG_SERIALCFG_EVEN));
m_flow232sel.InsertString(0, MSG_SERIALCFG_NOCTRL);
m_flow232sel.InsertString(1, MSG_SERIALCFG_SCTRL);
m_flow232sel.InsertString(2, MSG_SERIALCFG_HCTRL);
m_operatemodesel.InsertString(0, MSG_SERIALCFG_PPPOE);
m_operatemodesel.InsertString(1, MSG_SERIALCFG_CONSOLE);
m_operatemodesel.InsertString(2, MSG_SERIALCFG_TRANSPARENT);
m_PPPmodesel.InsertString(0, MSG_SERIALCFG_ACTIVE);
m_PPPmodesel.InsertString(1, MSG_SERIALCFG_PASSIVE);
m_dbmodesel.InsertString(0, MSG_SERIALCFG_SPECIFIED);
m_dbmodesel.InsertString(1, MSG_SERIALCFG_DEFAULT);
m_checkbit485sel.InsertString(0, MSG_SERIALCFG_NONE);
m_checkbit485sel.InsertString(1, MSG_SERIALCFG_ODD);
m_checkbit485sel.InsertString(2, MSG_SERIALCFG_EVEN);
m_flow485sel.InsertString(0, MSG_SERIALCFG_NOCTRL);
m_flow485sel.InsertString(1, MSG_SERIALCFG_SCTRL);
m_flow485sel.InsertString(2, MSG_SERIALCFG_HCTRL);
CString sTemp;
char cTemp[100];
m_nChanSel = 0;
m_nCopyChanNum = -1;
m_copychlsel.ResetContent();
m_chlnosel.ResetContent();
sTemp.Format(ConvertString(_T(NAME_SERIALCFG_ALLCHANNEL)));
m_copychlsel.AddString(sTemp);
bSetSerial232 = FALSE;
bGet232Serial = FALSE;
for(int i=0; i < m_Device->Info.byChanNum; i++)
{
bGet485Serial[i] = FALSE;
bSetSerial485[i] = FALSE;
sTemp.Format("%d", (i+1));
sTemp = ConvertString(NAME_SERIALCFG_CHANNEL) + sTemp;
m_chlnosel.AddString(sTemp);
m_copychlsel.AddString(sTemp);
m_nChanNum = i;
//if(m_bConnectServer)
//{
if(!CLIENT_GetDevConfig(m_Device->LoginID, DEV_GET_DECODERCFG, m_nChanNum,&decodercfg[i], sizeof(NET_DEV_DECODERCFG), &dwReturned, CONFIG_WAITTIME))
{
// sTemp.Format("获取通道%d 485串口参数失败!: DEV_GET_DECODERCFG = %d \n", m_nChanNum, NET_DVR_GetLastError());
AfxMessageBox(ConvertString("485 error"));
}
else
{
bGet485Serial[i] = TRUE;
}
// }
}
if(bGet485Serial[m_nChanSel])
{
m_nChanNum = m_nChanSel;
m_baud485sel.SetCurSel(GetBaudRateSel(decodercfg[m_nChanSel].dwBaudRate));
m_databit485sel.SetCurSel(GetDatabitSel(decodercfg[m_nChanSel].byDataBit));
m_stopbit485sel.SetCurSel(decodercfg[m_nChanSel].byStopBit);
m_checkbit485sel.SetCurSel(decodercfg[m_nChanSel].byParity);
m_flow485sel.SetCurSel(decodercfg[m_nChanSel].byFlowcontrol);
m_decodetypesel.SetCurSel(decodercfg[m_nChanSel].wDecoderType);
m_decodeAddress = (BYTE)decodercfg[m_nChanSel].wDecoderAddress;
GetDlgItem(IDC_APPLY232)->EnableWindow(TRUE);
GetDlgItem(IDC_COPYOK)->EnableWindow(TRUE);
GetDlgItem(IDC_APPLY485)->EnableWindow(TRUE);
}
// if(m_bConnectServer)
// {
if(!CLIENT_GetDevConfig(m_Device->LoginID, DEV_GET_RS232CFG, 0, &rs232cfg, sizeof(NET_DEV_RS232CFG), &dwReturned, CONFIG_WAITTIME))
{
//sTemp.Format("获取232串口参数失败!: NET_DVR_GET_RS232CFG = %d \n", NET_DVR_GetLastError());
AfxMessageBox(ConvertString("232error"));
}
else
{
m_baud232sel.SetCurSel(GetBaudRateSel(rs232cfg.dwBaudRate));
m_databit232sel.SetCurSel(GetDatabitSel(rs232cfg.byDataBit));
m_stopbit232sel.SetCurSel(rs232cfg.byStopBit);
m_checkbit232sel.SetCurSel(rs232cfg.byParity);
m_flow232sel.SetCurSel(rs232cfg.byFlowcontrol);
m_operatemodesel.SetCurSel(rs232cfg.dwWorkMode);
if(rs232cfg.dwWorkMode == 0)
{
m_PPPmodesel.SetCurSel(rs232cfg.struPPPConfig.byPPPMode);
m_dbmodesel.SetCurSel(rs232cfg.struPPPConfig.byRedialMode);
m_bDialBack = rs232cfg.struPPPConfig.byRedial;
m_bEncrypt = rs232cfg.struPPPConfig.byDataEncrypt;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sUsername, NAME_LEN);
m_username.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_userpsw.Format("%s", cTemp);
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sPassword, PASSWD_LEN);
m_verifypsw.Format("%s", cTemp);
m_remoteIP = rs232cfg.struPPPConfig.sRemoteIP;
m_localIP = rs232cfg.struPPPConfig.sLocalIP;
m_IPmask = rs232cfg.struPPPConfig.sLocalIPMask;
ZeroMemory(cTemp, 100);
memcpy(cTemp, rs232cfg.struPPPConfig.sTelephoneNumber, PHONENUMBER_LEN);
m_phoneNo.Format("%s", cTemp);
}
else if(rs232cfg.dwWorkMode == 1)
{
SwitchMode(FALSE);
}
else if(rs232cfg.dwWorkMode == 2)
{
SwitchMode(FALSE);
}
bGet232Serial = TRUE;
GetDlgItem(IDC_APPLY232)->EnableWindow(TRUE);
}
// }
m_chlnosel.SetCurSel(m_nChanSel);
m_copychlsel.SetCurSel(m_nChanSel);
// pSerialCFG = this;
UpdateData(FALSE);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
int ZipFile::ExtractAll(const char *dest)
{
if(!SwitchMode(OPEN))
return -1;
bool Stop = false;
u32 blocksize = 1024*70;
void *buffer = malloc(blocksize);
if(!buffer)
return -5;
char writepath[1024];
char filename[1024];
memset(writepath, 0, sizeof(writepath));
memset(filename, 0, sizeof(filename));
unz_file_info cur_file_info;
int ret = unzGoToFirstFile(uzFile);
if(ret != UNZ_OK)
{
free(buffer);
return -6;
}
while(!Stop)
{
if(unzGetCurrentFileInfo(uzFile, &cur_file_info, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
{
Stop = true;
}
if(!Stop && filename[strlen(filename)-1] != '/')
{
u64 uncompressed_size = cur_file_info.uncompressed_size;
u64 done = 0;
char *pointer = NULL;
ret = unzOpenCurrentFile(uzFile);
snprintf(writepath, sizeof(writepath), "%s/%s", dest, filename);
pointer = strrchr(writepath, '/');
int position = pointer-writepath+2;
char temppath[strlen(writepath)];
snprintf(temppath, position, "%s", writepath);
CreateSubfolder(temppath);
if(ret == UNZ_OK)
{
FILE *pfile = fopen(writepath, "wb");
if(!pfile)
{
free(buffer);
fclose(pfile);
unzCloseCurrentFile(uzFile);
return -8;
}
do
{
if(uncompressed_size - done < blocksize)
blocksize = uncompressed_size - done;
ret = unzReadCurrentFile(uzFile, buffer, blocksize);
if(ret == 0)
break;
fwrite(buffer, 1, blocksize, pfile);
done += ret;
} while(done < uncompressed_size);
fclose(pfile);
unzCloseCurrentFile(uzFile);
}
}
if(unzGoToNextFile(uzFile) != UNZ_OK)
{
Stop = true;
}
}
free(buffer);
buffer = NULL;
return 1;
}
int ZipFile::ExtractFile(int ind, const char *dest, bool withpath)
{
if(!SwitchMode(OPEN))
return -1;
if(!SeekFile(ind) && ind < RealArchiveItemCount)
return -1;
ArchiveFileStruct * CurArcFile = GetFileStruct(ind);
u32 done = 0;
char * RealFilename = strrchr(CurArcFile->filename, '/');
if(RealFilename)
RealFilename += 1;
else
RealFilename = CurArcFile->filename;
char writepath[1024];
if(withpath)
snprintf(writepath, sizeof(writepath), "%s/%s", dest, CurArcFile->filename);
else
snprintf(writepath, sizeof(writepath), "%s/%s", dest, RealFilename);
u32 filesize = CurArcFile->length;
if(CurArcFile->isdir)
{
strncat(writepath, "/", sizeof(writepath));
CreateSubfolder(writepath);
return 1;
}
int ret = unzOpenCurrentFile(uzFile);
if(ret != UNZ_OK)
return -2;
char * temppath = strdup(writepath);
char * pointer = strrchr(temppath, '/');
if(pointer)
{
pointer += 1;
pointer[0] = '\0';
}
CreateSubfolder(temppath);
free(temppath);
temppath = NULL;
u32 blocksize = 1024*50;
void *buffer = malloc(blocksize);
FILE *pfile = fopen(writepath, "wb");
if(!pfile)
{
unzCloseCurrentFile(uzFile);
free(buffer);
fclose(pfile);
WindowPrompt(("Could not extract file:"), CurArcFile->filename, "OK", NULL);
return -3;
}
do
{
if(filesize - done < blocksize)
blocksize = filesize - done;
ret = unzReadCurrentFile(uzFile, buffer, blocksize);
if(ret < 0)
{
free(buffer);
fclose(pfile);
unzCloseCurrentFile(uzFile);
return -4;
}
fwrite(buffer, 1, blocksize, pfile);
done += ret;
} while(done < filesize);
fclose(pfile);
unzCloseCurrentFile(uzFile);
free(buffer);
return 1;
}
int ZipFile::AddFile(const char *filepath, const char *destfilepath, int compresslevel, bool RefreshList)
{
if(!destfilepath)
return -1;
if(OpenMode == ZipFile::OPEN)
{
if(!SwitchMode(ZipFile::APPEND))
return -2;
}
else if(!SwitchMode(OpenMode))
return -3;
zip_fileinfo file_info;
memset(&file_info, 0, sizeof(zip_fileinfo));
if(destfilepath[strlen(destfilepath)-1] == '/')
{
int ret = zipOpenNewFileInZip(zFile, destfilepath, &file_info, NULL, 0, NULL, 0, NULL, Z_DEFLATED, compresslevel);
if(ret != ZIP_OK)
return -4;
zipCloseFileInZip(zFile);
return 1;
}
if(!filepath)
return -5;
struct stat filestat;
memset(&filestat, 0, sizeof(struct stat));
stat(filepath, &filestat);
u64 filesize = filestat.st_size;
//! Set up the modified time
struct tm * ModTime = localtime(&filestat.st_mtime);
file_info.tmz_date.tm_sec = ModTime->tm_sec;
file_info.tmz_date.tm_min = ModTime->tm_min;
file_info.tmz_date.tm_hour = ModTime->tm_hour;
file_info.tmz_date.tm_mday = ModTime->tm_mday;
file_info.tmz_date.tm_mon = ModTime->tm_mon;
file_info.tmz_date.tm_year = ModTime->tm_year;
FILE * sourceFile = fopen(filepath, "rb");
if(!sourceFile)
return -6;
u32 blocksize = 1024*70;
u8 * buffer = (u8 *) malloc(blocksize);
if(!buffer)
{
fclose(sourceFile);
return -7;
}
int ret = zipOpenNewFileInZip(zFile, destfilepath, &file_info, NULL, 0, NULL, 0, NULL, Z_DEFLATED, compresslevel);
if(ret != ZIP_OK)
{
free(buffer);
fclose(sourceFile);
return -8;
}
const char * RealFilename = strrchr(destfilepath, '/');
if(RealFilename)
RealFilename += 1;
else
RealFilename = destfilepath;
int res = 0;
u64 done = 0;
while(done < filesize)
{
if(filesize - done < blocksize)
blocksize = filesize - done;
ret = fread(buffer, 1, blocksize, sourceFile);
if(ret <= 0)
break; //done
res = zipWriteInFileInZip(zFile, buffer, ret);
if(res != ZIP_OK)
break;
done += ret;
}
free(buffer);
fclose(sourceFile);
zipCloseFileInZip(zFile);
if(RefreshList)
LoadList();
//! File is now created the next files need to be appended
OpenMode = ZipFile::APPEND;
return (done == filesize) ? 1 : -12;
}
FDE_CSSSYNTAXSTATUS CFDE_CSSSyntaxParser::DoSyntaxParse() {
while (m_eStatus >= FDE_CSSSYNTAXSTATUS_None) {
if (m_TextPlane.IsEOF()) {
if (m_pStream == NULL) {
if (m_eMode == FDE_CSSSYNTAXMODE_PropertyValue &&
m_TextData.GetLength() > 0) {
SaveTextData();
return m_eStatus = FDE_CSSSYNTAXSTATUS_PropertyValue;
}
return m_eStatus = FDE_CSSSYNTAXSTATUS_EOS;
}
FX_BOOL bEOS;
int32_t iLen = m_TextPlane.LoadFromStream(m_pStream, m_iStreamPos,
m_iPlaneSize, bEOS);
m_iStreamPos = m_pStream->GetPosition();
if (iLen < 1) {
if (m_eMode == FDE_CSSSYNTAXMODE_PropertyValue &&
m_TextData.GetLength() > 0) {
SaveTextData();
return m_eStatus = FDE_CSSSYNTAXSTATUS_PropertyValue;
}
return m_eStatus = FDE_CSSSYNTAXSTATUS_EOS;
}
}
FX_WCHAR wch;
while (!m_TextPlane.IsEOF()) {
wch = m_TextPlane.GetChar();
switch (m_eMode) {
case FDE_CSSSYNTAXMODE_RuleSet:
switch (wch) {
case '@':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_AtRule);
break;
case '}':
m_TextPlane.MoveNext();
if (RestoreMode()) {
return FDE_CSSSYNTAXSTATUS_DeclClose;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
m_ModeStack.Push(m_eMode);
SwitchMode(FDE_CSSSYNTAXMODE_Comment);
break;
}
default:
if (wch <= ' ') {
m_TextPlane.MoveNext();
} else if (FDE_IsSelectorStart(wch)) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_StyleRule;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
}
break;
case FDE_CSSSYNTAXMODE_Selector:
switch (wch) {
case ',':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
if (m_iTextDatLen > 0) {
return FDE_CSSSYNTAXSTATUS_Selector;
}
break;
case '{':
if (m_TextData.GetLength() > 0) {
SaveTextData();
return FDE_CSSSYNTAXSTATUS_Selector;
} else {
m_TextPlane.MoveNext();
m_ModeStack.Push(FDE_CSSSYNTAXMODE_RuleSet);
SwitchMode(FDE_CSSSYNTAXMODE_PropertyName);
return FDE_CSSSYNTAXSTATUS_DeclOpen;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_Selector;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_PropertyName:
switch (wch) {
case ':':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_PropertyValue);
return FDE_CSSSYNTAXSTATUS_PropertyName;
case '}':
m_TextPlane.MoveNext();
if (RestoreMode()) {
return FDE_CSSSYNTAXSTATUS_DeclClose;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_PropertyName;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_PropertyValue:
switch (wch) {
case ';':
m_TextPlane.MoveNext();
case '}':
SwitchMode(FDE_CSSSYNTAXMODE_PropertyName);
return FDE_CSSSYNTAXSTATUS_PropertyValue;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_PropertyValue;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_Comment:
if (wch == '/' && m_TextData.GetLength() > 0 &&
m_TextData.GetAt(m_TextData.GetLength() - 1) == '*') {
RestoreMode();
} else {
m_TextData.AppendChar(wch);
}
m_TextPlane.MoveNext();
break;
case FDE_CSSSYNTAXMODE_MediaType:
switch (wch) {
case ',':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
if (m_iTextDatLen > 0) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
break;
case '{': {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_MediaRule) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (m_TextData.GetLength() > 0) {
SaveTextData();
return FDE_CSSSYNTAXSTATUS_MediaType;
} else {
m_TextPlane.MoveNext();
*pMode = FDE_CSSSYNTAXMODE_RuleSet;
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
return FDE_CSSSYNTAXSTATUS_DeclOpen;
}
} break;
case ';': {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_Import) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (m_TextData.GetLength() > 0) {
SaveTextData();
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
} else {
FX_BOOL bEnabled = IsImportEnabled();
m_TextPlane.MoveNext();
m_ModeStack.Pop();
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
if (bEnabled) {
DisableImport();
return FDE_CSSSYNTAXSTATUS_ImportClose;
}
}
} break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_URI: {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_Import) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (wch <= ' ' || wch == ';') {
int32_t iURIStart, iURILength = m_TextData.GetLength();
if (iURILength > 0 &&
FDE_ParseCSSURI(m_TextData.GetBuffer(), iURILength, iURIStart,
iURILength)) {
m_TextData.Subtract(iURIStart, iURILength);
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_URI;
} else {
break;
}
}
}
AppendChar(wch);
} break;
case FDE_CSSSYNTAXMODE_AtRule:
if (wch > ' ') {
AppendChar(wch);
} else {
int32_t iLen = m_TextData.GetLength();
const FX_WCHAR* psz = m_TextData.GetBuffer();
if (FXSYS_wcsncmp(L"charset", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Charset);
} else if (FXSYS_wcsncmp(L"import", psz, iLen) == 0) {
m_ModeStack.Push(FDE_CSSSYNTAXMODE_Import);
SwitchMode(FDE_CSSSYNTAXMODE_URI);
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_ImportRule;
} else {
break;
}
} else if (FXSYS_wcsncmp(L"media", psz, iLen) == 0) {
m_ModeStack.Push(FDE_CSSSYNTAXMODE_MediaRule);
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
return FDE_CSSSYNTAXSTATUS_MediaRule;
} else if (FXSYS_wcsncmp(L"font-face", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_FontFaceRule;
} else if (FXSYS_wcsncmp(L"page", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_PageRule;
} else {
SwitchMode(FDE_CSSSYNTAXMODE_UnknownRule);
}
}
break;
case FDE_CSSSYNTAXMODE_Charset:
if (wch == ';') {
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
if (IsCharsetEnabled()) {
DisableCharset();
if (m_iTextDatLen > 0) {
if (m_pStream != NULL) {
FX_WORD wCodePage = FX_GetCodePageFormStringW(
m_TextData.GetBuffer(), m_iTextDatLen);
if (wCodePage < 0xFFFF &&
m_pStream->GetCodePage() != wCodePage) {
m_pStream->SetCodePage(wCodePage);
}
}
return FDE_CSSSYNTAXSTATUS_Charset;
}
}
} else {
AppendChar(wch);
}
break;
case FDE_CSSSYNTAXMODE_UnknownRule:
if (wch == ';') {
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
}
m_TextPlane.MoveNext();
break;
default:
FXSYS_assert(FALSE);
break;
}
}
}
return m_eStatus;
}
int main (void)
{
//Test
//Test();
//Init
InitDevice();
//Send Startup Message
FCMessageSend("vFlyOK");
//等待INS的GPS完成启动
//WaitGPS();
//改变运行状态并发送状态信息
RunState=DefaultRunState;
FCEventSend(RunState);
//初始化参数
InitPara();
FCMessageSend("InitParaOK");
//启动主计时器
TimerEnable(0);
while(1)
{
if(Do==DoWorkLoop)
{
LED2ON();
INS();
SwitchMode();
if(FPGAState==TRUE)
{
GetPWM();
}
//FCA();
//FCALimitPWM(void);
FCAGetNav();
FCAPWMOut();
SmoothPWM(40);
SetPWM();
//CollectMedianDataFun(40);
FCACollectPosYaw(5);
FCACollectMedianDataFun(40);
FCFrameProcess();
if(MainLoopRunCounter%DataSendDF==0)
{
DataReturn(0);
}
if(MainLoopRunCounter%DataRecDF==DataRecDF/2)
{
DataReturn(1);
}
MainLoopRunCounter++;
LED2OFF();
Do=DoNothing;
}
if(Do==DoFactoryLoop)
{
LED1ON();
GpioClrLOW(P1_25);//一律切换到手驾
INS();
FCFrameProcess();
if(DataToDownload==0)
{
if(MainLoopRunCounter%DataSendDF==0)
{
DataReturn(0);
}
/*
if(MainLoopRunCounter%DataRecDF==DataRecDF/2)
{
DataReturn(1);
}
*/
}
else
{
DataDownload();
}
MainLoopRunCounter++;
LED1OFF();
Do=DoNothing;
}
}
return 0;
}
inline int32_t CFDE_CSSSyntaxParser::SwitchToComment() {
int32_t iLength = m_TextData.GetLength();
m_ModeStack.Push(m_eMode);
SwitchMode(FDE_CSSSYNTAXMODE_Comment);
return iLength;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
// "([^"]+)"|(\S+)
// ""([^""]+)""|(\\S+)
//WavSound *w = new WavSound(":/resources/connected.wav", 0);
//w->play();
//return;
//PlaySound();
//return;
ui->setupUi(this);
QApplication::setWindowIcon(QIcon(":/resources/Icon/RunningIcon.png"));
strangerPrefsWindow = new StrangerPrefsWindow(this);
//QDockWidget *drawdock = new QDockWidget(this,Qt::Dialog);
//this->addDockWidget(Qt::RightDockWidgetArea,drawdock);
/*CometClient *c = new CometClient(this);
c->get("http://gggoogle.ru", 6);
c->get("http://gggoogle.ru", 7);
c->get("http://google.ru", 8);
c->get("http://googleq.ru", 9);
c->cancelAllRequests();
return;
*/
/*QHBoxLayout *dockLayout = new QHBoxLayout(this);
QComboBox *b = new QComboBox(this);
QTextEdit *t = new QTextEdit(this);
dockLayout->addWidget(b);
dockLayout->addWidget(t);
dockLayout->setSizeConstraint(QLayout::SetMinimumSize);
ui->dockWidgetContents_2->setLayout(dockLayout);
*/
QWidget::setTabOrder(ui->typingBox, ui->chatlogBox);
//do not allow Qt framework to intercept Tab keypress (we use it for switching modes)
//ui->chatlogBox->setFocusPolicy(Qt::NoFocus);
/*QFile stylesheetFile(":/resources/stylesheet.qss");
if(!stylesheetFile.open(QFile::ReadOnly)) {
qDebug() << "Error opening file " << stylesheetFile.error();
}
QString stylesheetString = QLatin1String(stylesheetFile.readAll());
setStyleSheet(stylesheetString);
*/
nightColoringMode = false;
switchColoringMode(); //switch to night coloring mode, and apply it
QStatusBar *sb = this->statusBar();
chatModeLabel = new QLabel(this);
//chatModeLabel = new QPushButton(this);
//chatModeLabel->setFlat(true);
sb->addPermanentWidget(chatModeLabel);
typingLabel = new QLabel(this);
sb->addPermanentWidget(typingLabel);
//center the window
setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, size(), qApp->desktop()->availableGeometry()));
receivedMessageSound = NULL;
sentMessageSound = NULL;
connectedSound = NULL;
disconnectedSound = NULL;
receivedMessageSound = new QSound(":/resources/sounds/shuffle.wav", this);
//sentMessageSound = new QSound(":/resources/sounds/test.wav", this);
connectedSound = new QSound(":/resources/sounds/click1.wav", this);
disconnectedSound = new QSound(":/resources/sounds/phone_disc.wav", this);
//receivedMessageSound->setObjectName();
//return;
QObject::connect(ui->typingBox, SIGNAL(enterPressed()), this, SLOT(enterPressed()));
QObject::connect(ui->typingBox, SIGNAL(escapePressed()), this, SLOT(escapePressed()));
QObject::connect(ui->typingBox, SIGNAL(switchMode()), this, SLOT(SwitchMode()));
QObject::connect(ui->typingBox, SIGNAL(typingStarted()), this, SLOT(TypingStarted()));
QObject::connect(ui->typingBox, SIGNAL(typingStopped()), this, SLOT(TypingStopped()));
QObject::connect(ui->typingBox, SIGNAL(showPreferences()), this, SLOT(displayStrangerPreferencesWindow()));
QObject::connect(ui->typingBox, SIGNAL(switchColoringMode()), this, SLOT(switchColoringMode()));
stranger = new Stranger(this);
spy = new Spy(this);
rusStranger = new RusStranger(this);
//rusStranger->requestChatKey();
//rusStranger->requestUid();
QObject::connect(stranger, SIGNAL(ReceivedMessage(const QString &)), this, SLOT(ReceivedMessage(const QString &)));
QObject::connect(stranger, SIGNAL(StrangerDisconnected()), this, SLOT(StrangerDisconnected()));
QObject::connect(stranger, SIGNAL(ConversationStarted(QStringList, bool)), this, SLOT(StrangerConnected(QStringList, bool)));
//QObject::connect(stranger, SIGNAL(ConversationStarted()), this, SLOT(StrangerConnected()));
QObject::connect(stranger, SIGNAL(ConversationStartedWithQuestion(QString)), this, SLOT(StrangerConnectedWithQuestion(QString)));
QObject::connect(stranger, SIGNAL(StrangerStartsTyping()), this, SLOT(StrangerStartsTyping()));
QObject::connect(stranger, SIGNAL(StrangerStopsTyping()), this, SLOT(StrangerStopsTyping()));
QObject::connect(stranger, SIGNAL(SystemMessage(const QString &)), this, SLOT(SystemMessage(const QString &)));
QObject::connect(stranger, SIGNAL(WaitingForStranger()), this, SLOT(WaitingForStranger()));
QObject::connect(spy, SIGNAL(ReceivedMessage(const QString &,const QString &)), this, SLOT(SpymodeReceivedMessage(const QString &,const QString &)));
QObject::connect(spy, SIGNAL(StrangerDisconnected(const QString &)), this, SLOT(SpymodeStrangerDisconnected(const QString &)));
QObject::connect(spy, SIGNAL(ConversationStarted()), this, SLOT(SpymodeStrangersConnected()));
QObject::connect(spy, SIGNAL(ConversationStartedWithQuestion(QString)), this, SLOT(StrangerConnectedWithQuestion(QString)));
QObject::connect(spy, SIGNAL(StrangerStartsTyping(QString)), this, SLOT(SpymodeStrangerStartsTyping(const QString &)));
QObject::connect(spy, SIGNAL(StrangerStopsTyping()), this, SLOT(SpymodeStrangerStopsTyping(const QString &)));
QObject::connect(spy, SIGNAL(SystemMessage(const QString &)), this, SLOT(SystemMessage(const QString &)));
QObject::connect(spy, SIGNAL(WaitingForStranger()), this, SLOT(WaitingForStranger()));
QObject::connect(rusStranger, SIGNAL(ReceivedMessage(const QString &)), this, SLOT(ReceivedMessage(const QString &)));
QObject::connect(rusStranger, SIGNAL(StrangerDisconnected()), this, SLOT(StrangerDisconnected()));
QObject::connect(rusStranger, SIGNAL(ConversationStarted()), this, SLOT(StrangerConnected()));
QObject::connect(rusStranger, SIGNAL(StrangerStartsTyping()), this, SLOT(StrangerStartsTyping()));
QObject::connect(rusStranger, SIGNAL(StrangerStopsTyping()), this, SLOT(StrangerStopsTyping()));
QObject::connect(rusStranger, SIGNAL(WaitingForStranger()), this, SLOT(WaitingForStranger()));
//chatMode = Russian;
chatMode = AnsweringQuestions;
SwitchMode(); //switch it to regular
this->escapePressed();
//strangerPrefsWindow->setModal(true);
//strangerPrefsWindow->show();
}
//-------------------------------------------------
int CheckSwitchKey(WPARAM wParam, LPARAM lParam)
{
if (!ClipboardIsEmpty)
return 0;
int ret = 0;
// In WinXP CTRL-SHIFT is used to change text alignment. Disable this functionality
static int ctrlPressed = 0;
static int shiftPressed = 0;
if (pShMem->winMajorVersion == 5 && pShMem->winMinorVersion == 1) { // WinXP
if ((KeyState[VK_CONTROL] & 0x80) && (KeyState[VK_SHIFT] & 0x80)) {
ctrlPressed = 1;
shiftPressed = 1;
}
if (ctrlPressed && (lParam & IsReleased) && wParam == VK_CONTROL) {
ctrlPressed = 0;
ret = 1;
}
if (shiftPressed && (lParam & IsReleased) && wParam == VK_SHIFT) {
shiftPressed = 0;
ret = 1;
}
}
/////////////////
//although the goal of this function is to check switch key,
//we also check if CTRL is used to reset buffer here (for convenience).
if (!(lParam & IsReleased) && wParam == VK_CONTROL &&
!(KeyState[VK_MENU] & 0x80)) {
PendingReset = 1;
}
//on FR, GER keyboards, AltGr == CTRL+ALT is used for typing accents,
// so we should not reset buffer if we see Alt is pressed
if (!(lParam & IsReleased) && wParam == VK_MENU)
PendingReset = 0;
if (PendingReset &&
(((lParam & IsReleased) && wParam == VK_CONTROL) ||
(!(lParam & IsReleased) && wParam != VK_CONTROL)) ) {
PendingReset = 0;
ResetBuffer();
}
/////////////////
// Check switch key
UINT key1, key2;
switch (pShMem->switchKey) {
case CTRL_SHIFT_SW:
key1 = VK_SHIFT;
key2 = VK_CONTROL;
break;
default:
key1 = VK_MENU;
key2 = 'Z';
break;
}
if (wParam == key1 || wParam == key2) {
if (lParam & IsReleased) {
if (PendingSwitch) {
PendingSwitch = 0;
SwitchMode();
MessageBeep(MB_ICONASTERISK);
return 1;
}
}
else {
if ((KeyState[key1] & 0x80) && (KeyState[key2] & 0x80))
PendingSwitch = 1;
}
}
else PendingSwitch = 0;
return ret;
}
