gssource.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 556 行

// GsSource.cpp: implementation of the CGsSource class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#pragma pack(push, 1)
struct	t_gss_file_head
{
	char	strVersion[16];
	char	strData[PATH_SIZE];
	int		nCount;
	DWORD	posData;
	DWORD	temp_num;

};
#pragma pack(pop)


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGsSource::CGsSource()
{
	m_temp_num	= 0;
	strcpy(m_data, "");
	strcpy(m_data_path, "");
	strcpy(m_gss_file, "");
	m_isModify	= false;
}

CGsSource::~CGsSource()
{
	Cleanup();
}

static	GSFILE_INFO g_temp_fi;

GSFILE_INFO*	CGsSource::FindSource(const char* key)
{
	if(CGsFunc::Path_IsSysPath(key))
	{
		strcpy(g_temp_fi.strFile, key);
		g_temp_fi.fft = CGsFunc::File_GetFFT(key);
		return &g_temp_fi;
	}

	std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.find(key);
	if(it==m_file_map.end())
	{
		return NULL;
	}
	else
	{
		return &it->second;
	}
}

VOID CGsSource::SetFileType(const char *strkey, FFT fft)
{
	std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.find(strkey);
	if(it!=m_file_map.end())
	{
		it->second.fft	= fft;
		if(m_isModify==FALSE)
		{
			m_isModify = TRUE;
			OnSetModify();
		}
		m_isModify	= TRUE;
	}

}



BOOL	CGsSource::AddSource(char* szfile)
{

	return true;
}

const char* CGsSource::AddFile(const char* key, FFT type)
{
	if(CGsFunc::Path_IsSysPath(key))
		return key;

	if(m_gss_file[0]==0 || !IsReady())
		return NULL;

	char	strKey_c[PATH_SIZE];
	CGsFunc::Path_RectifyPath(strKey_c, key);

//	if(m_file_map.end()==m_file_map.find(strKey_c))
//		return NULL;

	GSFILE_INFO* pfi	= FindSource(key);
	if(pfi!=NULL)
	{
		pfi->fft	= type;
	}
	else
	{
		GSFILE_INFO	tf;
		memset(&tf, 0, sizeof(tf));
		if(type==GSF_FOLDER)
		{
			strKey_c[strlen(strKey_c)] = '\\';
			strcpy(tf.strFile, "");
		}
		else
		{
			if(type==GSF_DDS)
			{
				sprintf(tf.strFile, "%s\\%08d.dds", m_data_path, m_temp_num);
			}
			else
			{
				sprintf(tf.strFile, "%s\\%08d.gs_", m_data_path, m_temp_num);
			}
			CGsFunc::Path_RectifyPath(tf.strFile);
			m_temp_num++;
		}
		tf.fft	= type;
		tf.pos_begin = 0;
		tf.file_size = 0;
		m_file_map.insert(std::map<KEY, GSFILE_INFO>::value_type(KEY(strKey_c), tf));
	}

	std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.find(KEY(strKey_c));
	if(it==m_file_map.end())
		return NULL;
	else
	{
		if(m_isModify==false)
		{
			m_isModify = TRUE;
			OnSetModify();
		}
		m_isModify	= TRUE;
//		GSFILE ff = it->second;


		return it->second.strFile;
	}
}


VOID	CGsSource::Cleanup()
{
	
	std::map<KEY, GSFILE_INFO>::iterator	it	= m_file_map.begin();
	while(it!=m_file_map.end())
	{
		if(it->second.fft>=GSF_FNT && it->second.fft<=GSF_FOT)
		{
			CGsFunc::Font_RemoveResource(it->second.strFile);
		}
		it++;
	}


	Save();
	m_file_map.clear();
//	m_file_array.clear();
	m_temp_num	= 0;
	strcpy(m_data, "");
	strcpy(m_data_path, "");
	strcpy(m_gss_file, "");
	OnSetModify();
	m_isModify	= false;
	
}



