Esempio n. 1
0
BLOCK* get_block(int block_size){
	CVFS* vfs = getVFS();
	BLOCK *ret = vfs->free,*suit;
	int max = 0;

	//return the data block of specified size
	//or greatest block smaller than specified block
	while(ret!=NULL){
		if(ret->size>block_size){
			BLOCK* found = new BLOCK();
			found->offset =ret->offset;
			found->size = block_size;
			found->next = NULL;
			found->prev = NULL;
			ret->offset = ret->offset+block_size;
			ret->size-=block_size;
			return found;
		}
		if(ret->size==block_size){
			ret->prev->next = ret->next;
			ret->next->prev = ret->prev;
			return ret;
		}
		if(ret->size>max){
			max = ret->size;
			suit = ret;
		}
	}
	return suit;
}
Esempio n. 2
0
void Loc::ImportStrings()
{
	Loc::AssociateWithFile(Loc::AIM_BIOGRAPHY,	L"Localization/AimBiographies.xml");
	Loc::AssociateWithFile(Loc::AIM_HISTORY,	L"Localization/AimHistory.xml");
	Loc::AssociateWithFile(Loc::AIM_POLICY,		L"Localization/AimPolicy.xml");
	Loc::AssociateWithFile(Loc::GAME_STRINGS,	L"Localization/GameStrings.xml");

	vfs::String bio, add, bio2;
	Loc::GetString(Loc::AIM_BIOGRAPHY,L"Bio",L"0",add);
	Loc::GetString(Loc::AIM_BIOGRAPHY,L"Add",L"10",bio);
	Loc::GetString(Loc::AIM_BIOGRAPHY,L"Bio",23,bio2);

	for(int i=0; i<200; ++i)
	{
		std::wstringstream wss;
		for(int exp=2; exp>=0; --exp)
		{
			int t = (int)std::pow((double)10,(double)exp);
			wss << (i % (t*10)) / t;
		}
		vfs::String s = wss.str() + L".EDT.xml";
		vfs::Path filename(L"Localization/Dialogue");
		filename += vfs::Path(s);
		if(getVFS()->fileExists(filename))
		{
			Loc::AssociateWithFile(Loc::DIALOGUE,filename,vfs::toString<wchar_t>(i));
		}
	}
}
Esempio n. 3
0
//list free blocks in the disk
void list_free_blocks(){
	CVFS* vfs = getVFS();
	BLOCK *move = vfs->free;

	while(move != NULL){
		printf("offset %d : size %d\n",move->offset,move->size);
		move = move->next;
	}
}
Esempio n. 4
0
//list all files in the file table
void listFiles(){
	CVFS *vfs = getVFS();
	FT* trav = vfs->myft;

	while(trav!=NULL){
		printf("%s\n",trav->name);
		trav = trav->next;
	}
}
Esempio n. 5
0
void initVFS(int vfs_size){
	CVFS* fs = getVFS();
	fs->disk = malloc(vfs_size);
	fs->disk_size = vfs_size;
	fs->myft = NULL;
	fs->free = new BLOCK();
	fs->free->size = vfs_size;
	fs->free->offset = 0;
	fs->free->next = fs->free->prev = NULL;
}
Esempio n. 6
0
bool vfs::PropertyContainer::initFromXMLFile(vfs::Path const& sFileName, vfs::PropertyContainer::TagMap& tagmap)
{
	vfs::tReadableFile *file = NULL;
	bool delete_file = false;
	if(getVFS()->fileExists(sFileName))
	{
		vfs::COpenReadFile rfile(sFileName);
		file = &rfile.file();
		rfile.release();
	}
	else
	{
		vfs::CFile* rfile = new vfs::CFile(sFileName);
		delete_file = true;
		file = vfs::tReadableFile::cast(rfile);
		if(!file->openRead())
		{
			delete file;
			return false;
		}
	}
	if(!file)
	{
		return false;
	}

	vfs::size_t size = file->getSize();

	std::vector<vfs::Byte> buffer(size+1);

	SGP_TRYCATCH_RETHROW( file->read(&buffer[0],size), L"" );
	buffer[size] = 0;

	file->close();
	if(delete_file) delete file;

	XML_Parser parser = XML_ParserCreate(NULL);

	CPropertyXMLParser pp(*this,tagmap,parser,NULL);
	pp.grabParser();

	if(!XML_Parse(parser, &buffer[0], size, TRUE))
	{
		std::wstringstream wss;
		wss << L"XML Parser Error in Groups.xml: "
			<< vfs::String::as_utf16(XML_ErrorString(XML_GetErrorCode(parser))) 
			<< L" at line "
			<< XML_GetCurrentLineNumber(parser);
		SGP_THROW(wss.str().c_str());
		//return false;
	}

	return true;
}
Esempio n. 7
0
bool CTransferRules::initFromTxtFile(vfs::Path const& sPath)
{
	// try to open via VirtualFileSystem
	if(getVFS()->fileExists(sPath))
	{
		return initFromTxtFile(getVFS()->getReadFile(sPath));
	}
	else
	{
		// file doesn't exist or VFS not initialized yet
		vfs::IBaseFile* pFile = new vfs::CFile(sPath);
		if(pFile)
		{
			bool success = initFromTxtFile(vfs::tReadableFile::cast(pFile));
			delete pFile;
			return success;
		}
	}
	return false;
}
Esempio n. 8
0
void vfs::CVirtualLocation::addFile(vfs::IBaseFile* file, vfs::String const& profileName)
{
	vfs::CVirtualFile *pVFile = NULL;
	tVFiles::iterator it = m_VFiles.find(file->getName());
	if(it == m_VFiles.end())
	{
		vfs::Path fp = file->getPath();
		vfs::CProfileStack& stack = *(getVFS()->getProfileStack());
		pVFile = vfs::CVirtualFile::create(fp,stack);
		it = m_VFiles.insert(m_VFiles.end(), std::pair<vfs::Path,vfs::CVirtualFile*>(file->getName(),pVFile));
	}
	it->second->add(file,profileName,true);
}
Esempio n. 9
0
bool vfs::CProfileStack::popProfile()
{
	// there might be some files in this profile that are referenced in a Log object
	// we need to it to release the file
	vfs::Log::flushReleaseAll();
	// an observer pattern would probably be the better solution,
	// but for now lets do it this way 

	vfs::CVirtualProfile* prof = this->topProfile();
	if(prof)
	{
		vfs::CVirtualProfile::Iterator loc_it = prof->begin();
		for(; !loc_it.end(); loc_it.next())
		{
			vfs::IBaseLocation* loc = loc_it.value();
			vfs::IBaseLocation::Iterator f_it = loc->begin();
			for(; !f_it.end(); f_it.next())
			{
				vfs::IBaseFile* file = f_it.value();
				vfs::Path sDir, sFile;
				if(file)
				{
					file->getPath().splitLast(sDir,sFile);
					vfs::CVirtualLocation* vloc = getVFS()->getVirtualLocation(sDir);
					if(vloc)
					{
						if( !vloc->removeFile(file) )
						{
							VFS_THROW(_BS(L"Could not remove file [") << file->getPath()
								<< L"] in Profile [" << prof->cName << L"]" << _BS::wget);
						}
					}
					else
					{
						VFS_THROW(_BS(L"Virtual location [") << sDir
							<< L"] doesn't exist. Maybe the VFS was not properly setup." << _BS::wget);
					}
				}
				else
				{
					VFS_THROW(_BS(L"File is NULL during iteration over files in location [")
						<< loc->getPath() << L"]" << _BS::wget);
				}
			}
		}
		// delete only when nothing went wrong
		this->m_profiles.pop_front();
		delete prof;
	}
	return true;
}
Esempio n. 10
0
int createFile(const char* fileName){

	CVFS *vfs = getVFS();
	FT *trav = new FT();

	//add new entry to the file table
	trav->next = vfs->myft;
	trav->name = (char*)fileName;
	trav->data = NULL;
	trav->size = 0;
	vfs->myft = trav;

	return SUCCESS;
}
Esempio n. 11
0
int deleteFile(const char* fileName){
	CVFS *vfs=getVFS();
	FT *trav = vfs->myft;
	FT *prev = NULL;

	//traverse till the required file
	while(trav!=NULL){
		if(strcmp(trav->name,fileName)==0){
			BLOCK *del = trav->data,*next;

			//add data block of the file to free data blocks
			while(del!=NULL){
				next = del->next;
				add_to_free(del);
				del = next;
			}

			if(prev == NULL)
				vfs->myft = trav->next;
			else
				prev->next = trav->next;
			//printf("root %d %d\n",vfs->free->offset,vfs->free->size);

			del = vfs->free;

			//combine adjacent data blocks in the free to overcome fragmentation of data blocks in free
			while(del->next != NULL){
				if(del->offset+del->size == del->next->offset){
					del->size += del->next->size;
					next = del->next;
					del->next = del->next->next;
					free(next);
				}
				del = del->next;
				if(del==NULL)
					break;
			}

			//free the data entry
			free(trav);

			return SUCCESS;
		}

		prev = trav;
		trav = trav->next;
	}

	return NOTFOUND;
}
Esempio n. 12
0
	FIFE::VFSSource* DirectoryProvider::createSource(const std::string& path) {
		if (isReadable(path)) {
			VFSSource* source = NULL;
			if ( hasSource(path)) {
				source = m_sources[path];
			} else {
				source = new VFSDirectory(getVFS(), path);
				m_sources[path] = source;
			}
			return source;
		}
		else
			throw Exception("Path " + path + " is not readable.");
	}
