void CRIFFChunkTreeDlg::OnSave()
{
OPENFILENAME ofn;
PrepareSimpleDialog(&ofn, *this, "*.txt");
ofn.lpstrFilter = "Text files (*.txt)|*.txt||";
ofn.Flags |= OFN_OVERWRITEPROMPT;
if (!GetOpenSaveFileNameUTF8(&ofn, false))
return;
CFileStream* destFile = new CFileStream();
if (STREAM_OK == destFile->Open(ofn.lpstrFile, StreamMode::Write))
{
CACHE* cache = new CACHE(4, 1<<18);
cache->Open(destFile, CACHE_OPEN_WRITE);
cache->Write(cUTF8Hdr, 3);
RenderItem(cache, m_Tree.GetRootItem(), 0);
cache->Close();
delete cache;
destFile->Close();
delete destFile;
}
else
{
MessageBoxHelper::CouldNotOpenFileForWrite(ofn.lpstrFile);
}
}
//////////////////////////////////////////////////////////////////////
// CShader
//////////////////////////////////////////////////////////////////////
bool CShader::LoadSource(const std::string& filename, const std::string& prefix)
{
if(filename.empty())
return true;
CFileStream file;
std::string path = "special://xbmc/system/shaders/";
path += CServiceBroker::GetRenderSystem()->GetShaderPath(filename);
path += filename;
if(!file.Open(path))
{
CLog::Log(LOGERROR, "CYUVShaderGLSL::CYUVShaderGLSL - failed to open file %s", filename.c_str());
return false;
}
getline(file, m_source, '\0');
size_t pos = 0;
size_t versionPos = m_source.find("#version");
if (versionPos != std::string::npos)
{
versionPos = m_source.find("\n", versionPos);
if (versionPos != std::string::npos)
pos = versionPos + 1;
}
m_source.insert(pos, prefix);
return true;
}
bool CDungeonConfig::Load(CFileStream&file)
{
file.ReadUInt( m_nDungeonID );
short nCount = 0;
file.ReadShort(nCount) ;
file.ReadString(m_strDungeonName, nCount);
file.ReadShort(nCount) ;
file.ReadString(m_strIconName, nCount);
file.ReadShort(nCount) ;
file.ReadString(m_strIconAtlas, nCount);
file.ReadUInt(m_nStoryID);
unsigned short nParcloseCount = 0;
file.ReadUShort( nParcloseCount );
for ( unsigned int i = 0 ;i < nParcloseCount; ++i )
{
unsigned int nParcloseID = 0;
file.ReadUInt( nParcloseID );
m_ParcloseList.push_back( nParcloseID );
}
return true;
}
bool CShader::InsertSource(const std::string& filename, const std::string& loc)
{
if(filename.empty())
return true;
CFileStream file;
std::string temp;
std::string path = "special://xbmc/system/shaders/";
path += CServiceBroker::GetRenderSystem()->GetShaderPath(filename);
path += filename;
if(!file.Open(path))
{
CLog::Log(LOGERROR, "CShader::InsertSource - failed to open file %s", filename.c_str());
return false;
}
getline(file, temp, '\0');
size_t locPos = m_source.find(loc);
if (locPos == std::string::npos)
{
CLog::Log(LOGERROR, "CShader::InsertSource - could not find location %s", loc.c_str());
return false;
}
m_source.insert(locPos, temp);
return true;
}
CFileStream* CFileStream::NewL(TDesC& aFileName, TBool aIsWrite)
{
CFileStream* r = new(ELeave) CFileStream(aIsWrite);
CleanupStack::PushL(r);
r->ConstructL(aFileName);
CleanupStack::Pop();
return r;
}
//???remove from here? make user use readers/writers directly?
void CDataServer::SavePRM(const nString& FileName, PParams Content)
{
if (!Content.isvalid()) return;
CFileStream File;
if (!File.Open(FileName, SAM_WRITE)) return;
CBinaryWriter Writer(File);
Writer.WriteParams(*Content);
}
void CGlobalMshLoader::SaveMeshToFile(const CMesh::TMeshContainer &mesh, const nstring &file)
{
CFileStream sfile;
sfile.Open(file, true, false);
SaveMeshToStream(mesh, &sfile);
sfile.Close();
}
int main(int argc, char* argv[])
{
CFileStream stream;
stream.open("./test.txt","wb+");
stream.write("aaa", 3);
stream.close();
return 0;
}
bool CTargetConfig::Load(CFileStream&file)
{
file.ReadUInt( m_nTargetID );
short nCount = 0;
file.ReadShort(nCount) ;
file.ReadString(m_strDesc, nCount);
file.ReadUInt( m_nFlag );
nCount = 0;
file.ReadShort(nCount) ;
file.ReadString(m_strValue, nCount);
unsigned short nStarValueCount = 0;
file.ReadUShort(nStarValueCount);
for (unsigned short i = 0 ; i < nStarValueCount; ++i)
{
unsigned short nStarCount = 0;
unsigned int nStarValue = 0;
file.ReadUShort(nStarCount);
file.ReadUInt(nStarValue);
m_mapStarValue[nStarCount] = nStarValue;
}
return true;
}
void CLuckDrawPrizeBase::LoadFromFile(CFileStream &file)
{
// Factory loads m_nType outside.
file.ReadUChar(m_nLevel);
file.ReadUChar(m_nSexNeed);
file.ReadBool(m_bAnnounce);
ASSERT(m_nType < ELuckDrawPrizeType_Max);
ASSERT(m_nLevel < ELuckDrawPrizeLevel_Max);
ASSERT(m_nSexNeed < ESexType_Max);
}
CMesh::TMeshContainer &CGlobalMshLoader::LoadMeshFromFile(const nstring &file)
{
CFileStream sfile;
sfile.Open(file);
LoadMeshFromStream(&sfile);
sfile.Close();
return gMeshBuffer;
}
void CMedalCfgMgr::LoadConfigFromFile()
{
std::string strFileName( g_sPath );
strFileName.append( MEDAL_FILE_NAME );
CFileStream file;
file.open( strFileName.c_str(), "rb" );
LoadMedalConfigFromFile( file );
LoadProgressConfigFromFile( file );
file.close();
}
bool CDocument::SaveToFile(const std::wstring& wsPath)
{
CFileStream* pStream = new CFileStream();
if (!pStream || !pStream->OpenFile(wsPath, true))
return false;
if (m_pJbig2)
m_pJbig2->FlushStreams();
SaveToStream((CStream*)pStream);
delete pStream;
return true;
}
bool CThemeDropConfig::Load(CFileStream&file)
{
file.ReadUInt( m_nThemeID );
CMainlineDropConfig::Load( file );
return true;
}
bool CThemeParcloseConfig::Load(CFileStream & file)
{
file.ReadUInt(m_nThemeID);
CParcloseConfig::Load(file);
return true;
}
bool CThemeParcloseConfig::Save(CFileStream & file)
{
file.WriteUInt(m_nThemeID);
CParcloseConfig::Save(file);
return true;
}
bool CThemeDropConfig::Save(CFileStream&file)
{
file.WriteUInt( m_nThemeID );
CMainlineDropConfig::Save( file );
return true;
}
//////////////////////////////////////////////////////////////////////
// CShader
//////////////////////////////////////////////////////////////////////
bool CShader::LoadSource(const string& filename, const string& prefix)
{
if(filename.empty())
return true;
CFileStream file;
if(!file.Open("special://xbmc/system/shaders/" + filename))
{
CLog::Log(LOGERROR, "CYUVShaderGLSL::CYUVShaderGLSL - failed to open file %s", filename.c_str());
return false;
}
getline(file, m_source, '\0');
m_source.insert(0, prefix);
return true;
}
bool CShader::AppendSource(const string& filename)
{
if(filename.empty())
return true;
CFileStream file;
string temp;
if(!file.Open("special://xbmc/system/shaders/" + filename))
{
CLog::Log(LOGERROR, "CShader::AppendSource - failed to open file %s", filename.c_str());
return false;
}
getline(file, temp, '\0');
m_source.append(temp);
return true;
}
void CMemoryStream::LoadFrom( const char* lpszFileName )
{
CFileStream* pStream = new CFileStream();
#ifdef SCUT_UPHONE
if (pStream->Open(lpszFileName, PO_CREAT | PO_RDWR | PO_BINARY, PS_IREAD | PS_IWRITE) == 0)
{
this->LoadFrom(pStream);
delete pStream;
}
#else
if (pStream->Open(lpszFileName, 0, 0, "rb") == 0)
{
this->LoadFrom(pStream);
delete pStream;
}
#endif
}
void CBaseMemoryStream::SaveTo( const char* lpszFileName )
{
CFileStream* fs = new CFileStream();
#ifdef SCUT_UPHONE
if (fs->Open(lpszFileName, PO_CREAT | PO_RDWR | PO_BINARY, PS_IREAD | PS_IWRITE) == 0)
{
this->SaveTo(fs);
delete fs;
}
#else
if (fs->Open(lpszFileName, 0, 0, "wb+") == 0)
{
this->SaveTo(fs);
delete fs;
}
#endif
}
bool CPlayList::Load(const std::string& strFileName)
{
Clear();
m_strBasePath = URIUtils::GetDirectory(strFileName);
CFileStream file;
if (!file.Open(strFileName))
return false;
if (file.GetLength() > 1024*1024)
{
CLog::Log(LOGWARNING, "%s - File is larger than 1 MB, most likely not a playlist", __FUNCTION__);
return false;
}
return LoadData(file);
}
TiXmlElement *CSmartPlaylist::OpenAndReadName(const CStdString &path)
{
CFileStream file;
if (!file.Open(path))
{
CLog::Log(LOGERROR, "Error loading Smart playlist %s (failed to read file)", path.c_str());
return NULL;
}
m_xmlDoc.Clear();
file >> m_xmlDoc;
if (m_xmlDoc.Error())
{
CLog::Log(LOGERROR, "Error loading Smart playlist (failed to parse xml: %s)", m_xmlDoc.ErrorDesc());
return NULL;
}
TiXmlElement *root = m_xmlDoc.RootElement();
if (!root || strcmpi(root->Value(),"smartplaylist") != 0)
{
CLog::Log(LOGERROR, "Error loading Smart playlist %s", path.c_str());
return NULL;
}
// load the playlist type
const char* type = root->Attribute("type");
if (type)
m_playlistType = type;
// backward compatibility:
if (m_playlistType == "music")
m_playlistType = "songs";
if (m_playlistType == "video")
m_playlistType = "musicvideos";
// load the playlist name
TiXmlHandle name = ((TiXmlHandle)root->FirstChild("name")).FirstChild();
if (name.Node())
m_playlistName = name.Node()->Value();
else
{
m_playlistName = CUtil::GetTitleFromPath(path);
if (URIUtils::GetExtension(m_playlistName) == ".xsp")
URIUtils::RemoveExtension(m_playlistName);
}
return root;
}
HRESULT CPkcs7::SaveIntoJavaClassFile(FILEHANDLE hFile,LPCOLESTR wszFileName,BOOL fClearDirty)
// Save this signed data (presumably already signed) into the right place in the class file
{
HRESULT hr = S_OK;
CFileStream stm;
if (stm.OpenFileForWriting(hFile, wszFileName, FALSE))
{
IPersistStream* pPerStream;
hr = CJavaClassFile::CreateInstance(NULL, IID_IPersistStream, (LPVOID*)&pPerStream);
if (hr == S_OK)
{
hr = pPerStream->Load(&stm); // load the class file
if (hr == S_OK)
{
BLOB b;
hr = CPersistMemoryHelper2::Save(&b, FALSE); // get our bits
if (hr == S_OK)
{
IInsertSig* pSig;
hr = pPerStream->QueryInterface(IID_IInsertSig, (LPVOID*)&pSig);
if (hr == S_OK)
{
hr = pSig->SaveSig(&b); // stuff our bits in
pSig->Release();
}
FreeTaskMem(b);
}
if (hr == S_OK)
{
stm.Reset();
stm.Truncate();
hr = pPerStream->Save(&stm, FALSE); // save the class file
}
}
pPerStream->Release();
}
}
else
hr = HError();
if (hr == S_OK && fClearDirty)
m_isDirty = FALSE;
return hr;
}
bool CStoryConfig::Load(CFileStream&file)
{
file.ReadUInt( m_nStoryID );
unsigned short nNPCListCount = 0;
file.ReadUShort( nNPCListCount );
for ( unsigned int i = 0 ;i < nNPCListCount; ++i )
{
unsigned int nNPCID = 0;
file.ReadUInt( nNPCID );
m_NPCList.push_back( nNPCID );
}
unsigned short nContentCount = 0;
file.ReadUShort( nContentCount );
for ( unsigned int i = 0 ;i < nContentCount; ++i )
{
CStoryContent content;
file.ReadUInt( content.m_nNPCID );
short nCount = 0;
file.ReadShort(nCount) ;
file.ReadString(content.m_strContent, nCount);
m_ContentList.push_back( content );
}
return true;
}
int ExtractThread(EXTRACT_THREAD_VIDEO_DATA* lpETD)
{
lpETD->dlg->SetDialogState_Muxing();
lpETD->dlg->ButtonState_START();
lpETD->dlg->AddProtocolLine("started extracting binary", 4);
VIDEOSOURCE* v = lpETD->v;
v->Enable(1);
CFileStream* f = lpETD->file;
char cTime[20];
char* lpBuffer = new char[2<<20];
int iLastTime = GetTickCount();
v->ReInit();
while (!v->IsEndOfStream() && !DoStop()) {
__int64 iTimecode;
__int64 iNS = 0;
DWORD dwSize;
v->GetFrame(lpBuffer,&dwSize,&iTimecode);
f->Write(lpBuffer,dwSize);
if (GetTickCount()-iLastTime>100 || v->IsEndOfStream()) {
Millisec2Str((iTimecode * v->GetTimecodeScale() + iNS)/ 1000000,cTime);
CUTF8 utf8Time(cTime);
lpETD->dlg->m_Prg_Frames.SetWindowText(utf8Time.TStr());
iLastTime+=100;
}
}
lpETD->dlg->SetDialogState_Config();
lpETD->dlg->ButtonState_STOP();
delete lpBuffer;
StopMuxing(false);
lpETD->file->Close();
lpETD->dlg->AddProtocol_Separator();
delete lpETD;
v->Enable(0);
return 1;
}
void CMedalCfgMgr::LoadProgressConfigFromFile( CFileStream &rFileStream )
{
if ( !rFileStream.IsOpen() )
return;
m_mapMedalProgressCfg.clear();
unsigned short nCount = 0;
rFileStream.ReadUShort( nCount );
for ( unsigned short i = 0; i < nCount; ++i )
{
CMedalProgressCfg processInfo;
if ( processInfo.LoadInfoFromFile( rFileStream ) )
{
m_mapMedalProgressCfg.insert( std::make_pair( processInfo.GetId(), processInfo ) );
}
}
}
bool CShader::AppendSource(const std::string& filename)
{
if(filename.empty())
return true;
CFileStream file;
std::string temp;
std::string path = "special://xbmc/system/shaders/";
path += CServiceBroker::GetRenderSystem()->GetShaderPath(filename);
path += filename;
if(!file.Open(path))
{
CLog::Log(LOGERROR, "CShader::AppendSource - failed to open file %s", filename.c_str());
return false;
}
getline(file, temp, '\0');
m_source.append(temp);
return true;
}
DWORD CDataServer::LoadFileToBuffer(const nString& FileName, char*& Buffer)
{
CFileStream File;
int BytesRead;
if (File.Open(FileName, SAM_READ, SAP_SEQUENTIAL))
{
int FileSize = File.GetSize();
Buffer = (char*)n_malloc(FileSize);
BytesRead = File.Read(Buffer, FileSize);
File.Close();
}
else
{
Buffer = NULL;
BytesRead = 0;
}
return BytesRead;
}
PParams CDataServer::ReloadPRM(const nString& FileName, bool Cache)
{
CFileStream File;
if (!File.Open(FileName, SAM_READ)) return NULL;
CBinaryReader Reader(File);
PParams Params;
Params.Create();
if (Reader.ReadParams(*Params))
{
if (Cache) HRDCache.Add(FileName.Get(), Params); //!!!???mangle path to avoid duplicates?
n_printf("FileIO: PRM \"%s\" successfully loaded from HDD\n", FileName.Get());
}
else
{
Params = NULL;
n_printf("FileIO: PRM loading from \"%s\" failed\n", FileName.Get());
}
return Params;
}