Subversion Repositories spk

Rev

Rev 53 | Rev 62 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 53 Rev 58
Line 723... Line 723...
723
{
723
{
724
	// no file to read from
724
	// no file to read from
725
	if ( this->filename().empty() ) return;
725
	if ( this->filename().empty() ) return;
726
 
726
 
727
	// now open the file
727
	// now open the file
728
	std::fstream File(this->filename(), std::ios::in | std::ios::binary);
728
	CFileIO File(this->filename());
729
	if ( !File.is_open() ) return;
729
	if ( !File.startRead() ) return;
730
 
730
 
731
	// read the header
731
	// read the header
732
	CBaseFile::readEndOfLine(File);
732
	File.readEndOfLine();
733
	// skip past values
733
	// skip past values
734
	File.seekg(4 + m_SHeader.lValueCompressSize, std::ios::cur);
734
	File.seek(4 + m_SHeader.lValueCompressSize);
735
 
735
 
736
	// read the next header
736
	// read the next header
737
	CBaseFile::readEndOfLine(File);
737
	File.readEndOfLine();
738
	// skip past files
738
	// skip past files
739
	File.seekg(4 + m_SHeader2.lSize, std::ios::cur);
739
	File.seek(4 + m_SHeader2.lSize);
740
 
740
 
741
	if ( m_pIconFile )
741
	if ( m_pIconFile )
742
	{
742
	{
743
		if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )
743
		if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )
744
			m_pIconFile->readFromFile(File, m_pIconFile->GetDataSize());
744
			m_pIconFile->readFromFile(File, m_pIconFile->GetDataSize());
745
		else
745
		else
746
			File.seekg(4 + m_pIconFile->GetDataSize(), std::ios::cur);
746
			File.seek(4 + m_pIconFile->GetDataSize());
747
	}
747
	}
748
 
748
 
749
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
749
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
750
	{
750
	{
751
		C_File *fit = node->Data();
751
		C_File *fit = node->Data();
752
		if ( (!fit->GetData()) && (!fit->Skip()) )
752
		if ( (!fit->GetData()) && (!fit->Skip()) )
753
			fit->readFromFile(File, fit->GetDataSize());
753
			fit->readFromFile(File, fit->GetDataSize());
754
		else
754
		else
755
			File.seekg(4 + fit->GetDataSize(), std::ios::cur);
755
			File.seek(4 + fit->GetDataSize());
756
	}
756
	}
757
 
757
 
758
	File.close();
758
	File.close();
759
}
759
}
760
 
760
 
Line 763... Line 763...
763
	if ( f->GetData() && f->GetDataSize() ) return true;	// already loaded the data
763
	if ( f->GetData() && f->GetDataSize() ) return true;	// already loaded the data
764
	if ( this->filename().empty() || !f ) return false;		// no filename to load from
764
	if ( this->filename().empty() || !f ) return false;		// no filename to load from
765
	if ( !m_lFiles.FindData(f) ) return false;				// unable to find file entry
765
	if ( !m_lFiles.FindData(f) ) return false;				// unable to find file entry
766
 
766
 
767
	// now open the file
767
	// now open the file
768
	std::fstream File(this->filename(), std::ios::in | std::ios::binary);
768
	CFileIO *File = _startRead();
769
	if ( !File.is_open() ) return false;
769
	if ( !File ) return false;
770
 
-
 
771
	// read the header
-
 
772
	CBaseFile::readEndOfLine(File, NULL, false);
-
 
773
	// skip past values
-
 
774
	File.seekg(4 + m_SHeader.lValueCompressSize, std::ios::cur);
-
 
775
 
-
 
776
	// read the next header
-
 
777
	CBaseFile::readEndOfLine(File, NULL, false);
-
 
778
	// skip past files
-
 
779
	File.seekg(4 + m_SHeader2.lSize, std::ios::cur);
-
 
780
 
770
 
781
	if ( m_pIconFile ) File.seekg(4 + m_pIconFile->GetDataSize(), std::ios::cur);
771
	if ( m_pIconFile ) File->seek(4 + m_pIconFile->GetDataSize());
782
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
772
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
783
		C_File *fit = node->Data();
773
		C_File *fit = node->Data();