Esempio n. 13
0
int renameFile(const char* oldName,const char* newName){
	CVFS *vfs=getVFS();
	FT *trav = vfs->myft;

	//traverse till the required file
	while(trav!=NULL){
		if(strcmp(trav->name,oldName)==0){
			//rename and return success
			trav->name = (char*)newName;
			return SUCCESS;
		}
		trav = trav->next;
	}
	return NOTFOUND;
}
Esempio n. 14
0
bool ja2xp::convertSLFto7z(vfs::Path const& sSrc, vfs::Path const& sDst, bool bConvertSTIs, bool bPngOffsets)
{
	vfs::CVirtualFileSystem::Iterator it = getVFS()->begin(sSrc);
	int file_counter = 0;
	for(; !it.end(); it.next())
	{
		file_counter++;
		vfs::String::str_t fname = it.value()->getPath().c_wcs();
		if( !vfs::StrCmp::Equal( fname.substr(fname.length()-4,4), L".slf") )
		{
			std::wcout << L"\"" << fname << L"\" " << L"is not an .slf file" << std::endl;
			continue;
		}
		if(!it.value()->openRead())
		{
			std::wcout << L"Could not open file \"" << sSrc() << L"\""  << std::endl;
			continue;
		}
		vfs::String::str_t new_fname = fname.substr(0,fname.length()-4) + L".jdc.7z";
		vfs::Path out_name;
		if(vfs::StrCmp::Equal(sDst(), L"."))
		{
			out_name = vfs::Path(new_fname);
		}
		else
		{
			out_name = sDst;
		}
		 
		std::wcout << L"Converting file \"" << it.value()->getPath().c_wcs() << L"\"" << std::endl;

		vfs::COpenWriteFile wfile(out_name,true,true);
		if(!convertSLFto7z(it.value(), &wfile.file(), bConvertSTIs, bPngOffsets))
		{
			printf("\n");
			continue;
		}
		printf("\n");
	}
	if(file_counter == 0)
	{
		std::wcout << L"Nothing to convert!" << std::endl;
	}
	return true;
}
void onReceipt(Message *m)
{
    uint32_t vfs = getVFS();
    int idx = getLinuxPID(m->Source);

    if(m->Code < _signalCount && _signals[m->Code] != 0)
    {
        _sig_func_ptr function = _signals[m->Code];

        //I don't like this, but it's needed for POSIX compatibility
        _signals[m->Code] = 0;
        function(m->Code);
    }

    //This is a decent message handling system. Fairly simple
    if(idx != -1 && _pids[idx] != 0 && _pids[idx]->handler != 0)
        _pids[idx]->handler(m);
}
Esempio n. 16
0
//add blocks to free blocks in the disk
void add_to_free(BLOCK* add){
	CVFS *vfs = getVFS();
	BLOCK *move = vfs->free,*prev=NULL;
	while(move != NULL){
		if(move->offset == add->offset+add->size){
			move->offset=add->offset;
			move->size += add->size;
			//printf("adding block offset %d:size %d to start of move\n",add->offset,add->size);
			return;
		}
		if(move->offset+move->size == add->offset){
			move->size += add->size;
			//printf("adding block offset %d:size %d to end of move\n",add->offset,add->size);
			return;
		}
		if(move->offset>add->offset+add->size){
			if(prev==NULL){
				add->next = vfs->free;
				add->prev = NULL;
				vfs->free->prev = add;
				vfs->free = add;
				return;
			}
			add->next = move;
			add->prev = prev;
			move->prev = add;
			prev->next = add;
			return;
			//adding the block in the position such the next node starts after present block in lexicographical order
		}
		prev = move;
		move = move->next;
	}

	if(prev==NULL){
		vfs->free = add;
	}

	prev->next = add;
	//printf("adding block offset %d:size %d at end\n",add->offset,add->size);
}
Esempio n. 17
0
int readFile(const char* fileName,void* buffer,int buffersize,int offset){
	CVFS *vfs = getVFS();
	FT *trav = vfs->myft;

	int bytes_read = 0;

	//traverse till the required file
	while(trav!=NULL){
		if(strcmp(fileName,trav->name)==0){
			BLOCK* move = trav->data;

			//traverse all data blocks of the file
			while(move != NULL && buffersize>0){

				while(offset>=move->size){
					offset -= move->size;
					move = move->next;
				}

				//copy the data in the data block to buffer
				memcpy(buffer,(void*)((char*)vfs->disk + move->offset + offset),min(buffersize,move->size-offset));

				//increment the buffer point
				buffer = (char*)buffer + min(move->size-offset,buffersize);

				bytes_read += min(move->size-offset,buffersize);
				buffersize -= min(move->size-offset,buffersize);

				offset = 0;
				move = move->next;
			}

			return bytes_read;
		}
		trav = trav->next;
	}
	return -1;
}
Esempio n. 18
0
int writeFile(const char* fileName,const void* buffer,int buffersize,int offset){

	CVFS *vfs = getVFS();
	FT *trav = vfs->myft;

	if(buffersize > vfs->disk_size)
		return NOMEM;

	while(trav != NULL){
		//search the file
		if(strcmp(trav->name,fileName)==0){

			BLOCK *prev=NULL,*move=trav->data;

			if((offset && trav->size<=offset) || offset<-1)
				return NOTDEF;

			//traverse till end
			if(offset==-1){
				if(move != NULL) {
					while(move->next != NULL){
						move = move->next;
					}

					prev = move;
					move = move->next;
				}

				offset = 0;
			}

			if(offset>0){
				//traverse till the data block which has specified offset
				while(offset>=move->size){
					offset -= move->size;
					prev = move;
					move = move->next;
				}

				//write form offset to end of block or end of buffer
				memcpy((void*)((char*)vfs->disk + move->offset + offset),buffer,min(buffersize,move->size-offset));
				//printf("written data:%s - to offset %d till %d characters\n",(char*)buffer,move->offset+offset,min(buffersize,move->size-offset));

				buffer = (char*)buffer + min(buffersize,move->size-offset);
				buffersize -= move->size-offset;
				offset = 0;
				prev = move;
				move = move->next;
			}

			while(buffersize>0){
				//allocate a new block when the next block is NULL for write
				if(move==NULL){
					if(prev==NULL)
						move = trav->data = get_block(buffersize);
					else{
						prev->next = get_block(buffersize);
						prev->next->prev = prev;
						move = prev->next;
					}
					trav->size += move->size;
				}

				//write the buffer to disk
				memcpy((void*)((char*)vfs->disk + move->offset),buffer,min(buffersize,move->size));

				//printf("written data:%s - to offset %d till %d characters\n",(char*)buffer,move->offset,min(buffersize,move->size));
				buffersize -= move->size;
				//move buffer pointer
				buffer = (char*)buffer + move->size;

				prev = move;
				move = move->next;
			}
			return SUCCESS;
		}
		trav = trav->next;
	}
	return NOTFOUND;
}
Esempio n. 19
0
BINKFLIC *BinkOpenFlic( const CHAR8 *cFilename )
{
	BINKFLIC *pBink;

	// Get an available flic slot from the list
	if( !( pBink = BinkGetFreeFlic() ) )
	{
		ErrorMsg("BINK ERROR: Out of flic slots, cannot open another");
		return(NULL);
	}
#ifndef USE_VFS
	// Attempt opening the filename
	if(!(pBink->hFileHandle = FileOpen( const_cast<CHAR8*>(cFilename), FILE_OPEN_EXISTING | FILE_ACCESS_READ, FALSE ) ) )
	{
		ErrorMsg("BINK ERROR: Can't open the BINK file");
		return(NULL);
	}

	//Get the real file handle for the file man handle for the smacker file
	HANDLE hFile = GetRealFileHandleFromFileManFileHandle( pBink->hFileHandle );
#else
	vfs::Path introname(cFilename);
	vfs::Path dir,filename;
	introname.splitLast(dir,filename);
	vfs::Path tempfile = vfs::Path(L"Temp") + filename;
	if(!getVFS()->fileExists(tempfile))
	{
		try
		{
			if(!getVFS()->fileExists(introname))
			{
				return NULL;
			}
			vfs::COpenReadFile rfile(introname);
			vfs::size_t size = rfile->getSize();
			std::vector<vfs::Byte> data(size);
			rfile->read(&data[0],size);

			vfs::COpenWriteFile wfile(tempfile,true);
			wfile->write(&data[0],size);
		}
		catch(std::exception& ex)
		{
			SGP_RETHROW(_BS(L"Intro file \"") << filename << L"\" could not be extracted" << _BS::wget, ex);
		}
	}
#endif

#ifndef USE_VFS
	if( !( pBink->BinkHandle = BinkOpen((CHAR8 *)hFile, BINKFILEHANDLE ) ) ) //| SMACKTRACKS 
#else
	vfs::Path tempfilename;
	try
	{
		vfs::COpenWriteFile wfile(tempfile);
		if(!wfile->_getRealPath(tempfilename))
		{
			return NULL;
		}
	}
	catch(std::exception& ex)
	{
		SGP_RETHROW(L"Temporary intro file could not be read", ex);
	}
	if( !( pBink->BinkHandle = BinkOpen(tempfilename.to_string().c_str(), BINKNOTHREADEDIO /*BINKFILEHANDLE*/ ) ) ) //| SMACKTRACKS 
#endif
	{
		ErrorMsg("BINK ERROR: Bink won't open the BINK file");
		return(NULL);
	}

	// Make sure we have a video surface
	BinkSetupVideo();

	pBink->cFilename = cFilename;

	pBink->lpDDS = lpBinkVideoPlayback2;

	pBink->hWindow = hBinkDisplayWindow;

	// Bink flic is now open and ready to go
	pBink->uiFlags |= BINK_FLIC_OPEN;

	return( pBink );
}
Esempio n. 20
0
BOOLEAN InitMainMenu( )
{
	//VOBJECT_DESC	VObjectDesc;	
	VSURFACE_DESC		vs_desc = {};

	//main Menu by JAzz
	UINT16 iCounter2; 

	if(is_networked)
	{	
		is_networked = FALSE;

#ifdef USE_VFS
		// remove Multiplayer profile if it exists
		vfs::CProfileStack *PS = getVFS()->getProfileStack();
		vfs::CVirtualProfile *pProf = PS->getProfile("_MULTIPLAYER");
		if( pProf && (pProf == PS->topProfile()) )
		{
			SGP_THROW_IFFALSE(PS->popProfile(), "Leaving Multiplayer mode : Could not remove \"_MULTIPLAYER\" profile");
		}
#endif

		// Snap: UN-Init MP save game directory
		if ( !InitSaveDir() )
		{
			//if something didnt work, dont even know how to make error code...//hayden
		}
	}

	//Check to see whatr saved game files exist
	InitSaveGameArray();

	//Create the background mouse mask
	CreateDestroyBackGroundMouseMask( TRUE );

	CreateDestroyMainMenuButtons( TRUE );
		
	// load background graphic and add it	
	//Main Menu by Jazz
	for( iCounter2 = 1; iCounter2 < MAX_ELEMENT; iCounter2++ )
	{
		//VObjectDesc.fCreateFlags = VSURFACE_CREATE_FROMFILE;		
		vs_desc.fCreateFlags = VSURFACE_CREATE_FROMFILE | VSURFACE_SYSTEM_MEM_USAGE | VSURFACE_CREATE_FROMPNG_FALLBACK;

		if (gMainMenulayout[iCounter2].Visible == 1)
		{
			strcpy(vs_desc.ImageFile, gMainMenulayout[iCounter2].FileName);
			
			if( !AddVideoSurface( &vs_desc, &gMainMenulayout[iCounter2].uiIndex ) )
			AssertMsg(0, String( "Missing %s", gMainMenulayout[iCounter2].FileName ) );	


			//if (iResolution >= _640x480 && iResolution < _800x600)
			//{				
			//	strcpy(VObjectDesc.ImageFile, gMainMenulayout[iCounter2].FileName);

			//	if( !AddVideoObject( &VObjectDesc, &gMainMenulayout[iCounter2].uiIndex ) )
			//		AssertMsg(0, String( "Missing %s", gMainMenulayout[iCounter2].FileName ) );				
			//}
			//else if (iResolution < _1024x768)
			//{		
			//	strcpy(VObjectDesc.ImageFile, gMainMenulayout[iCounter2].FileName800x600);

			//	if( !AddVideoObject( &VObjectDesc, &gMainMenulayout[iCounter2].uiIndex ) )
			//		AssertMsg(0, String( "Missing %s", gMainMenulayout[iCounter2].FileName800x600 ) );				
			//}
			//else
			//{		
			//	strcpy(VObjectDesc.ImageFile, gMainMenulayout[iCounter2].FileName1024x768);

			//	if( !AddVideoObject( &VObjectDesc, &gMainMenulayout[iCounter2].uiIndex ) )
			//		AssertMsg(0, String( "Missing %s", gMainMenulayout[iCounter2].FileName1024x768 ) );				
			//}
		}
	}
	
	//if there are no saved games, disable the button
	if( !IsThereAnySavedGameFiles() )
		DisableButton( iMenuButtons[ LOAD_GAME ] );
		
		
	#ifdef JA113DEMO
		DisableButton( iMenuButtons[ NEW_MP_GAME ] );
	#endif

	gbHandledMainMenu = 0;
	fInitialRender		= TRUE;

	SetPendingNewScreen( MAINMENU_SCREEN);
	guiMainMenuExitScreen = MAINMENU_SCREEN;

	DequeueAllKeyBoardEvents();

	return( TRUE );
}
Esempio n. 21
0
	FIFE::VFSSource* DirectoryProvider::createSource(const std::string& path) const {
		if (isReadable(path))
            return new VFSDirectory(getVFS(), path);
		else
			throw Exception("Path " + path + " is not readable.");
	}
