// test a wxFile and wxFileInput/OutputStreams of a known type
//
void FileKindTestCase::TestFd(wxFile& file, bool expected)
{
CPPUNIT_ASSERT(file.IsOpened());
CPPUNIT_ASSERT((wxGetFileKind(file.fd()) == wxFILE_KIND_DISK) == expected);
CPPUNIT_ASSERT((file.GetKind() == wxFILE_KIND_DISK) == expected);
wxFileInputStream inStream(file);
CPPUNIT_ASSERT(inStream.IsSeekable() == expected);
wxFileOutputStream outStream(file);
CPPUNIT_ASSERT(outStream.IsSeekable() == expected);
}
/* read block at possition offset from file */
static inline ssize_t readblock(wxFile& fd, void* buffer, size_t size, off_t offset)
{
assert(offset >= 0);
if (offset < 0) {
return -1;
}
if (fd.Seek(offset) != offset) {
return -1;
}
return fd.Read(buffer, size);
}
// Writes a wxString to a file. File must be open. File is closed automatically.
bool cbWrite(wxFile& file, const wxString& buff, wxFontEncoding encoding)
{
bool result = false;
if (file.IsOpened())
{
wxCSConv conv(encoding);
result = file.Write(buff,conv);
if (result)
file.Flush();
file.Close();
}
return result;
}
Status_e FileText::writeStringInFile(wxFile& file, wxString const& str)
{
uint8_t sizeStr = strlen(str.fn_str());
//Écriture de la taille du texte.
if(file.Write(&sizeStr, sizeof sizeStr) != sizeof sizeStr)
return STATUS_FILE_WRITE_ERROR;
//Écriture du texte.
if(!file.Write(str))
return STATUS_FILE_WRITE_ERROR;
return STATUS_SUCCESS;
}
bool LoadHeader(wxFile& pkg_f, PKGHeader* m_header)
{
pkg_f.Seek(0);
if (pkg_f.Read(m_header, sizeof(PKGHeader)) != sizeof(PKGHeader)) {
ConLog.Error("PKG: Package file is too short!");
return false;
}
if (!CheckHeader(pkg_f, m_header))
return false;
return true;
}
void cxEnv::WriteEnvToFile(wxFile& file) const {
wxASSERT(file.IsOpened());
for (map<wxString, wxString>::const_iterator p = m_env.begin(); p != m_env.end(); ++p) {
wxString line = p->first;
line += wxT('=');
line += p->second;
line += wxT('\n');
file.Write(line);
}
file.Write(wxT("\n"));
}
// pass an uninitialized file object, the function will ask the user for the
// filename and try to open it, returns true on success (file was opened),
// false if file couldn't be opened/created and -1 if the file selection
// dialog was cancelled
int SjLogDialog::OpenLogFile(wxFile& file, wxString& retFilename)
{
SJ_WINDOW_DISABLER(this);
// get the file name
// -----------------
SjExtList extList; extList.AddExt(wxT("txt"));
wxFileDialog dlg(this, _("Save"), wxT(""), wxT("log.txt"), extList.GetFileDlgStr(wxFD_SAVE), wxFD_SAVE|wxFD_CHANGE_DIR);
if( dlg.ShowModal() != wxID_OK ) { return -1; }
wxString filename = dlg.GetPath();
// open file
// ---------
bool bOk wxDUMMY_INITIALIZE(false);
if ( wxFile::Exists(filename) )
{
wxASSERT( wxYES != wxCANCEL );
wxASSERT( wxNO != wxCANCEL );
bool bAppend = false;
switch( SjMessageBox(wxString::Format(_("Overwrite \"%s\"?"), filename.c_str()), SJ_PROGRAM_NAME,
wxICON_QUESTION | wxYES_NO | wxCANCEL, this, NULL, NULL, _("Yes"), _("Append")) )
{
case wxYES:
bAppend = false;
break;
case wxNO:
bAppend = true;
break;
default:
return -1;
}
if ( bAppend ) {
bOk = file.Open(filename, wxFile::write_append);
}
else {
bOk = file.Create(filename, true /* overwrite */);
}
}
else {
bOk = file.Create(filename);
}
retFilename = filename;
return bOk;
}
/// This is the 'callback' function called with each write of PNG data
/// to the stream. This is where we conveet to text and add commas.
size_t SourceOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
{
wxString Temp;
for(int i=0;i<(int)bufsize;i++)
{
// Write one byte with a comma
Temp = wxString::Format( wxT("%i,"),(int)(((unsigned char*)buffer)[i]) );
File.Write( Temp );
nBytes++;
// New line if more than 20 bytes written since last time.
if( (nBytes %20)==0 )
{
File.Write( wxT("\r\n "));
}
}
return bufsize;
}
Status_e FileText::readStringInFile(wxFile& file, wxString* str)const
{
uint8_t sizeStr;
//Lecture de la taille du texte.
if(file.Read(&sizeStr, sizeof sizeStr) != sizeof sizeStr)
return STATUS_FILE_READ_ERROR;
//Lecture du texte.
wxMemoryBuffer buffer;
if(file.Read(buffer.GetWriteBuf(sizeStr), sizeStr) != sizeStr)
return STATUS_FILE_READ_ERROR;
buffer.UngetWriteBuf(sizeStr);
str->Clear();
str->Append(wxString::FromUTF8Unchecked((const char *)buffer.GetData(), buffer.GetDataLen()));
return STATUS_SUCCESS;
}
static uint GetFileSizeImpl(wxFile& file, const wxString& name)
{
if (file.IsOpened())
{
wxFileOffset pos = file.Tell();
file.SeekEnd();
wxFileOffset size = file.Tell();
file.Seek(pos);
return size;
}
else
{
wxFile file2(name, wxFile::read);
if (!file2.IsOpened())
return 0;
file2.SeekEnd();
return file2.Tell();
}
}
int Test_Version(char* FileName_, char* Begin, char* End)
{
wxString FileName=Ztring().From_Local(FileName_).c_str();
//Opening File
F.Open(FileName);
I=F.Read(C, 1000000);
if (!I)
{
ToShow+=__T("Error opening ")+FileName;
return -1;
}
//Getting information
C[I]=0;
Z.From_Local(C);
Z=Z.SubString(Ztring().From_Local(Begin), Ztring().From_Local(End));
//deleting extra bytes
if (Z[Z.size()-1]=='\n')
Z.resize(Z.size()-1);
if (Z[Z.size()-1]=='\r')
Z.resize(Z.size()-1);
//Testing validity
if (Z.size()!=3 && Z.size()!=7) //non long, no short
{
ToShow+=__T("Error reading ")+FileName;
return -2;
}
//Reformtation information
Z.FindAndReplace(__T(","), __T("."), 0, Ztring_Recursive);
if (Z!=Version && Z!=Version_Short)
{
ToShow+=FileName;
ToShow+=__T(" is not good : version is marked ");
ToShow+=Z;
ToShow+=__T("\r\n");
}
return 0;
}
// Decryption.
bool CheckHeader(wxFile& pkg_f, PKGHeader* m_header)
{
if (m_header->pkg_magic != 0x7F504B47) {
ConLog.Error("PKG: Not a package file!");
return false;
}
switch (m_header->pkg_type)
{
case PKG_RELEASE_TYPE_DEBUG: break;
case PKG_RELEASE_TYPE_RELEASE: break;
default:
ConLog.Error("PKG: Unknown PKG type!");
return false;
}
switch (m_header->pkg_platform)
{
case PKG_PLATFORM_TYPE_PS3: break;
case PKG_PLATFORM_TYPE_PSP: break;
default:
ConLog.Error("PKG: Unknown PKG type!");
return false;
}
if (m_header->header_size != PKG_HEADER_SIZE) {
ConLog.Error("PKG: Wrong header size!");
return false;
}
if (m_header->pkg_size != pkg_f.Length()) {
ConLog.Error("PKG: File size mismatch.");
return false;
}
if (m_header->data_size + m_header->data_offset + 0x60 != pkg_f.Length()) {
ConLog.Error("PKG: Data size mismatch.");
return false;
}
return true;
}
Status_e FileText::filePointerAfterHeader(wxFile& file)const
{
uint8_t sizelg;
//Lecture de la taille du premier langage.
if(file.Read(&sizelg, sizeof sizelg) != sizeof sizelg)
return STATUS_FILE_READ_ERROR;
//Pointer sur la taille du deuxième langage.
if(file.Seek(sizelg, wxFromCurrent) == wxInvalidOffset)
return STATUS_FILE_READ_ERROR;
//Lecture de la taille du deuxième langage.
if(file.Read(&sizelg, sizeof sizelg) != sizeof sizelg)
return STATUS_FILE_READ_ERROR;
//Pointer sur la taille du premier texte ou la fin du fichier
file.Seek(sizelg, wxFromCurrent);
return STATUS_SUCCESS;
}
DWORD CNWCFile::LoadCompressed(wxFile& in, FILE* out, FILELOAD fl)
{
#define HEADER_SIZE 6
long lSize = in.Length();
if ( lSize <= HEADER_SIZE )
return ERROR_INVALID_DATA;
wxString strTmpName = wxFileName::CreateTempFileName(_T("N2X"));
DWORD dwResult = ERROR_GEN_FAILURE;
// save compressed file content without [NWZ]\0
{
TByteArray dtCompressed;
dtCompressed.SetCount(lSize - HEADER_SIZE);
in.Seek(HEADER_SIZE, wxFromStart);
in.Read(&dtCompressed[0], lSize-HEADER_SIZE);
in.Close();
dwResult = UncompressNSave(strTmpName, &dtCompressed[0], dtCompressed.GetCount());
if ( ERROR_SUCCESS != dwResult )
{
wxRemoveFile(strTmpName);
return dwResult;
}
}
wxFile file;
if ( file.Open(strTmpName) )
{
dwResult = Load(file, out, fl);
file.Close();
}
wxRemoveFile(strTmpName);
return dwResult;
#undef HEADER_SIZE
}
// Reads a wxString from a file. File must be open. File is closed automatically.
bool cbRead(wxFile& file, wxString& st, wxFontEncoding encoding)
{
st.Empty();
if (!file.IsOpened())
return false;
int len = file.Length();
if (!len)
{
file.Close();
return true;
}
char* buff = new char[len+1];
if (!buff) // remark by killerbot : this is useless, since when out of mem --> exception (this is not malloc you know)
{
file.Close();
return false;
}
file.Read((void*)buff, len);
file.Close();
buff[len]='\0';
DetectEncodingAndConvert(buff, st, encoding);
delete [] buff;
return true;
}
void ReplayList::GetHeaderInfo(wxFile& replay, StoredGame& rep, const int version) const
{
const int seek = 72 + (version < 5 ? 0 : 240);
if (replay.Seek(seek) == wxInvalidOffset) {
return;
}
int gametime = 0;
replay.Read(&gametime, 4);
rep.duration = gametime;
rep.size = replay.Length();
//! \todo don't use long long? (pedantic)
wxLongLong_t unixtime = 0;
if (replay.Seek(56) == wxInvalidOffset) {
return;
}
replay.Read(&unixtime, 8);
wxDateTime dt;
dt.Set((time_t)unixtime);
// todo: add 2 strings one for date other for time?
rep.date_string = STD_STRING(dt.FormatISODate() + _T(" ") + dt.FormatISOTime());
// rep.date = (time_t) unixtime ;
}
static bool
wxDoCopyFile(wxFile& fileIn,
const wxStructStat& fbuf,
const wxString& filenameDst,
bool overwrite)
{
// reset the umask as we want to create the file with exactly the same
// permissions as the original one
wxCHANGE_UMASK(0);
// create file2 with the same permissions than file1 and open it for
// writing
wxFile fileOut;
if ( !fileOut.Create(filenameDst, overwrite, fbuf.st_mode & 0777) )
return false;
// copy contents of file1 to file2
char buf[4096];
for ( ;; )
{
ssize_t count = fileIn.Read(buf, WXSIZEOF(buf));
if ( count == wxInvalidOffset )
return false;
// end of file?
if ( !count )
break;
if ( fileOut.Write(buf, count) < (size_t)count )
return false;
}
// we can expect fileIn to be closed successfully, but we should ensure
// that fileOut was closed as some write errors (disk full) might not be
// detected before doing this
return fileIn.Close() && fileOut.Close();
}
bool UnpackEntry(wxFile& dec_pkg_f, const PKGEntry& entry, std::string dir)
{
u8 buf[BUF_SIZE];
dec_pkg_f.Seek(entry.name_offset);
dec_pkg_f.Read(buf, entry.name_size);
buf[entry.name_size] = 0;
switch (entry.type & (0xff))
{
case PKG_FILE_ENTRY_NPDRM:
case PKG_FILE_ENTRY_NPDRMEDAT:
case PKG_FILE_ENTRY_SDAT:
case PKG_FILE_ENTRY_REGULAR:
{
wxFile out;
out.Create(dir + buf);
dec_pkg_f.Seek(entry.file_offset);
for (u64 size = 0; size < entry.file_size; ) {
size += dec_pkg_f.Read(buf, BUF_SIZE);
if (size > entry.file_size)
out.Write(buf, BUF_SIZE - (size - entry.file_size));
else
out.Write(buf, BUF_SIZE);
}
out.Close();
}
break;
case PKG_FILE_ENTRY_FOLDER:
wxMkdir(dir + buf);
break;
}
return true;
}
// ----------------------------------------------------------------------------
// Pass an uninitialized file object. The function will ask the user for the
// filename and try to open it. It returns true on success (file was opened),
// false if file couldn't be opened/created and -1 if the file selection
// dialog was canceled.
//
static bool OpenLogFile(wxFile& file, wxString& filename, wxWindow *parent)
{
filename = wxSaveFileSelector(L"log", L"txt", L"log.txt", parent);
if ( !filename ) return false; // canceled
if( wxFile::Exists(filename) )
{
bool bAppend = false;
wxString strMsg;
strMsg.Printf(L"Append log to file '%s' (choosing [No] will overwrite it)?",
filename.c_str());
switch ( Msgbox::ShowModal( _("Save log question"), strMsg, MsgButtons().YesNo().Cancel() ) )
{
case wxID_YES:
bAppend = true;
break;
case wxID_NO:
bAppend = false;
break;
case wxID_CANCEL:
return false;
default:
pxFailDev( "invalid message box return value" );
}
return ( bAppend ) ?
file.Open(filename, wxFile::write_append) :
file.Create(filename, true /* overwrite */);
}
return file.Create(filename);
}
/// Opens the file and also adds a standard comment at the start of it.
int SourceOutputStream::OpenFile(const wxString & Filename)
{
nBytes = 0;
bool bOk;
bOk = File.Open( Filename, wxFile::write );
if( bOk )
{
File.Write( wxT("// ThemeAsCeeCode.h\r\n") );
File.Write( wxT("//\r\n") );
File.Write( wxT("// This file was Auto-Generated.\r\n") );
File.Write( wxT("// It is included by Theme.cpp.\r\n") );
File.Write( wxT("// Only check this into CVS if you've read and understood the guidelines!\r\n\r\n ") );
}
return bOk;
}
wxString ReplayList::GetScriptFromReplay(wxFile& replay, const int version) const
{
wxString script;
if ( !replay.IsOpened() ) return script;
if(replay.Seek(20)==wxInvalidOffset) {
return script;
}
int headerSize=0 ;
replay.Read( &headerSize, 4);
const int seek = 64 + (version < 5 ? 0 : 240);
if(replay.Seek(seek)==wxInvalidOffset) {
return script;
}
wxFileOffset scriptSize=0;
replay.Read( &scriptSize, 4);
scriptSize = LSL::Util::Clamp( wxFileOffset(scriptSize), wxFileOffset(0), replay.Length() );
if(replay.Seek(headerSize) == wxInvalidOffset)return script;
std::string script_a(scriptSize,0);
replay.Read( &script_a[0], scriptSize );
script = TowxString( script_a ) ;//(script_a,scriptSize);
return script;
}
bool FileManager::WriteWxStringToFile(wxFile& f, const wxString& data, wxFontEncoding encoding, bool bom)
{
const char* mark = 0;
size_t mark_length = 0;
if (bom)
{
switch (encoding)
{
case wxFONTENCODING_UTF8:
mark = "\xEF\xBB\xBF";
mark_length = 3;
break;
case wxFONTENCODING_UTF16BE:
mark = "\xFE\xFF";
mark_length = 2;
break;
case wxFONTENCODING_UTF16LE:
mark = "\xFF\xFE";
mark_length = 2;
break;
case wxFONTENCODING_UTF32BE:
mark = "\x00\x00\xFE\xFF";
mark_length = 4;
break;
case wxFONTENCODING_UTF32LE:
mark = "\xFF\xFE\x00\x00";
mark_length = 4;
break;
case wxFONTENCODING_SYSTEM:
default:
break;
}
if(f.Write(mark, mark_length) != mark_length)
return false;
}
if (data.length() == 0)
return true;
#if defined(UNICODE) || defined(_UNICODE)
size_t inlen = data.Len(), outlen = 0;
wxCharBuffer mbBuff;
if ( encoding == wxFONTENCODING_UTF7 )
{
wxMBConvUTF7 conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else if ( encoding == wxFONTENCODING_UTF8 )
{
wxMBConvUTF8 conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else if ( encoding == wxFONTENCODING_UTF16BE )
{
wxMBConvUTF16BE conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else if ( encoding == wxFONTENCODING_UTF16LE )
{
wxMBConvUTF16LE conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else if ( encoding == wxFONTENCODING_UTF32BE )
{
wxMBConvUTF32BE conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else if ( encoding == wxFONTENCODING_UTF32LE )
{
wxMBConvUTF32LE conv;
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
else
{
// try wxEncodingConverter first, even it it only works for
// wxFONTENCODING_ISO8859_1..15, wxFONTENCODING_CP1250..1257 and wxFONTENCODING_KOI8
// but it's much, much faster than wxCSConv (at least on linux)
wxEncodingConverter conv;
// should be long enough
char* tmp = new char[2*inlen];
#if wxCHECK_VERSION(2, 9, 0)
if(conv.Init(wxFONTENCODING_UNICODE, encoding) && conv.Convert(data.wx_str(), tmp))
#else
if(conv.Init(wxFONTENCODING_UNICODE, encoding) && conv.Convert(data.c_str(), tmp))
#endif
{
mbBuff = tmp;
outlen = strlen(mbBuff); // should be correct, because Convert has returned true
}
else
{
// try wxCSConv, if nothing else works
wxCSConv conv(encoding);
mbBuff = conv.cWC2MB(data.c_str(), inlen, &outlen);
}
delete[] tmp;
}
// if conversion to chosen encoding succeeded, we write the file to disk
if(outlen > 0)
{
return f.Write(mbBuff, outlen) == outlen;
}
// if conversion to chosen encoding does not succeed, we try UTF-8 instead
size_t size = 0;
wxCSConv conv(encoding);
wxCharBuffer buf = data.mb_str(conv);
if(!buf || !(size = strlen(buf)))
{
buf = data.mb_str(wxConvUTF8);
if(!buf || !(size = strlen(buf)))
{
cbMessageBox(_T( "The file could not be saved because it contains characters "
"that can neither be represented in your current code page, "
"nor be converted to UTF-8.\n"
"The latter should actually not be possible.\n\n"
"Please check your language/encoding settings and try saving again." ),
_("Failure"), wxICON_WARNING | wxOK );
return false;
}
else
{
InfoWindow::Display(_("Encoding Changed"),
_("The saved document contained characters\n"
"which were illegal in the selected encoding.\n\n"
"The file's encoding has been changed to UTF-8\n"
"to prevent you from losing data."), 8000);
}
}
return f.Write(buf, size);
#else
// For ANSI builds, dump the char* to file.
return f.Write(data.c_str(), data.Length()) == data.Length();
#endif
}
Ztring OldFiles_Test ()
{
//Checking version in Info_Version
ToShow+=__T("Version checked : ");
F.Open(__T("../Source/MediaInfo/MediaInfo_Config.cpp"));
I=F.Read(C, 1000000);
if (!I)
{
ToShow+=__T("Error opening ../Source/MediaInfo/MediaInfo_Config.cpp");
return ToShow;
}
C[I]=0;
Z.From_Local(C);
Version=Z.SubString(__T("MediaInfoLib - v"), __T("\")"));
if (Version.size()!=7)
{
ToShow+=__T("Error reading ../Source/MediaInfo/MediaInfo.cpp : \"MediaInfoLib - vX.X.X.X - \" not found");
return ToShow;
}
Version_Short=Version; Version_Short.resize(3);
ToShow+=Version+__T("\r\n");
//Checking version in MediaInfo.h
if (Test_Version("../Source/MediaInfo/MediaInfo.h", "@version ", "\n")) return ToShow;
if (Test_Version("../Source/MediaInfo/MediaInfoList.h", "@version ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " FILEVERSION ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " PRODUCTVERSION ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " VALUE \"FileVersion\", \"", "\"")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " VALUE \"ProductVersion\", \"", "\"")) return ToShow;
if (Test_Version("../History.txt", "Version ", " ")) return ToShow;
if (Test_Date(__T("MSVC/Library/MediaInfo.lib"))) return ToShow;
if (Test_Date(__T("MSVC/Dll/MediaInfo.dll"))) return ToShow;
return ToShow;
}
void MakeSaveState(wxFile& f)
{
const ArrayF<MemoryBlock>& mb = Memory.MemoryBlocks;
state_hdr state;
memset(&state, 0, sizeof(state_hdr));
state.magic = state_magic;
state.version = state_version;
state.mem_count = mb.GetCount();
//state.hle_count = mb.GetCount();
state.mem_offset = sizeof(state_hdr) + 4;
f.Seek(state.mem_offset);
for(u32 i=0; i<state.mem_count; ++i)
{
state.mem_size += mb[i].GetSize();
f.Write(mb[i].GetMem(), mb[i].GetSize());
}
state.hle_offset = state.mem_offset + state.mem_size + 4;
f.Seek(0);
f.Write(&state, sizeof(state_hdr));
}
bool ControlPanel::SendWav(wxFile& wavfile)
{
if(m_pSocket->IsDisconnected())
return false;
::wxMilliSleep(100);
char* data = new char[wavfile.Length()];
wavfile.Read(data, wavfile.Length());
m_pSocket->SaveState();
m_pSocket->SetFlags(wxSOCKET_WAITALL | wxSOCKET_BLOCK);
m_pSocket->WaitForWrite();
m_pSocket->Write(data, wavfile.Length());
/*
int writeStep = ( wavfile.Length()>1024 ? 1024 : wavfile.Length()); // send blocks of 128 bytes
int sent = 0;
while(sent < wavfile.Length())
{
m_pSocket->Write(&data[sent], writeStep);
if(m_pSocket->Error())
{
wxLogMessage("Error sending wav!");
return false;
}
sent += m_pSocket->LastCount();
// ::wxUsleep(5);
}
*/
// wxLogMessage(_T("Wav file is sent! %d bytes"), m_pSocket->LastCount());
m_pSocket->RestoreState();
return true;
}
/* MemChunk::importFileStream
* Loads a file (or part of it) from a currently open file stream
* into the MemChunk
* Returns false if file couldn't be opened, true otherwise
*******************************************************************/
bool MemChunk::importFileStream(wxFile& file, uint32_t len)
{
// Check file
if (!file.IsOpened())
return false;
// Clear current data if it exists
clear();
// Get current file position
uint32_t offset = file.Tell();
// If length isn't specified or exceeds the file length,
// only read to the end of the file
if (offset + len > file.Length() || len == 0)
len = file.Length() - offset;
// Setup variables
size = len;
// Read the file
if (size > 0)
{
//data = new uint8_t[size];
if (allocData(size))
file.Read(data, size);
else
return false;
}
return true;
}
size_t WBinaryPage::ImportFile(wxFile& file)
{
wxFileOffset filesize = file.Length();
wmain->statusbar->ProgressStart(wxString(_("Importing")).mb_str(), Enctain::PI_GENERIC,
0, filesize);
bindata.SetBufSize(filesize);
char buffer[65536];
for (int i = 0; !file.Eof(); i++)
{
size_t rb = file.Read(buffer, sizeof(buffer));
if (rb == 0) break;
bindata.AppendData(buffer, rb);
wmain->statusbar->ProgressUpdate(bindata.GetDataLen());
}
listctrl->UpdateData();
needsave = true;
wmain->statusbar->ProgressStop();
return bindata.GetDataLen();
}
int ReplayList::replayVersion(wxFile& replay) const
{
if (replay.Seek(16) == wxInvalidOffset) {
return 0;
}
int version = 0;
replay.Read(&version, 4);
return version;
}
/* NodeBuilders::saveBuilderPaths
* Writes builder paths to [file]
*******************************************************************/
void NodeBuilders::saveBuilderPaths(wxFile& file)
{
file.Write("nodebuilder_paths\n{\n");
for (unsigned a = 0; a < builders.size(); a++)
{
string path = builders[a].path;
path.Replace("\\", "/");
file.Write(S_FMT("\t%s \"%s\"\n", builders[a].id, path));
}
file.Write("}\n");
}
// Unpacking.
bool LoadEntries(wxFile& dec_pkg_f, PKGHeader* m_header, PKGEntry *m_entries)
{
dec_pkg_f.Seek(0);
dec_pkg_f.Read(m_entries, sizeof(PKGEntry) * m_header->file_count);
if (m_entries->name_offset / sizeof(PKGEntry) != m_header->file_count) {
ConLog.Error("PKG: Entries are damaged!");
return false;
}
return true;
}