BOOL CGsSource::Load(const char *strFile)
{ 
//	char temp_path[PATH_SIZE];
//	::GetCurrentDirectory(PATH_SIZE, temp_path);
	char strTemp[PATH_SIZE];
	CGsFunc::Path_MakeFullPath(strTemp, strFile);
	Cleanup();
	fstream		fs;
	fs.open(strTemp, ios::in | ios::out | ios::binary );
	if(!fs)
	{
		return false;
	}

	t_gss_file_head		head;
	fs.read((char*)&head, sizeof(head));

	if(KEY(head.strVersion)!="GSS2003a")
	{
		fs.close();
		return FALSE;
	}

	strcpy(m_data, head.strData);
	m_temp_num	= head.temp_num;

	char	szTemp[PATH_SIZE];

	strcpy(m_gss_file, strTemp);
	CGsFunc::Path_GetParentPath(m_data_path, m_gss_file);
	strcat(m_data_path, "\\");
	strcat(m_data_path, m_data);
	CGsFunc::Path_RectifyPath(m_data_path);

//	strcpy(szTemp, m_gss_file);
//	char*	sz	= strrchr(szTemp, '\\');
//	if(sz)
//		*sz=0;
//	else
//		szTemp[0]	= 0;
//	sprintf(g_szWorkPath, "%s\\%s", szTemp, (LPCSTR)g_szWorkData);


	fs.seekp(head.posData, ios::beg);


	GSFILE_INFO	gsstf;
	for(int i=0; i<head.nCount; i++)
	{
		fs.read(szTemp, PATH_SIZE); 
		fs.read((char*)&gsstf, sizeof(GSFILE_INFO));
		char strTemp[PATH_SIZE];
		strcpy(strTemp, gsstf.strFile);
		sprintf(gsstf.strFile, "%s\\%s", m_data_path, strTemp);
		CGsFunc::Path_RectifyPath(gsstf.strFile);
		char	szt[PATH_SIZE];
		CGsFunc::Path_RectifyPath(szt, szTemp);
		if(gsstf.fft==GSF_FOLDER)
			szt[strlen(szt)] = '\\';
		m_file_map.insert(std::map<KEY, GSFILE_INFO>::value_type(KEY(szt), gsstf));
		if(gsstf.fft>=GSF_FNT && gsstf.fft<=GSF_FOT)
		{
			CGsFunc::Font_AddResource(gsstf.strFile);
		}
	}

	fs.close();	

	
	return TRUE;
}

BOOL CGsSource::Save()
{
	if(!m_isModify || !IsReady())
		return TRUE;
	fstream		fs;
	fs.open(m_gss_file, ios::in | ios::out | ios::binary | ios::trunc);
	if(!fs)
	{
		return false;
	}

	t_gss_file_head		head;
	strcpy(head.strVersion, "GSS2003a");
	strcpy(head.strData, m_data);
	head.nCount		= m_file_map.size();
	head.posData	= 1000;
	head.temp_num	= m_temp_num;

	fs.write((char*)&head, sizeof(head));

	fs.seekp(1000, ios::beg);

	char	szTemp[PATH_SIZE];

	std::map<KEY, GSFILE_INFO>::iterator	it	= m_file_map.begin();
	while(it!=m_file_map.end())
	{
		strcpy(szTemp, it->first.c_str());
		fs.write(szTemp, PATH_SIZE); 
		GSFILE_INFO gsf	= it->second;
		memset(gsf.strFile, 0, PATH_SIZE);
		CGsFunc::Path_GetPathFile(gsf.strFile, it->second.strFile);
		fs.write((char*)&(gsf), sizeof(GSFILE_INFO));
		it++;
	}
	fs.close();

	if(m_isModify==TRUE)
	{
		m_isModify = FALSE;
		OnSetModify();
	}
	m_isModify	= false;
	return TRUE;
}

VOID CGsSource::UpdateToBrower(GS_Src_Browser *pBrowser, BOOL bIncrease, BOOL bExcept, va_list& argptr)
{
	if(pBrowser==NULL)
		return;

	std::set<FFT> type_set;


	BOOL bAllType  = false;

	if(bExcept)
	{
		FFT i;
		for(int j=GSF_UNKNOWN; j<GSF_GSS; j++)
		{
			type_set.insert(FFT(j));
		}
		i=va_arg( argptr, FFT);
			while( i != -1 )
			{
				if(i>GSF_GSS)
					break;
				if(i==GSF_UNKNOWN)
				{
					bAllType = true;
					break;
				}
				std::set<FFT>::iterator it = type_set.find(i);

				if(it!=type_set.end())
				{
					type_set.erase(it);
				}

				i = va_arg( argptr, FFT);
			}

	}
	else
	{

	//	type_set.insert(type);
	//	va_list temp;
	//	va_start( temp, type );     /* Initialize variable arguments. */
		FFT i=va_arg( argptr, FFT);
		if(i<GSF_UNKNOWN || i>GSF_GSS)
		{
			bAllType = true;
		}
		else
		{
			while( i != -1 )
			{
				if(i>GSF_GSS)
					break;
				if(i==GSF_UNKNOWN)
				{
					bAllType = true;
					break;
				}
				type_set.insert(i);
				i = va_arg( argptr, FFT);
			}
		}
	}
//	va_end( temp );              /* Reset variable arguments.      */


	GSFILE ff;

	char	strTemp[PATH_SIZE];
	if(bIncrease)
	{
		std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.begin();
		while(it!=m_file_map.end())
		{
			const char* str = it->first.c_str();
			ff = it->second;
			if(bAllType || type_set.end()!=type_set.find(it->second.fft))
			{
				pBrowser->AddItem(it->first.c_str(), it->second.fft);
			}
			else if(type_set.end()!=type_set.find(GSF_FOLDER))
			{
				CGsFunc::Path_GetParentPath(strTemp, it->first.c_str());
				pBrowser->AddItem(strTemp, GSF_FOLDER);
			}
			it++;
		}
	}
	else
	{
		std::map<KEY, GSFILE_INFO>::reverse_iterator it = m_file_map.rbegin();
		while(it!=m_file_map.rend())
		{
			const char* str = it->first.c_str();
			ff = it->second;
			if(bAllType || type_set.end()!=type_set.find(it->second.fft))
			{
				pBrowser->AddItem(it->first.c_str(), it->second.fft);
			}
			else if(type_set.end()!=type_set.find(GSF_FOLDER))
			{
				CGsFunc::Path_GetParentPath(strTemp, it->first.c_str());
				pBrowser->AddItem(strTemp, GSF_FOLDER);
			}
			it++;
		}
	}
	type_set.clear();
}