784
		if (fit == f ) {
774
		if (fit == f ) {
785
			fit->readFromFile(File, fit->GetDataSize());
775
			fit->readFromFile(*File, fit->GetDataSize());
786
			break;
776
			break;
787
		}
777
		}
788
		else File.seekg(4 + fit->GetDataSize(), std::ios::cur);
778
		else File->seek(4 + fit->GetDataSize());
789
	}
779
	}
790
 
780
 
791
	File.close();
781
	delete File;
792
	return true;
782
	return true;
793
}
783
}
794
 
784
 
795
void CBaseFile::ReadIconFileToMemory ()
785
CFileIO *CBaseFile::_startRead()
796
{
786
{
797
	// no file to read from
787
	// no file to read from
798
	if ( this->filename().empty() )
788
	if ( this->filename().empty() ) return NULL;
799
		return;
-
 
800
 
-
 
801
	if ( !m_pIconFile )
-
 
802
		return;
-
 
803
 
789
 
804
	// now open the file
790
	// now open the file
805
	std::fstream stream(this->filename(), std::ios::in | std::ios::binary);
791
	CFileIO *File = new CFileIO(this->filename());
806
	if ( !stream.is_open() ) return;
792
	if ( !File->startRead() ) return NULL;
807
 
793
 
808
	// read the header
794
	// read the header
809
	CBaseFile::readEndOfLine(stream, NULL, false);
795
	File->readEndOfLine();
810
	// skip past values
796
	// skip past values
811
	stream.seekg(4 + m_SHeader.lValueCompressSize, std::ios::cur);
797
	File->seek(4 + m_SHeader.lValueCompressSize);
812
 
798
 
813
	// read the next header
799
	// read the next header
814
	CBaseFile::readEndOfLine(stream, NULL, false);
800
	File->readEndOfLine();
815
	// skip past files
801
	// skip past files
816
	stream.seekg(4 + m_SHeader2.lSize, std::ios::cur);
802
	File->seek(4 + m_SHeader2.lSize);
817
 
803
 
818
	if ( m_pIconFile ) {
804
	return File;
819
		if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )
-
 
820
			m_pIconFile->readFromFile(stream, m_pIconFile->GetDataSize() );
-
 
821
		else
-
 
822
			stream.seekg(4 + m_pIconFile->GetDataSize(), std::ios::cur);
-
 
823
	}
805
}
824
 
806
 
-
 
807
void CBaseFile::ReadIconFileToMemory ()
-
 
808
{
-
 
809
	if ( !m_pIconFile )	return;
-
 
810
	CFileIO *File = _startRead();
-
 
811
	if ( !File ) return;
-
 
812
 
-
 
813
	if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )
-
 
814
		m_pIconFile->readFromFile(*File, m_pIconFile->GetDataSize());
-
 
815
	else
-
 
816
		File->seek(4 + m_pIconFile->GetDataSize());
-
 
817
 
825
	stream.close();
818
	delete File;
826
}
819
}
827
 
820
 