Esempio n. 22
0
bool vfs::canWrite()
{
	vfs::CVirtualProfile *prof = getVFS()->getProfileStack()->topProfile();
	return prof && prof->cWritable;
}
Esempio n. 23
0
UINT32 LoadSaveScreenHandle(void)
{
	FDLG_LIST *FListNode;
	INT32 x;
	InputAtom DialogEvent;

	if( fEnteringLoadSaveScreen )
	{
		LoadSaveScreenEntry();
	}

	if( gbCurrentFileIOStatus ) //loading or saving map
	{
		UINT32 uiScreen;
		uiScreen = ProcessFileIO();
		if( uiScreen == EDIT_SCREEN && gbCurrentFileIOStatus == LOADING_MAP )
			RemoveProgressBar( 0 );
		return uiScreen;
	}

	if( gubMessageBoxStatus )
	{
		if( MessageBoxHandled() )
			return ProcessLoadSaveScreenMessageBoxResult();
		return LOADSAVE_SCREEN;
	}

	//handle all key input.
	while( DequeueEvent(&DialogEvent) )
	{
		if( !HandleTextInput(&DialogEvent) && (DialogEvent.usEvent == KEY_DOWN || DialogEvent.usEvent == KEY_REPEAT) )
		{
			HandleMainKeyEvents( &DialogEvent );
		}
	}

	HandleMouseWheelEvents();//dnl ch36 150909

	DrawFileDialog();

	// Skip to first filename to show
	FListNode = FileList;
	for(x=0;x<iTopFileShown && x<iTotalFiles && FListNode != NULL;x++)
	{
		FListNode = FListNode->pNext;
	}

	// Show up to 8 filenames in the window
	SetFont( FONT12POINT1 );
	if( gfNoFiles )
	{
		SetFontForeground( FONT_LTRED );
		SetFontBackground( 142 );
	  mprintf( iScreenWidthOffset + 226, iScreenHeightOffset + 126, L"NO FILES IN \\MAPS DIRECTORY" );
	}
	else for(x=iTopFileShown;x<(iTopFileShown+8) && x<iTotalFiles && FListNode != NULL; x++)
	{
		if( !EditingText() && x == iCurrFileShown  )
		{
			SetFontForeground( FONT_GRAY2 );
			SetFontBackground( FONT_METALGRAY );
		}
		else
		{
			SetFontForeground( FONT_BLACK );
			SetFontBackground( 142 );
		}
		mprintf( iScreenWidthOffset + 186,(iScreenHeightOffset + 73+ (x-iTopFileShown)*15 ), L"%S", FListNode->FileInfo.zFileName);
		FListNode = FListNode->pNext;
	}

	RenderAllTextFields();

	InvalidateScreen();

	ExecuteBaseDirtyRectQueue();
	EndFrameBufferRender();

	switch( iFDlgState )
	{
		case DIALOG_CANCEL:
			RemoveFileDialog();
			fEnteringLoadSaveScreen = TRUE;
			return EDIT_SCREEN;
		case DIALOG_DELETE:
			sprintf( gszCurrFilename, "MAPS\\%S", gzFilename );
			if( GetFileFirst(gszCurrFilename, &FileInfo) )
			{
				CHAR16 str[40];
				if( FileInfo.uiFileAttribs & (FILE_IS_READONLY|FILE_IS_HIDDEN|FILE_IS_SYSTEM) )
				{
					swprintf( str, L" Delete READ-ONLY file %s? ", gzFilename );
					gfReadOnly = TRUE;
				}
				else
					swprintf( str, L" Delete file %s? ", gzFilename );
				gfDeleteFile = TRUE;
				CreateMessageBox( str );
			}
			return LOADSAVE_SCREEN;
		case DIALOG_SAVE://dnl ch37 230909
		{
			if(!ExtractFilenameFromFields())
			{
				CreateMessageBox(L" Illegal filename.  Try another filename? ");
				gfIllegalName = TRUE;
				iFDlgState = DIALOG_NONE;
				return(LOADSAVE_SCREEN);
			}
			sprintf(gszCurrFilename, "MAPS\\%S", gzFilename);
			gfFileExists = FALSE;
#ifndef USE_VFS
			gfReadOnly = FALSE;
			if(FileExists(gszCurrFilename))
			{
				gfFileExists = TRUE;
				if(GetFileFirst(gszCurrFilename, &FileInfo))
				{
					if(FileInfo.uiFileAttribs & (FILE_IS_READONLY|FILE_IS_DIRECTORY|FILE_IS_HIDDEN|FILE_IS_SYSTEM|FILE_IS_OFFLINE|FILE_IS_TEMPORARY))
						gfReadOnly = TRUE;
					GetFileClose(&FileInfo);
				}
			}
#else
			gfReadOnly = TRUE;
			vfs::CProfileStack* st = getVFS()->getProfileStack();
			vfs::CProfileStack::Iterator it = st->begin();
			while(!it.end())
			{
				vfs::CVirtualProfile* prof = it.value();
				if(prof->cWritable == true)
				{
					gfReadOnly = FALSE;
					vfs::Path const& path = gszCurrFilename;
					vfs::IBaseFile *file = prof->getFile(path);
					if(file)
					{
						gfFileExists = TRUE;
						if(file->implementsWritable() == false)
							gfReadOnly = TRUE;
					}
					break;
				}
				it.next();
			}
#endif
			if(gfReadOnly)
			{
				CreateMessageBox(L" File is read only!  Choose a different name? ");
				return( LOADSAVE_SCREEN);
			}
			else if(gfFileExists)
			{
				CreateMessageBox(L" File exists, Overwrite? ");
				return(LOADSAVE_SCREEN);
			}
			RemoveFileDialog();
			gbCurrentFileIOStatus = INITIATE_MAP_SAVE;
			return(LOADSAVE_SCREEN);
		}
		case DIALOG_LOAD:
			if( !ExtractFilenameFromFields() )
			{
				CreateMessageBox( L" Illegal filename.  Try another filename? " );
				gfIllegalName = TRUE;
				iFDlgState = DIALOG_NONE;
				return LOADSAVE_SCREEN;
			}
			RemoveFileDialog();
			CreateProgressBar( 0, iScreenWidthOffset + 118, iScreenHeightOffset + 183, iScreenWidthOffset + 522, iScreenHeightOffset + 202 );
			DefineProgressBarPanel( 0, 65, 79, 94, iScreenWidthOffset + 100, iScreenHeightOffset + 155, iScreenWidthOffset + 540, iScreenHeightOffset + 235 );
			swprintf( zOrigName, L"Loading map:  %s", gzFilename );
			SetProgressBarTitle( 0, zOrigName, BLOCKFONT2, FONT_RED, FONT_NEARBLACK );
			gbCurrentFileIOStatus = INITIATE_MAP_LOAD;
			return LOADSAVE_SCREEN ;
		default:
			iFDlgState = DIALOG_NONE;
	}
	iFDlgState = DIALOG_NONE;
	return LOADSAVE_SCREEN ;
}
Esempio n. 24
0
void LoadSaveScreenEntry()
{
	fEnteringLoadSaveScreen = FALSE;
	gbCurrentFileIOStatus	= IOSTATUS_NONE;

	gfReadOnly = FALSE;
	gfFileExists = FALSE;
	gfLoadError = FALSE;
	gfIllegalName = FALSE;
	gfDeleteFile = FALSE;
	gfNoFiles = FALSE;
	gfSaveError = FALSE;//dnl ch37 200909

	// setup filename dialog box
	// (*.dat and *.map) as file filter

	// If user clicks on a filename in the window, then turn off string focus and re-init the string with the new name.
	// If user hits ENTER or presses OK, then continue with the file loading/saving

	if(FileList)
	{
		TrashFDlgList(FileList);
		FileList = NULL;
	}

	iTopFileShown = iTotalFiles = 0;
#ifdef USE_VFS//dnl ch37 300909
	FDLG_LIST* TempFileList = NULL;
	vfs::CProfileStack* st = getVFS()->getProfileStack();
	vfs::CProfileStack::Iterator it = st->begin();
	while(!it.end())
	{
		TempFileList = NULL;
		vfs::CVirtualProfile* prof = it.value();
		memset(&FileInfo, 0, sizeof(GETFILESTRUCT));
		strcpy(FileInfo.zFileName, "< ");
		strcat(FileInfo.zFileName, prof->cName.utf8().c_str());
		strcat(FileInfo.zFileName, " >");
		FileInfo.zFileName[FILENAME_BUFLEN] = 0;
		FileInfo.uiFileAttribs = FILE_IS_DIRECTORY;
		if(iCurrentAction == ACTION_SAVE_MAP && prof->cWritable == false)
		{
			it.next();
			continue;
		}
		TempFileList = AddToFDlgList(TempFileList, &FileInfo);
		iTotalFiles++;
		vfs::CVirtualProfile::FileIterator fit = prof->files(L"MAPS/*");
		while(!fit.end())
		{
			vfs::String fname = fit.value()->getName().c_str();
			memset(&FileInfo, 0, sizeof(GETFILESTRUCT));
			strcpy(FileInfo.zFileName, fname.utf8().c_str());
			FileInfo.uiFileSize = fname.length();
			FileInfo.uiFileAttribs = (fit.value()->implementsWritable() ? FILE_IS_NORMAL : FILE_IS_READONLY);
			if(strlen(FileInfo.zFileName) < FILENAME_BUFLEN)
			{
				TempFileList = AddToFDlgList(TempFileList, &FileInfo);
				iTotalFiles++;
			}
			fit.next();
		}
		if(TempFileList)
		{
			while(TempFileList->pPrev)
				TempFileList = TempFileList->pPrev;
			if(FileList)
			{
				while(FileList->pNext)
					FileList = FileList->pNext;
				FileList->pNext = TempFileList;
				TempFileList->pPrev = FileList;
			}
			else
				FileList = TempFileList;
		}
		it.next();
	}
	while(FileList->pPrev)
		FileList = FileList->pPrev;
#else
	if(GetFileFirst("MAPS\\*.dat", &FileInfo))
	{
		if(strlen(FileInfo.zFileName) < FILENAME_BUFLEN)
		{
			FileList = AddToFDlgList(FileList, &FileInfo);
			iTotalFiles++;
		}
		while(GetFileNext(&FileInfo))
		{
			if(strlen(FileInfo.zFileName) < FILENAME_BUFLEN)
			{
				FileList = AddToFDlgList(FileList, &FileInfo);
				iTotalFiles++;
			}
		}
		GetFileClose(&FileInfo);
	}
#endif
	swprintf( zOrigName, L"%s Map (*.dat)", iCurrentAction == ACTION_SAVE_MAP ? L"Save" : L"Load" );

	swprintf( gzFilename, L"%S", gubFilename );

	CreateFileDialog( zOrigName );

	if( !iTotalFiles )
	{
		gfNoFiles = TRUE;
		if( iCurrentAction == ACTION_LOAD_MAP )
			DisableButton( iFileDlgButtons[0] );
	}

	iLastFileClicked = -1;
	iLastClickTime = 0;

}
Esempio n. 25
0
	RawData* DAT1::open(const std::string& file) const {
		const RawDataDAT1::s_info& info = getInfo(file);
		return new RawData(new RawDataDAT1(getVFS(), m_datpath, info));
	}