VOID CGsSource::SetModify()
{
	if(m_isModify==FALSE)
	{
		m_isModify = TRUE;
		OnSetModify();
	}
	m_isModify	= TRUE;
}

BOOL CGsSource::IsPathExist(const char *strPath)
{
	if(!IsReady())
		return FALSE;
	if(KEY(strPath)=="\\")
		return TRUE;
	std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.lower_bound(KEY(strPath));
	if(it!=m_file_map.end() && 0==it->first.find(strPath, 0))
	{
		return TRUE;
	}
	return FALSE;
}


VOID CGsSource::DeleteFile(const char *key)
{
	if(CGsFunc::Path_IsSysPath(key))
	{
//		CGsFunc::File_Delete(key);
		return;
	}
	if(!IsReady())
		return;
//	if(len==0)
//	{
//		m_file_map.clear();
//		m_isModify
//	}
	char strTemp[PATH_SIZE];
	CGsFunc::Path_GetParentPath(strTemp, key);
	int len = strlen(strTemp);
	strTemp[len]='\\';
	strTemp[len+1]=0;

	std::map<KEY, GSFILE_INFO>::iterator it = m_file_map.lower_bound(KEY(key));
	while(it!=m_file_map.end() && 0==it->first.find(key, 0))
	{
		_DeleteFile(it);
	}
	if(!IsPathExist(strTemp))
	{
		AddFile(strTemp);
	}

}

VOID CGsSource::_DeleteFile(std::map<KEY, GSFILE_INFO>::iterator &it)
{
	KEY key = it->first;
	if(key.at(key.length()-1)=='\\')
	{
		it++;
		while(it!=m_file_map.end() && 0==it->first.find(key, 0))
		{
			_DeleteFile(it);
			it++;
		}
		it = m_file_map.find(key);
		it = m_file_map.erase(it);
		if(m_isModify==FALSE)
		{
			m_isModify = TRUE;
			OnSetModify();
		}
		m_isModify = TRUE;
	}
	else
	{
		if(it->second.fft>=GSF_FNT && it->second.fft<=GSF_FOT)
		{
			CGsFunc::Font_RemoveResource(it->second.strFile);
		}
		CGsFunc::File_Delete(it->second.strFile);
		it = m_file_map.erase(it);
		if(m_isModify==FALSE)
		{
			m_isModify = TRUE;
			OnSetModify();
		}
		m_isModify = TRUE;
	}
}

const char* CGsSource::ImportFile(const char *key, const char *strFile)
{
	if(CGsFunc::Path_IsSysPath(key))
	{
//		if(CGsFunc::File_CopyTo(strFile, key))
//			return strFile;
		return NULL;
	}
	
	if(!IsReady())
		return NULL;
	FFT ft = CGsFunc::File_GetFFT(strFile);
	if(NULL==AddFile(key, ft))
		return NULL;
	GSFILE_INFO* pfi = FindSource(key);
	if(NULL==pfi)
		return NULL;
	if(CGsFunc::File_CopyTo(strFile, pfi->strFile))
	{
		if(m_isModify==FALSE)
		{
			m_isModify = TRUE;
			OnSetModify();
		}
		m_isModify = TRUE;
		CGsFunc::File_UpdateInfo(pfi);
		if(pfi->fft>=GSF_FNT && pfi->fft<=GSF_FOT)
		{
			CGsFunc::Font_AddResource(pfi->strFile);
		}
		return pfi->strFile;
	}
	else
	{
		return NULL;
	}
}

BOOL CGsSource::ExportFile(const char *key, const char *strFile)
{
	if(CGsFunc::Path_IsSysPath(key))
	{
		return CGsFunc::File_CopyTo(key, strFile);
	}
	if(!IsReady())
		return FALSE;
	GSFILE_INFO* pfi = FindSource(key);
	if(NULL==pfi)
		return FALSE;
	return CGsFunc::File_CopyTo(pfi->strFile, strFile);

}