828
void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)
821
void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)
829
{
822
{
830
	CyStringList lPatches;
823
	CyStringList lPatches;
Line 1571... Line 1564...
1571
	Return: boolean - return ture if acceptable format
1564
	Return: boolean - return ture if acceptable format
1572
	Desc:   Opens and reads the spk file and loads all data into class
1565
	Desc:   Opens and reads the spk file and loads all data into class
1573
*/
1566
*/
1574
bool CBaseFile::ReadFile ( CyString filename, int readtype, CProgressInfo *progress )
1567
bool CBaseFile::ReadFile ( CyString filename, int readtype, CProgressInfo *progress )
1575
{
1568
{
1576
	std::fstream stream(filename.ToString().c_str(), std::ios::in | std::ios::binary);
1569
	CFileIO File(filename.ToString());
1577
	if ( !stream.is_open() ) return false;
1570
	if ( !File.startRead() ) return false;
1578
 
1571
 
1579
	bool ret = this->readFile(stream, readtype, progress);
1572
	bool ret = this->readFile(File, readtype, progress);
1580
	if ( ret ) this->setFilename(filename.ToString());
1573
	if ( ret ) this->setFilename(filename.ToString());
1581
 
1574
 
1582
	stream.close();
1575
	File.close();
1583
	return ret;
1576
	return ret;
1584
}
1577
}
1585
 
1578
 
1586
int CBaseFile::_read_Header(std::fstream &stream, int iReadType, int iMaxProgress, CProgressInfo *pProgress)
1579
int CBaseFile::_read_Header(std::fstream &stream, int iReadType, int iMaxProgress, CProgressInfo *pProgress)
1587
{
1580
{
Line 1687... Line 1680...
1687
 
1680
 
1688
	delete []readData;
1681
	delete []readData;
1689
	return true;
1682
	return true;
1690
}
1683
}
1691
 
1684
 
1692
bool CBaseFile::readFile(std::fstream &stream, int readtype, CProgressInfo *progress)
1685
bool CBaseFile::readFile(CFileIO &File, int readtype, CProgressInfo *progress)
1693
{
1686
{
1694
	ClearError ();
1687
	ClearError ();
1695
 
1688
 
1696
	// first read the header
1689
	// first read the header
1697
	if ( !ParseHeader(CBaseFile::readEndOfLine(stream, NULL, false)) ) return false;
1690
	if ( !ParseHeader(File.readEndOfLine()) ) return false;
1698
	if ( readtype == SPKREAD_HEADER ) return true;
1691
	if ( readtype == SPKREAD_HEADER ) return true;
1699
 
1692
 
1700
	// update the progress for each section
1693
	// update the progress for each section
1701
	int maxProgress = (readtype == SPKREAD_VALUES) ? 3 : 6;
1694
	int maxProgress = (readtype == SPKREAD_VALUES) ? 3 : 6;
1702
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(1, maxProgress);
1695
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(1, maxProgress);
1703
 
1696
 
1704
	long doneLen = 0;
1697
	long doneLen = 0;
1705
	// next read the data values for the spk files
1698
	// next read the data values for the spk files
1706
	if ( m_SHeader.lValueCompressSize ) doneLen = this->_read_Header(stream, readtype, maxProgress, progress);
1699
	if ( m_SHeader.lValueCompressSize ) doneLen = this->_read_Header(File.stream(), readtype, maxProgress, progress);
1707
 
1700
 
1708
	// update the progress for each section
1701
	// update the progress for each section
1709
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(3, maxProgress);
1702
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(3, maxProgress);
1710
	if ( readtype == SPKREAD_VALUES ) return true;
1703
	if ( readtype == SPKREAD_VALUES ) return true;
1711
 
1704
 
1712
	// next should be the next header
1705
	// next should be the next header
1713
	if ( !ParseFileHeader(CBaseFile::readEndOfLine(stream, NULL, false)) ) return false;
1706
	if ( !ParseFileHeader(File.readEndOfLine()) ) return false;
1714
 
1707
 
1715
	// clear the current file list
1708
	// clear the current file list
1716
	m_lFiles.clear(true);
1709
	m_lFiles.clear(true);
1717
 
1710
 
1718
	// update the progress for each section
1711
	// update the progress for each section
1719
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(4, maxProgress);
1712
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(4, maxProgress);
1720
 
1713
 
1721
	if ( m_SHeader2.lSize ) this->_read_FileHeader(stream, readtype, maxProgress, doneLen, progress);
1714
	if ( m_SHeader2.lSize ) this->_read_FileHeader(File.stream(), readtype, maxProgress, doneLen, progress);
1722
 
1715
 
1723
	// file mismatch
1716
	// file mismatch
1724
	long numfiles = m_lFiles.size();
1717
	long numfiles = m_lFiles.size();
1725
	if ( m_pIconFile ) ++numfiles;
1718
	if ( m_pIconFile ) ++numfiles;
1726
	if ( m_SHeader2.iNumFiles != numfiles ) {
1719
	if ( m_SHeader2.iNumFiles != numfiles ) {
Line 1731... Line 1724...
1731
	// update the progress for each section
1724
	// update the progress for each section
1732
	if ( readtype != SPKREAD_ALL && progress )	progress->UpdateProgress(6, maxProgress);
1725
	if ( readtype != SPKREAD_ALL && progress )	progress->UpdateProgress(6, maxProgress);
1733
 
1726
 
1734
	if ( readtype == SPKREAD_ALL ) {
1727
	if ( readtype == SPKREAD_ALL ) {
1735
		int fileCount = 2;
1728
		int fileCount = 2;
1736
		if ( m_pIconFile ) m_pIconFile->readFromFile(stream, m_pIconFile->GetDataSize() );
1729
		if ( m_pIconFile ) m_pIconFile->readFromFile(File, m_pIconFile->GetDataSize());
1737
 
1730
 
1738
		// ok finally we need to read all the file
1731
		// ok finally we need to read all the file
1739
		for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
1732
		for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
1740
			node->Data()->readFromFile(stream, node->Data()->GetDataSize() );
1733
			node->Data()->readFromFile(File, node->Data()->GetDataSize());
1741
			if ( progress )	progress->UpdateProgress(fileCount++, m_lFiles.size() + 2);
1734
			if ( progress )	progress->UpdateProgress(fileCount++, m_lFiles.size() + 2);
1742
		}
1735
		}
1743
 
1736
 
1744
		m_bFullyLoaded = true;
1737
		m_bFullyLoaded = true;
1745
	}
1738
	}
Line 2054... Line 2047...
2054
	// no file to read from
2047
	// no file to read from
2055
	if ( this->filename().empty() )
2048
	if ( this->filename().empty() )
2056
		return false;
2049
		return false;
2057
 
2050
 
2058
	// now open the file
2051
	// now open the file
2059
	CFileIO File(this->filename());
2052
	CFileIO *File = _startRead();
2060
	if ( !File.StartRead() ) return false;
2053
	if ( !File ) return false;
2061
 
-
 
2062
	// read the header
-
 
2063
	File.readEndOfLine();
-
 
2064
	// skip past values
-
 
2065
	File.seek(m_SHeader.lValueCompressSize);
-
 
2066
 
-
 
2067
	// read the next header
-
 
2068
	File.readEndOfLine();
-
 
2069
	// skip past files
-
 
2070
	File.seek(4 + m_SHeader2.lSize);
-
 
2071
 
2054
 
2072
	// now were in the file section
2055
	// now were in the file section
2073
	// skip past each one
2056
	// skip past each one
2074
	if ( m_pIconFile ) File.seek(4 + m_pIconFile->GetDataSize ());
2057
	if ( m_pIconFile ) File->seek(4 + m_pIconFile->GetDataSize ());
2075
 
2058
 
2076
	CDirIO Dir(dir);
2059
	CDirIO Dir(dir);
2077
 
2060
 
2078
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
2061
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
2079
		C_File *fit = node->Data();
2062
		C_File *fit = node->Data();
2080
 
2063
 
2081
		if ( progress )	progress->UpdateFile ( fit );
2064
		if ( progress )	progress->UpdateFile ( fit );
2082
 
2065
 
2083
		if ( (!fit->GetDataSize ()) || (!fit->GetData()) ) {
2066
		if ( (!fit->GetDataSize ()) || (!fit->GetData()) ) {
2084
			if ( !fit->readFromFile(File, fit->GetDataSize()) ) return false;
2067
			if ( !fit->readFromFile(*File, fit->GetDataSize()) ) return false;
2085
		}
2068
		}
2086
		else
2069
		else
2087
			File.seek(fit->GetDataSize());
2070
			File->seek(fit->GetDataSize());
2088
 
2071
 
2089
		if ( game ) {
2072
		if ( game ) {
2090
			if ( fit->GetGame() && fit->GetGame() != game )
2073
			if ( fit->GetGame() && fit->GetGame() != game )
2091
				continue;
2074
				continue;
2092
		}
2075
		}
Line 2100... Line 2083...
2100
			if ( !fit->UncompressToFile ( dir, this, includedir, progress ) ) return false;
2083
			if ( !fit->UncompressToFile ( dir, this, includedir, progress ) ) return false;
2101
		}
2084
		}
2102
		else if ( (!data) || (!fit->WriteToDir ( dir, this, includedir, NullString, data, size )) ) return false;
2085
		else if ( (!data) || (!fit->WriteToDir ( dir, this, includedir, NullString, data, size )) ) return false;
2103
	}
2086
	}
2104
 
2087
 
2105
	File.close();
2088
	delete File;
2106
	return true;
2089
	return true;
2107
}
2090
}
2108
 
2091
 
2109
 
2092
 
2110
 
2093