//-----------------------------------------------------------------------
size_t ZipDataStream::tell(void) const
{
zzip_off_t pos = zzip_tell(mZzipFile);
if (pos<0)
return (size_t)(-1);
return static_cast<size_t>(pos) - mCache.avail();
}
size_t getEntry(const char *name, char *contentFile, char **ptr) {
size_t size=0;
ZZIP_DIR *dir;
ZZIP_DIRENT entry;
ZZIP_FILE *file;
char *buf;
dir = zzip_dir_open(name, 0);
if (!dir) {
fprintf(stderr, "failed to open %s\n", name);
return 0;
}
zzip_dir_read(dir, &entry);
file = zzip_file_open(dir, contentFile, 0);
(void)zzip_seek(file, 0, SEEK_END);
size = zzip_tell(file);
(void)zzip_seek(file, 0, SEEK_SET);
buf = (char *)malloc(size+1);
(void)zzip_read(file, buf, size);
buf[size] = '\0';
*ptr = buf;
zzip_file_close(file);
zzip_dir_close(dir);
return size;
}
/** => zzip_tell
* This function is provided for users who can not use any largefile-mode.
*/
long
zzip_tell32(ZZIP_FILE * fp)
{
if (sizeof(zzip_off_t) == sizeof(long))
{
return zzip_tell(fp);
} else
{
off_t off = zzip_tell(fp);
if (off >= 0) {
register long off32 = off;
if (off32 == off) return off32;
#ifdef ZZIP_DISABLED
errno = EOVERFLOW;
#endif /* ZZIP_DISABLED */
}
return -1;
}
}
int
ACEXML_ZipCharStream::available (void)
{
if (this->infile_ == 0)
return -1;
long curr;
if ((curr = zzip_tell (this->infile_)) < 0)
return -1;
return (this->size_ - curr);
}
u32 ZIPROMReaderSize(void * file)
{
u32 size;
zzip_seek((ZZIP_FILE*)file, 0, SEEK_END);
size = zzip_tell((ZZIP_FILE*)file);
zzip_seek((ZZIP_FILE*)file, 0, SEEK_SET);
return size;
}
// Reads line from UTF-8 encoded text file.
// File must be open in binary read mode.
// ATTENTION: if buffer is not large enough, the zzip_fread will fail
// and ReadULine will return , but you will not be able to know if it returned
// for a string overflow (managed) or because it reached EOF!
bool ReadULine(ZZIP_FILE* fp, TCHAR *unicode, int maxChars)
{
// This is a char, and we need space for at least MAX_HELP TCHARS!
//
unsigned char buf[1500 * 2];
long startPos = zzip_tell(fp);
if (startPos < 0) {
StartupStore(_T(". ftell() error = %d%s"), errno, NEWLINE);
return(false);
}
size_t nbRead = zzip_fread(buf, 1, sizeof(buf) - 1, fp);
if (nbRead == 0)
return(false);
buf[nbRead] = '\0';
// find new line (CR/LF/CRLF) in the string and terminate string at that position
size_t i;
for (i = 0; i < nbRead; i++) {
if (buf[i] == '\n')
{
buf[i++] = '\0';
if (buf[i] == '\r')
i++;
break;
}
if (buf[i] == '\r')
{
buf[i++] = '\0';
if (buf[i] == '\n')
i++;
break;
}
}
// next reading will continue after new line
zzip_seek(fp, startPos + i, SEEK_SET);
// skip leading BOM
char* begin = (char*) buf;
if (buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF)
begin += 3;
return(utf2unicode(begin, unicode, maxChars) >= 0);
}
std::future<void*> ResourceManager::LoadSound(const char* filepath, void* _fSystem)
{
#ifdef _CACH_PARSED_DATA_
for (std::map<const char*, SoundData*>::iterator it = mSoundResource.begin(); it != mSoundResource.end(); it++)
{
if (it->first == filepath)
return mThreadPool.AddTask<LoadSoundTask>(it->second->buffer, it->second->bufferSize, &mGlLock, _fSystem);
}
#endif
unsigned int bufferSize;
unsigned char* buffer;
switch (mAssetPacketExtension)
{
case PACA:
bufferSize = mPacaReader.GetResourceSize(filepath);
buffer = new unsigned char[bufferSize];
if (mPacaReader.GetResource(filepath, buffer, bufferSize))
{
#ifdef _CACH_PARSED_DATA_
SoundData* sd = new SoundData();
sd->buffer = buffer;
sd->bufferSize = bufferSize;
mSoundResource.insert(std::pair<const char*, SoundData*>(filepath, sd));
#endif
return mThreadPool.AddTask<LoadSoundTask>(buffer, bufferSize, &mGlLock, _fSystem);
}
break;
case ZIP:
ZZIP_FILE* fp = zzip_file_open(mDir, filepath, 0);
zzip_seek(fp, 0, SEEK_END);
bufferSize = zzip_tell(fp);
zzip_rewind(fp);
buffer = new unsigned char[bufferSize];
bufferSize = zzip_file_read(fp, buffer, static_cast<int>(bufferSize));
zzip_file_close(fp);
#ifdef _CACH_PARSED_DATA_
SoundData* sd = new SoundData();
sd->buffer = buffer;
sd->bufferSize = bufferSize;
mSoundResource.insert(std::pair<const char*, SoundData*>(filepath, sd));
#endif
return mThreadPool.AddTask<LoadSoundTask>(buffer, bufferSize, &mGlLock, _fSystem);
}
}
static int ff_seek (lua_State *L) {
static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
static const char *const modenames[] = {"set", "cur", "end", NULL};
ZZIP_FILE *f = tointernalfile(L, 1);
int op = luaL_checkoption(L, 2, "cur", modenames);
long offset = luaL_optlong(L, 3, 0);
luaL_argcheck(L, op != -1, 2, "invalid mode");
op = zzip_seek(f, offset, mode[op]);
if (op < 0)
return pushresult(L, 0, NULL); /* error */
else {
lua_pushnumber(L, zzip_tell(f));
return 1;
}
}
TextureResource* ResourceManager::LoadTexture( const char* file)
{
#ifdef _CACH_PARSED_DATA_
for (std::map<const char*, TextureResource*>::iterator it = mTextureResource.begin(); it != mTextureResource.end(); it++)
{
if (it->first == file)
return it->second;
}
#endif
unsigned int bufferSize;
unsigned char* buffer;
switch ( mAssetPacketExtension )
{
case PACA:
bufferSize = mPacaReader.GetResourceSize(file);
buffer = new unsigned char[bufferSize];
if ( mPacaReader.GetResource(file, buffer, bufferSize ) )
{
TextureResource* textureResource = new TextureResource();
textureResource->future = mThreadPool.AddTask<LoadTextureTask>(buffer, bufferSize, &mGlLock);
#ifdef _CACH_PARSED_DATA_
mTextureResource.insert(std::pair<const char*, TextureResource*>(file, textureResource));
#endif
return textureResource;
}
break;
case ZIP:
ZZIP_FILE* fp = zzip_file_open( mDir, file, 0 );
zzip_seek( fp, 0, SEEK_END );
bufferSize = zzip_tell( fp );
zzip_rewind( fp );
buffer = new unsigned char[bufferSize];
bufferSize = zzip_file_read( fp, buffer, static_cast<int>( bufferSize ) );
zzip_file_close( fp );
TextureResource* textureResource = new TextureResource();
textureResource->future = mThreadPool.AddTask<LoadTextureTask>(buffer, bufferSize, &mGlLock);
#ifdef _CACH_PARSED_DATA_
mTextureResource.insert(std::pair<const char*, TextureResource*>(file, textureResource));
#endif
return textureResource;
}
}
BOOL ReadString(ZZIP_FILE *zFile, int Max, TCHAR *String)
{
char sTmp[READLINE_LENGTH+1];
char FileBuffer[READLINE_LENGTH+1];
long dwNumBytesRead=0;
long dwTotalNumBytesRead=0;
long dwFilePos;
String[0] = '\0';
sTmp[0] = 0;
#if BUGSTOP
LKASSERT((unsigned)Max<sizeof(sTmp));
#endif
if (Max >= (int)(sizeof(sTmp)))
return(FALSE);
if (!zFile)
return(FALSE);
dwFilePos = zzip_tell(zFile);
dwNumBytesRead = zzip_fread(FileBuffer, 1, Max, zFile);
if (dwNumBytesRead <= 0)
return(FALSE);
int i = 0;
int j = 0;
while((i<Max) && (j<(int)dwNumBytesRead)) {
char c = FileBuffer[j];
j++;
dwTotalNumBytesRead++;
if((c == '\n')){
break;
}
sTmp[i] = c;
i++;
}
sTmp[i] = 0;
zzip_seek(zFile, dwFilePos+j, SEEK_SET);
sTmp[Max-1] = '\0';
mbstowcs(String, sTmp, strlen(sTmp)+1);
return (dwTotalNumBytesRead>0);
}
PSAR_ENTRY *LPP_PsarDecoder_getEntry(const char *filename)
{
if(!initialized) return NULL;
zzip_strings_t ext[] = {"", 0};
ZZIP_FILE *fd = zzip_open_ext_io(filename, O_RDONLY | (0x0), ZZIP_ONLYZIP, ext, &psar_handlers);
if(fd == NULL)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot open the file '%s' for read.\n", __FUNCTION__, __LINE__, filename);
#endif
return NULL;
}
PSAR_ENTRY *entry = (PSAR_ENTRY*)malloc(sizeof(PSAR_ENTRY));
if(!entry)
{
#ifdef DEBUG
dwrite_output("Function %s Line %d : Cannot allocate 'entry' to memory.\n", __FUNCTION__, __LINE__);
#endif
zzip_close(fd);
return NULL;
}
memset(entry, 0, sizeof(PSAR_ENTRY));
zzip_seek(fd, 0, SEEK_END);
entry->len = zzip_tell(fd);
zzip_rewind(fd);
if(entry->len <= 0)
{
free(entry);
zzip_fclose(fd);
#ifdef DEBUG
dwrite_output("Function %s Line %d : file len is lower than zero.\n", __FUNCTION__, __LINE__);
#endif
return NULL;
}
entry->data = (u8*)malloc(entry->len);
zzip_fread(entry->data, 1, entry->len, fd);
zzip_fclose(fd);
return(entry);
}
size_t getEntry(const char *name, char *contentFile, char **ptr) {
size_t size=0;
ZZIP_DIR *dir;
ZZIP_DIRENT entry;
ZZIP_FILE *file;
zzip_error_t error;
char *buf;
o_log(DEBUGM, "opening %s", name);
dir = zzip_dir_open(name, &error);
if (!dir) {
o_log(ERROR, "failed to open %s", name);
return 0;
}
while(zzip_dir_read(dir, &entry)) {
if( 0 == strcmp(entry.d_name, contentFile) ) {
file = zzip_file_open(dir, contentFile, O_RDONLY);
(void)zzip_seek(file, 0, SEEK_END);
size = zzip_tell(file);
(void)zzip_seek(file, 0, SEEK_SET);
buf = (char *)malloc(size+1);
(void)zzip_read(file, buf, size);
buf[size] = '\0';
*ptr = buf;
zzip_file_close(file);
}
}
zzip_dir_close(dir);
return size;
}
//-----------------------------------------------------------------------
bool ZipDataStream::eof(void) const
{
return (zzip_tell(mZzipFile) >= static_cast<zzip_off_t>(mSize));
}
//-----------------------------------------------------------------------
size_t ZipDataStream::tell(void) const
{
return zzip_tell(mZzipFile);
}
bool
CZipIOAccess::Eof( void ) const
{GUCEF_TRACE;
return (zzip_tell( m_zzipFile ) >= static_cast<zzip_off_t>( m_size ) );
}
CORE::UInt32
CZipIOAccess::Tell( void ) const
{GUCEF_TRACE;
return (CORE::UInt32) zzip_tell( m_zzipFile );
}
static void
ReadAirspace(AirspaceDatabase &airspace_database, ZZIP_FILE *fp)
{
StartupStore(TEXT("ReadAirspace\n"));
int Tock = 0;
DWORD dwStep;
DWORD dwPos;
DWORD dwOldPos = 0L;
int nLineType;
unsigned NumberOfAirspacePointsPass[2] = { 0, 0 };
unsigned NumberOfAirspaceAreasPass[2] = { 0, 0 };
unsigned NumberOfAirspaceCirclesPass[2] = { 0, 0 };
LineCount = 0;
airspace_database.SetQNH(QNH);
XCSoarInterface::CreateProgressDialog(gettext(TEXT("Loading Airspace File...")));
// Need step size finer than default 10
XCSoarInterface::SetProgressStepSize(5);
dwStep = zzip_file_size(fp) / 10L;
TempArea.FirstPoint = airspace_database.NumberOfAirspacePoints;
bFillMode = false;
bWaiting = true;
XCSoarInterface::StepProgressDialog();
while((nLineType = GetNextLine(fp, TempString)) >= 0) {
Tock++;
Tock %= 50;
if (Tock == 0) {
dwPos = zzip_tell(fp);
if ((dwPos - dwOldPos) >= dwStep) {
XCSoarInterface::StepProgressDialog();
dwOldPos = dwPos;
}
}
if (!ParseLine(airspace_database, nLineType, NumberOfAirspacePointsPass[0],
NumberOfAirspaceAreasPass[0],
NumberOfAirspaceCirclesPass[0])) {
CloseAirspace(airspace_database);
return;
}
}
// Process final area (if any). bFillMode is false. JG 10-Nov-2005
if (!bWaiting)
NumberOfAirspaceAreasPass[0]++; // ????
// allocate new memory
size_t screen_point_size = (airspace_database.NumberOfAirspacePoints +
NumberOfAirspacePointsPass[0]) *
sizeof(AirspaceScreenPoint[0]);
POINT *new_points = AirspaceScreenPoint == NULL
? (POINT *)LocalAlloc(LMEM_FIXED, screen_point_size)
: (POINT *)LocalReAlloc(AirspaceScreenPoint, LMEM_FIXED,
screen_point_size);
if (new_points != NULL)
AirspaceScreenPoint = new_points;
if ((screen_point_size > 0 && new_points == NULL) ||
!airspace_database.GrowPoints(NumberOfAirspacePointsPass[0]) ||
!airspace_database.GrowAreas(NumberOfAirspaceAreasPass[0]) ||
!airspace_database.GrowCircles(NumberOfAirspaceCirclesPass[0])) {
// can't allocate memory, so delete everything
airspace_database.Clear();
if (AirspaceScreenPoint != NULL) {
LocalFree((HLOCAL)AirspaceScreenPoint);
AirspaceScreenPoint = NULL;
}
return;
}
// ok, start the read
TempArea.FirstPoint = airspace_database.NumberOfAirspacePoints;
zzip_seek(fp, 0, SEEK_SET );
LineCount = -1;
bFillMode = true;
bWaiting = true;
dwOldPos = 0L;
XCSoarInterface::StepProgressDialog();
CenterY = CenterX = 0;
Rotation = 1;
while((nLineType = GetNextLine(fp, TempString)) >= 0) {
Tock++;
Tock %= 50;
if (Tock == 0) {
dwPos = zzip_tell(fp);
if ((dwPos - dwOldPos) >= dwStep) {
XCSoarInterface::StepProgressDialog();
dwOldPos = dwPos;
}
}
ParseLine(airspace_database, nLineType, NumberOfAirspacePointsPass[1],
NumberOfAirspaceAreasPass[1],
NumberOfAirspaceCirclesPass[1]);
}
// Process final area (if any). bFillMode is true. JG 10-Nov-2005
if (!bWaiting)
AddArea(airspace_database, &TempArea, NumberOfAirspaceAreasPass[1]);
if (NumberOfAirspacePointsPass[0] != NumberOfAirspacePointsPass[1]
|| NumberOfAirspaceAreasPass[0] != NumberOfAirspaceAreasPass[1]
|| NumberOfAirspaceCirclesPass[0] != NumberOfAirspaceCirclesPass[1]){
if (MessageBoxX(gettext(TEXT("Internal Airspace Parser Error!\r\nPlease send this Airspacefile to Support")),
gettext(TEXT("Airspace")), MB_OKCANCEL) == IDCANCEL) {
}
}
#ifndef NDEBUG
// only do this if debugging
DumpAirspaceFile(airspace_database);
#endif
// if(AirspacePoint != NULL) LocalFree((HLOCAL)AirspacePoint);
}
ModelFileParser* ResourceManager::LoadModel(const char* file)
{
#ifdef _CACH_PARSED_DATA_
for (std::map<const char*, ModelFileParser*>::iterator it = mModelFileParsers.begin(); it != mModelFileParsers.end(); it++)
{
if (it->first == file)
return it->second;
}
#endif
unsigned int bufferSize;
char* buffer;
switch ( mAssetPacketExtension )
{
case PACA:
{
bufferSize = mPacaReader.GetResourceSize( file );
buffer = new char[bufferSize];
if ( !mPacaReader.GetResource( file, buffer, bufferSize ) )
return nullptr;
break;
}
break;
case ZIP:
{
ZZIP_FILE* fp = zzip_file_open( mDir, file, 0 );
zzip_seek( fp, 0, SEEK_END );
bufferSize = zzip_tell( fp );
zzip_rewind( fp );
buffer = new char[bufferSize];
bufferSize = zzip_file_read( fp, buffer, bufferSize );
zzip_file_close( fp );
}
break;
}
addToMemCount(bufferSize);
ModelFileParser* mParser;
std::string fileString;
fileString = std::string(file);
if (fileString.substr(fileString.find_last_of(".") + 1) == "mesh")
{
mParser = new MeshParser();
addToMemCount(sizeof(mParser));
}
else if (fileString.substr(fileString.find_last_of(".") + 1) == "obj")
{
mParser = new ObjParser();
addToMemCount(sizeof(mParser));
}
else
{
delete[] buffer;
addToMemCount(-bufferSize);
return NULL;
}
mParser->Load(buffer, bufferSize);
addToMemCount(mParser->memory);
delete[] buffer;
addToMemCount(-bufferSize);
#ifdef _CACH_PARSED_DATA_
mModelFileParsers.insert(std::pair<const char*, ModelFileParser*>(file, mParser));
#endif
return mParser;
}
/** 检查ZIP文件指针是否到达末尾
*/
bool FZipFileStream::Eof(void) const
{
return zzip_tell(m_pZipFile) >= static_cast<zzip_off_t>(m_nStreamSize);
}
/**
* This function will perform a => lseek(2) operation on a real/zipped file
*
* It will try to seek to the offset specified by offset, relative to whence,
* which is one of SEEK_SET, SEEK_CUR or SEEK_END.
*
* If the file-handle is wrapping a stat'able file then it will actually just
* perform a normal => lseek(2)-call. Otherwise the relative offset
* is calculated, negative offsets are transformed into positive ones
* by rewinding the file, and then data is read until the offset is
* reached. This can make the function terribly slow, but this is
* how gzio implements it, so I'm not sure there is a better way
* without using the internals of the algorithm.
*/
zzip_off_t
zzip_seek(ZZIP_FILE * fp, zzip_off_t offset, int whence)
{
zzip_off_t cur_pos, rel_ofs, read_size, ofs;
ZZIP_DIR *dir;
if (! fp)
return -1;
if (! fp->dir)
{ /* stat fd */
return fp->io->fd.seeks(fp->fd, offset, whence);
}
cur_pos = zzip_tell(fp);
/* calculate relative offset */
switch (whence)
{
case SEEK_SET: /* from beginning */
rel_ofs = offset - cur_pos;
break;
case SEEK_CUR: /* from current */
rel_ofs = offset;
break;
case SEEK_END: /* from end */
rel_ofs = fp->usize + offset - cur_pos;
break;
default: /* something wrong */
return -1;
}
if (rel_ofs == 0)
return cur_pos; /* don't have to move */
if (rel_ofs < 0)
{ /* convert backward into forward */
if (zzip_rewind(fp) == -1)
return -1;
read_size = cur_pos + rel_ofs;
cur_pos = 0;
} else
{ /* amount to read is positive relative offset */
read_size = rel_ofs;
}
if (read_size < 0) /* bad offset, before beginning of file */
return -1;
if (read_size + cur_pos > (zzip_off_t)fp->usize) /* bad offset, past EOF */
return -1;
if (read_size == 0) /* nothing to read */
return cur_pos;
dir = fp->dir;
/*
* If this is other handle than previous, save current seek pointer
* and read the file position of `this' handle.
*/
if (dir->currentfp != fp)
{
if (zzip_file_saveoffset(dir->currentfp) < 0
|| dir->currentfp->io->fd.seeks(dir->fd, fp->offset, SEEK_SET) < 0)
{
dir->errcode = ZZIP_DIR_SEEK;
return -1;
}
else
{
dir->currentfp = fp;
}
}
if (fp->method == 0)
{ /* unstore, just lseek relatively */
ofs = fp->io->fd.tells(dir->fd);
ofs = fp->io->fd.seeks(dir->fd,read_size,SEEK_CUR);
if (ofs > 0)
{ /* readjust from beginning of file */
ofs -= fp->dataoffset;
fp->restlen = fp->usize - ofs;
}
return ofs;
} else
{ /* method == 8, inflate */
char *buf;
/*FIXME: use a static buffer! */
buf = (char *)malloc(ZZIP_32K);
if (! buf) return -1;
while (read_size > 0)
{
zzip_off_t size = ZZIP_32K;
if (read_size < size/*32K*/) size = read_size;
size = zzip_file_read(fp, buf, (zzip_size_t)size);
if (size <= 0) {
free(buf);
return -1;
}
read_size -= size;
}
free (buf);
}
return zzip_tell(fp);
}
/** 获取当前ZIP文件指针的位置
*/
size_t FZipFileStream::Tell(void) const
{
return zzip_tell( m_pZipFile );
}
int CZipArchive::CZipFile::getPos(){
return zzip_tell(m_zipfile);
}
// Rescale automatically dialogs, using negative values to force rescaling
// Notice: SHOULD BE CALLED ONLY IF rWidth is negative, in order to avoid useless SetWindowPos
int RescaleWidth(const int rWidth) {
// Always rescale negative widths
if (rWidth <-1) {
// Special case is when width is also the scale unit, which demonstrate we have a bug to fix here!
#if USEIBOX
if (rWidth == (int)(-246*InfoBoxLayout::dscale)){
#else
if (rWidth == (int)(-246*ScreenDScale)){
#endif
return LKwdlgConfig;
}
double i=(246.0 / abs(rWidth));
if (i==0) {
FailStore(_T("INTERNAL ERROR RESCALEWIDTH rWidth=%d"),rWidth);
DoStatusMessage(_T("RESCALE ERR-001"));
return rWidth;
}
#if USEIBOX
int ri=(int)( (LKwdlgConfig/i) *InfoBoxLayout::dscale );
#else
int ri=(int)( (LKwdlgConfig/i) *ScreenDScale );
#endif
// StartupStore(_T("... RescaleWidth(): rescale %d to %d\n"),rWidth, ri);
if (ri>ScreenSizeX) return(ScreenSizeX);
return (ri);
}
// else use the incoming rWidth but it is clearly an error
DoStatusMessage(_T("RESCALE WARN-001"));
return rWidth;
}
void ChangeWindCalcSpeed(const int newspeed) {
WindCalcSpeed += (double)newspeed/SPEEDMODIFY;
}
// runmode 0: exec inside LocalPath home of LK8000
// runmode 1: exec inside
bool LKRun(const TCHAR *prog, const int runmode, const DWORD dwaitime) {
if (_tcslen(prog) <5) {
StartupStore(_T("... LKRun failure: invalid exec path <%s>%s"),prog,NEWLINE);
return false;
}
TCHAR path[MAX_PATH];
if (runmode<0 || runmode>1) {
StartupStore(_T("... LKRun failure: invalid runmode=%d %s"),runmode,NEWLINE);
return false;
}
// mode 0: localpath , forced execution, with warnings if something goes wrong
// mode 1: optional execution, no warnings if nothing found
if (runmode<2) {
LocalPath(path,prog);
if (runmode==0) StartupStore(_T(". LKRun: exec <%s> background=%u%s"),path,dwaitime,NEWLINE);
PROCESS_INFORMATION pi;
STARTUPINFO si;
ZeroMemory(&si,sizeof(STARTUPINFO));
si.cb=sizeof(STARTUPINFO);
si.wShowWindow= SW_SHOWNORMAL;
si.dwFlags = STARTF_USESHOWWINDOW;
// if (!::CreateProcess(_T("C:\\WINDOWS\\notepad.exe"),_T(""), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
if (!::CreateProcess(path,_T(""), NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
if (runmode==0) StartupStore(_T("... LKRun exec FAILED%s"),NEWLINE);
return false;
}
::WaitForSingleObject(pi.hProcess, dwaitime);
StartupStore(_T(". LKRun exec terminated%s"),NEWLINE);
return true;
}
return false;
}
void GotoWaypoint(const int wpnum) {
if (!ValidWayPoint(wpnum)) {
DoStatusMessage(_T("ERR-639 INVALID GOTO WPT"));
return;
}
if (ValidTaskPoint(ActiveWayPoint) && ValidTaskPoint(1)) {
TCHAR wpname[NAME_SIZE+1];
_tcscpy(wpname,WayPointList[wpnum].Name);
wpname[10] = '\0';
if (MessageBoxX(hWndMapWindow,
// LKTOKEN _@M158_ = "CONFIRM GOTO, ABORTING TASK?"
gettext(TEXT("_@M158_")),
// LKTOKEN _@M40_ = "A task is running!"
gettext(TEXT("_@M40_")),
MB_YESNO|MB_ICONQUESTION) == IDYES) {
LockTaskData();
FlyDirectTo(wpnum);
OvertargetMode=OVT_TASK;
UnlockTaskData();
}
} else {
LockTaskData();
FlyDirectTo(wpnum);
OvertargetMode=OVT_TASK;
UnlockTaskData();
}
}
void ToggleBaroAltitude() {
if (!GPS_INFO.BaroAltitudeAvailable) {
// LKTOKEN _@M121_ = "BARO ALTITUDE NOT AVAILABLE"
DoStatusMessage(gettext(TEXT("_@M121_")));
return;
}
EnableNavBaroAltitude=!EnableNavBaroAltitude;
if (EnableNavBaroAltitude)
// LKTOKEN _@M756_ = "USING BARO ALTITUDE"
DoStatusMessage(gettext(TEXT("_@M756_")));
else
// LKTOKEN _@M757_ = "USING GPS ALTITUDE"
DoStatusMessage(gettext(TEXT("_@M757_")));
}
TCHAR * GetSizeSuffix(void) {
static TCHAR suffixname[12];
_stprintf(suffixname,_T("%03dx%03d"),ScreenSizeX,ScreenSizeY);
return(suffixname);
}
void LKRunStartEnd(bool start) {
if (start) {
LKRun(_T("PREROTATE1.EXE"),1,5000);
LKRun(_T("PREROTATE2.EXE"),1,5000);
LKRun(_T("PREROTATE3.EXE"),1,5000);
LKRun(_T("PRELOAD_00.EXE"),1,0);
LKRun(_T("PRELOAD_05.EXE"),1,5000);
LKRun(_T("PRELOAD_30.EXE"),1,30000);
LKRun(_T("PRELOAD_60.EXE"),1,60000);
LKRun(_T("PRELOAD_99.EXE"),1,INFINITE);
} else {
LKRun(_T("ENDLOAD_00.EXE"),1,0);
LKRun(_T("ENDLOAD_05.EXE"),1,5000);
LKRun(_T("ENDLOAD_30.EXE"),1,30000);
LKRun(_T("ENDLOAD_60.EXE"),1,60000);
LKRun(_T("ENDROTATE1.EXE"),1,5000);
LKRun(_T("ENDROTATE2.EXE"),1,5000);
LKRun(_T("ENDROTATE3.EXE"),1,5000);
LKRun(_T("ENDLOAD_99.EXE"),1,INFINITE);
}
}
// Reads line from UTF-8 encoded text file.
// File must be open in binary read mode.
bool ReadULine(ZZIP_FILE* fp, TCHAR *unicode, int maxChars)
{
unsigned char buf[READLINE_LENGTH * 2];
long startPos = zzip_tell(fp);
if (startPos < 0) {
StartupStore(_T(". ftell() error = %d%s"), errno, NEWLINE);
return(false);
}
size_t nbRead = zzip_fread(buf, 1, sizeof(buf) - 1, fp);
if (nbRead == 0)
return(false);
buf[nbRead] = '\0';
// find new line (CR/LF/CRLF) in the string and terminate string at that position
size_t i;
for (i = 0; i < nbRead; i++) {
if (buf[i] == '\n')
{
buf[i++] = '\0';
if (buf[i] == '\r')
i++;
break;
}
if (buf[i] == '\r')
{
buf[i++] = '\0';
if (buf[i] == '\n')
i++;
break;
}
}
// next reading will continue after new line
zzip_seek(fp, startPos + i, SEEK_SET);
// skip leading BOM
char* begin = (char*) buf;
if (buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF)
begin += 3;
return(utf2unicode(begin, unicode, maxChars) >= 0);
}
//从zip文件中读取全部文件内容到文件中或者内存中,
//zip文件必须是通过addPatchFile加入的patch文件,
bool Updater::_readContentsFromZip(const char* szZipFile, const char* szFileName,
const char* szDiskFileName, char** ppMemoryBuf, unsigned int& nFileSize)
{
//参数检查
assert(szZipFile && szFileName && (szDiskFileName || ppMemoryBuf) );
if(!szZipFile || szZipFile[0]==0 || !szFileName || szFileName[0]==0 || (!szDiskFileName && !ppMemoryBuf))
{
setLastError(AXP_ERR_PARAM);
return false;
}
//搜索加入的zip文件
PATCHFILE_MAP::iterator itPatch =
m_mapPatchFile.find(normaliseName(szZipFile));
//无法找到zip文件
assert(itPatch != m_mapPatchFile.end());
if(itPatch == m_mapPatchFile.end())
{
setLastError(AXP_ERR_PARAM, "%s not inserted", szZipFile);
return false;
}
//获得ZIP句柄
ZZIP_DIR* mZzipDir = (ZZIP_DIR*)(itPatch->second);
assert(mZzipDir);
std::string norFileName = normaliseName(szFileName, false, true);
//得到文件信息
ZZIP_STAT zstat;
memset(&zstat, 0, sizeof(ZZIP_STAT));
//打开文件,如果打不开，是空文件
ZZIP_FILE* zzipFile = zzip_file_open(mZzipDir, norFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS);
if(zzipFile)
{
int zip_err = zzip_dir_stat(mZzipDir, norFileName.c_str(), &zstat, ZZIP_CASEINSENSITIVE);
if(zip_err!=0)
{
zzip_file_close(zzipFile);
setLastError(AXP_ERR_ZIPFILE, "ziperr=%d", mZzipDir->errcode);
return false;
}
}
//如果需要写入文件
if(szDiskFileName)
{
//确认文件所在目录存在
char szDiskFilePath[MAX_PATH] = {0};
strncpy(szDiskFilePath, szDiskFileName, MAX_PATH);
PathRemoveFileSpec(szDiskFilePath);
if(szDiskFilePath[0]!=0 && !forceCreatePath(szDiskFilePath))
{
if(zzipFile)zzip_file_close(zzipFile);
setLastError(AXP_ERR_FILE_ACCESS, "Path=%s, WinErr=%d", szDiskFilePath, ::GetLastError());
return false;
}
//创建该文件
HANDLE hDiskFile = ::CreateFile(szDiskFileName,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
0,
CREATE_ALWAYS,
FILE_ATTRIBUTE_ARCHIVE,
0);
if(hDiskFile == INVALID_HANDLE_VALUE)
{
if(zzipFile)zzip_file_close(zzipFile);
setLastError(AXP_ERR_FILE_ACCESS, "File=%s, WinErr=%d", szDiskFileName, ::GetLastError());
return false;
}
if(zstat.st_size > 0)
{
const int MAX_BUFFER_SIZE = 4096;
char buffer[MAX_BUFFER_SIZE] = {0};
zzip_seek(zzipFile, 0, SEEK_SET);
zzip_ssize_t zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer));
//实际已经写入的尺寸
unsigned int nActWriteSize = 0;
//分块读写文件内容
do
{
//文件结束
if(zReadSize==0) break;
//写入磁盘文件
DWORD dwBytesWrite;
if(!WriteFile(hDiskFile, buffer, (DWORD)zReadSize, &dwBytesWrite, 0) ||
dwBytesWrite != (DWORD)zReadSize)
{
zzip_file_close(zzipFile);
CloseHandle(hDiskFile);
setLastError(AXP_ERR_FILE_WRITE, "File=%s, WinErr: %d", szDiskFileName, GetLastError());
return false;
}
//文件结束
if(zzip_tell(zzipFile) >=zstat.st_size) break;
zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer));
}while(true);
}
//关闭句柄
CloseHandle(hDiskFile); hDiskFile=0;
}
//如果需要读入内存
if(ppMemoryBuf)
{
//所需要的内存
unsigned int nMemoryNeed = (unsigned int)zstat.st_size+1;
while(nMemoryNeed%4)nMemoryNeed++; //upbound 4
//扩大静态内存大小
static std::vector< unsigned char > s_autoMemory;
if(s_autoMemory.size() < nMemoryNeed)
{
s_autoMemory.resize(nMemoryNeed);
}
s_autoMemory.assign(s_autoMemory.size(), 0);
//读入文件内容
if(zstat.st_size > 0)
{
zzip_seek(zzipFile, 0, SEEK_SET);
zzip_ssize_t nZipSize = zzip_file_read(zzipFile, (char*)&(s_autoMemory[0]), zstat.st_size);
if(nZipSize != zstat.st_size)
{
zzip_file_close(zzipFile);
setLastError(AXP_ERR_ZIPFILE, "ziperr=%d", mZzipDir->errcode);
return false;
}
}
//返回内容
*ppMemoryBuf = (char *)(&(s_autoMemory[0]));
}
//关闭句柄
if(zzipFile)zzip_file_close(zzipFile); zzipFile=0;
nFileSize = (unsigned int)zstat.st_size;
return true;
}
int64 ZipStream::getPosition() const
{
return zzip_tell(handle);
}
bool ExtractFileFromZip(AXP::IUpdater* pUpdater, const char* szZipFile, const char* szFileInZip, const char* szFileInDisk)
{
//打开zip文件
zzip_error_t zzipError;
ZZIP_DIR* mZzipDir = zzip_dir_open_ext_io(szZipFile, &zzipError, 0,
(zzip_plugin_io_t)(pUpdater->getEncryptZipPluginIO(szZipFile)));
if (zzipError != ZZIP_NO_ERROR)
{
return false;
}
//得到文件信息
ZZIP_STAT zstat;
memset(&zstat, 0, sizeof(ZZIP_STAT));
//打开文件,如果打不开，是空文件
ZZIP_FILE* zzipFile = zzip_file_open(mZzipDir, szFileInZip, ZZIP_ONLYZIP | ZZIP_CASELESS);
if(!zzipFile)
{
zzip_dir_close(mZzipDir);
return false;
}
//获得文件信息
int zip_err = zzip_dir_stat(mZzipDir, szFileInZip, &zstat, ZZIP_CASEINSENSITIVE);
if(zip_err!=0)
{
zzip_file_close(zzipFile);
zzip_dir_close(mZzipDir);
return false;
}
//创建该文件
HANDLE hDiskFile = ::CreateFile(szFileInDisk,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
0,
CREATE_ALWAYS,
FILE_ATTRIBUTE_ARCHIVE,
0);
if(hDiskFile == INVALID_HANDLE_VALUE)
{
zzip_file_close(zzipFile);
zzip_dir_close(mZzipDir);
return false;
}
if(zstat.st_size > 0)
{
const int MAX_BUFFER_SIZE = 4096;
char buffer[MAX_BUFFER_SIZE] = {0};
zzip_seek(zzipFile, 0, SEEK_SET);
zzip_ssize_t zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer));
//实际已经写入的尺寸
unsigned int nActWriteSize = 0;
//分块读写文件内容
do
{
//文件结束
if(zReadSize==0) break;
//写入磁盘文件
DWORD dwBytesWrite;
if(!WriteFile(hDiskFile, buffer, (DWORD)zReadSize, &dwBytesWrite, 0) ||
dwBytesWrite != (DWORD)zReadSize)
{
zzip_file_close(zzipFile);
zzip_dir_close(mZzipDir);
CloseHandle(hDiskFile);
return false;
}
//文件结束
if(zzip_tell(zzipFile) >=zstat.st_size) break;
zReadSize = zzip_file_read(zzipFile, buffer, sizeof(buffer));
}while(true);
}
//关闭句柄
CloseHandle(hDiskFile); hDiskFile=0;
zzip_file_close(zzipFile); zzipFile=0;
zzip_dir_close(mZzipDir); mZzipDir=0;
return true;
}
bool CZipArchive::CZipFile::eof(){
return (zzip_tell(m_zipfile) >= static_cast<zzip_off_t>(length()));
}