Esempio n. 26
0
bool ja2xp::convertSTItoJPC(vfs::Path const& sSrc, vfs::Path const& sDst, bool bPacked, bool bOffsets, bool bOnePng, bool rgba)
{
	vfs::CVirtualFileSystem::Iterator it = getVFS()->begin(sSrc);
	int file_counter = 0;
	for(; !it.end(); it.next())
	{
		file_counter++;
		vfs::String::str_t fname = it.value()->getPath().c_wcs();
		if( !vfs::StrCmp::Equal( fname.substr(fname.length()-4,4), L".sti") )
		{
			std::wcout << L"\"" << fname << L"\" is not an .sti file" << std::endl;
			continue;
		}
		if(!it.value()->openRead())
		{
			std::wcout << L"Could not open file \"" << sSrc() << L"\""  << std::endl;
			continue;
		}
		vfs::String::str_t fname_base = fname.substr(0,fname.length()-4);
		 
		std::wcout << L"Converting file \"" << fname << L"\"" << std::endl;

		if(bOnePng)
		{
			vfs::Path out_name;
			if(vfs::StrCmp::Equal(sDst(), L"."))
			{
				out_name = vfs::Path(fname_base + L".png");
			}
			else
			{
				out_name = sDst;
			}
			vfs::COpenWriteFile wfile(out_name,true,true);

			if(	!convertSTItoPNG( it.value(), &(wfile.file()), rgba ) )
			{
				std::wcout << L"error : could not convert sti image" << std::endl;
				continue;
			}
		}
		else if(bPacked)
		{
			vfs::Path out_name;
			if(vfs::StrCmp::Equal(sDst(), L"."))
			{
				out_name = vfs::Path(fname_base + L".jpc.7z");
			}
			else
			{
				out_name = sDst;
			}
			vfs::COpenWriteFile wfile(out_name,true,true);

			if(	!convertSTItoJPC( it.value(), &(wfile.file()), bOffsets, rgba ) )
			{
				std::wcout << L"error : could not convert sti image" << std::endl;
				continue;
			}
		}
		else
		{
			if(	!convertSTItoJPC( it.value(), vfs::Path(fname_base), bOffsets, rgba ) )
			{
				std::wcout << L"error : could not convert sti image" << std::endl;
				continue;
			}
		}
	}
	if(file_counter == 0)
	{
		std::wcout << L"Nothing to convert!" << std::endl;
	}
	return true;
}