[Scummvm-cvs-logs] CVS: scummvm/wince findgame.cpp,NONE,1.1 gapi_keys.cpp,NONE,1.1 pocketscumm.ico,NONE,1.1 pocketpc.cpp,1.2,1.3

James Brown ender at users.sourceforge.net
Thu Mar 14 06:26:12 CET 2002


Update of /cvsroot/scummvm/scummvm/wince
In directory usw-pr-cvs1:/tmp/cvs-serv23229

Modified Files:
	pocketpc.cpp 
Added Files:
	findgame.cpp gapi_keys.cpp pocketscumm.ico 
Log Message:
Add files for new WinCE port.



--- NEW FILE: findgame.cpp ---
#ifdef _WIN32_WCE

// Browse directories to locate SCUMM games

#include "stdafx.h"
#include <Winuser.h>
#include "resource.h"

#define MAX_GAMES 20

struct ScummGame {
	const char *gamename;
	const char *description;
	const char *directory;
	const char *check_file_1;
	const char *check_file_2;
	const char *filename;
	unsigned char next_demo;
};

struct InstalledScummGame {
	unsigned char reference;
	TCHAR directory[MAX_PATH];
};

static const ScummGame GameList[] = {
	{ 
		 "Indiana Jones 3 (new)", 
	     "Buggy, unplayable", 
		 "indy3", "", "", 
		 "indy3",
	     0 
	},
	{	 
		 "Zak Mc Kracken (new)",
		 "Buggy, unplayable",
		 "zak256", "", "",
		 "zak256",
		 0
	},
	{
		 "Loom (old)",
		 "Not working",
		 "loom", "", "",
		 "loom",
		 0
	},
	{
		 "Monkey Island 1 (EGA)",
		 "Not tested",
		 "monkeyEGA", "", "",
		 "monkeyEGA",
		 0
	},
	{
		 "Loom (VGA)",
		 "Buggy, playable a bit",
		 "loomcd", "", "",
		 "loomcd",
		 0
	},
	{
		 "Monkey Island 1 (VGA)",
		 "Working well, perhaps completable ?",
		 "", "MONKEY.000", "MONKEY.001",
		 "monkey",
		 0
	},
	{
		 "Monkey Island 2 (VGA)",
		 "Completable",
		 "", "MONKEY2.000", "MONKEY2.001",
		 "monkey2",
		 0
	},
	{
		 "Indiana Jones 4",
		 "Completable",
		 "", "ATLANTIS.000", "ATLANTIS.001",
		 "atlantis",
		 1
	},
	{
		 "Indiana Jones 4 demo",
		 "Completable",
		 "", "PLAYFATE.000", "PLAYFATE.001",
		 "playfate",
		 0
	},
	{
		 "Day of the Tentacle",
		 "Completable",
		 "", "TENTACLE.000", "TENTACLE.001",
		 "tentacle",
		 1
	},
	{
		 "Day of the Tentacle demo",
		 "Completable",
		 "", "DOTTDEMO.000", "DOTTDEMO.001",
		 "dottdemo",
		 0
	},
	{	
		 "Sam & Max",
		 "Completable,glitches,no music",
		 "", "SAMNMAX.000", "SAMNMAX.001",
		 "samnmax",
		 1
	},
	{
		 "Sam & Max demo",
		 "Completable, minor glitches, no music",
		 "", "SNMDEMO.000", "SNMDEMO.001",
		 "snmdemo",
		 0
	},
	{
		 "Full Throttle",
		 "Partially working",
		 "", "FT.LA0", "FT.LA1",
		 "ft",
		 0
	},
	{
		 "The Dig",
		 "Partially working",
		 "", "DIG.LA0", "DIG.LA1",
		 "dig",
		 0
	},
	{
		 NULL, NULL, NULL, NULL, NULL, NULL, 0
	}
};

void findGame(TCHAR*);
int displayFoundGames(void);

char gamesFound[MAX_GAMES];
unsigned char listIndex[MAX_GAMES];
InstalledScummGame gamesInstalled[MAX_GAMES];
int installedGamesNumber;
HWND hwndDlg;

void setFindGameDlgHandle(HWND x) {
	hwndDlg = x;
}

bool loadGameSettings() {
	HKEY			hkey;
	DWORD			disposition;
	DWORD			keyType, keySize, dummy;
	int				index;
	int				i;
	unsigned char	references[MAX_PATH];

	if(RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Software\\PocketSCUMM"), 
		 0, NULL, 0, 0, NULL, &hkey, &disposition) == ERROR_SUCCESS) {

		 keyType = REG_DWORD;
		 keySize = sizeof(DWORD);
		 if (RegQueryValueEx(hkey, TEXT("GamesInstalled"), NULL, &keyType, 
						 (unsigned char*)&dummy, &keySize) == ERROR_SUCCESS) 
					index = dummy;
		 else
					return FALSE;

		 installedGamesNumber = index;

		 keyType = REG_BINARY;
		 keySize = index;
		 if (RegQueryValueEx(hkey, TEXT("GamesReferences"), NULL, &keyType, 
						 references, &keySize) != ERROR_SUCCESS)
					return FALSE;

		 for (i=0; i<index; i++)
			 gamesFound[references[i]] = 1;

		 keyType = REG_SZ;
		 for (i=0; i<index; i++) {
			 char work[100];
			 TCHAR keyname[100];

			 gamesInstalled[i].reference = references[i];
			 keySize = MAX_PATH;
			 sprintf(work, "GamesDirectory%d", i);			 
			 MultiByteToWideChar(CP_ACP, 0, work, strlen(work) + 1, keyname, sizeof(keyname));
			 if (RegQueryValueEx(hkey, keyname, NULL, &keyType, (unsigned char*)gamesInstalled[i].directory, &keySize) != ERROR_SUCCESS)
				 return FALSE;			 
		 }
		 
		 RegCloseKey(hkey);
		 displayFoundGames();
		 return TRUE;
	 }
	else
		return FALSE;
}

int countGameReferenced(int reference, int *infos) {
	int i;
	int number = 0;

	for (i=0; i<installedGamesNumber; i++)
		if (gamesInstalled[i].reference == reference) 
			infos[number++] = i;

	return number;
}

int displayFoundGames() {

	int i;
	int index = 0;

	for (i = 0; i< MAX_GAMES; i++) {
		ScummGame current_game;
		char    work[400];
		TCHAR	desc[400];
		int		numberReferenced;
		int		infos[10];
		int		j;

		current_game = GameList[i];
		if (!current_game.filename)
			break;
		if (!gamesFound[i])
			continue;
		
		numberReferenced = countGameReferenced(i, infos);

		for (j=0; j<numberReferenced; j++) {
			if (numberReferenced != 1)
				sprintf(work, "%s (%d)", current_game.gamename, j + 1);
			else
				strcpy(work, current_game.gamename);
			MultiByteToWideChar(CP_ACP, 0, work, strlen(work) + 1, desc, sizeof(desc));
			SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_ADDSTRING, 0, (LPARAM)desc);
			listIndex[index++] = infos[j];
		}
	}

	return index;

}

void startFindGame() {
	TCHAR			fileName[MAX_PATH];
	TCHAR			*tempo;
	int				i = 0;
	int		    	index = 0;
	HKEY			hkey;
	DWORD			disposition, keyType, keySize, dummy;
	unsigned char	references[MAX_GAMES];

	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Scanning, please wait"));

	SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_RESETCONTENT, 0, 0);

	memset(gamesFound, 0, MAX_GAMES);
	GetModuleFileName(NULL, fileName, MAX_PATH);
	tempo = wcsrchr(fileName, '\\');
	*tempo = '\0';
	*(tempo + 1) = '\0';
	installedGamesNumber = 0;

	findGame(fileName);

	// Display the results
	index = displayFoundGames();

	// Save the results in the registry
	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Saving the results"));

	for (i=0; i<index; i++)
		references[i] = gamesInstalled[i].reference;

	if(RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Software\\PocketSCUMM"), 
		 0, NULL, 0, 0, NULL, &hkey, &disposition) == ERROR_SUCCESS) {

		 keyType = REG_DWORD;
		 keySize = sizeof(DWORD);
		 dummy = index;
		 RegSetValueEx(hkey, TEXT("GamesInstalled"), 0, keyType, (unsigned char*)&dummy, keySize);
		 keyType = REG_BINARY;
		 keySize = index;	
		 RegSetValueEx(hkey, TEXT("GamesReferences"), 0, keyType, references, 
						keySize);	
		 keyType = REG_SZ;
		 for (i=0; i<index; i++) {
			 char work[100];
			 TCHAR keyname[100];

			 sprintf(work, "GamesDirectory%d", i);
			 MultiByteToWideChar(CP_ACP, 0, work, strlen(work) + 1, keyname, sizeof(keyname));
			 keySize = (wcslen(gamesInstalled[i].directory) + 1) * 2;
			 RegSetValueEx(hkey, keyname, 0, keyType, (unsigned char*)gamesInstalled[i].directory, keySize);				 
		 }
		 
		 RegCloseKey(hkey);
	 }

	 SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Scan finished"));

}

void getSelectedGame(int result, char *id, TCHAR *directory) {
	ScummGame game;

	game = GameList[gamesInstalled[listIndex[result]].reference];
	strcpy(id, game.filename);
	wcscpy(directory, gamesInstalled[listIndex[result]].directory);
}

void displayGameInfo() {
	int item;	
	TCHAR work[400];
	ScummGame game;

	item = SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_GETCURSEL, 0, 0);
	if (item == LB_ERR)
		return;

	game = GameList[gamesInstalled[listIndex[item]].reference];
	wcscpy(work, TEXT("File path : ..."));	
	wcscat(work, wcsrchr(gamesInstalled[listIndex[item]].directory, '\\'));			
	SetDlgItemText(hwndDlg, IDC_FILEPATH, work);
	MultiByteToWideChar(CP_ACP, 0, game.description, strlen(game.description) + 1, work, sizeof(work));
	SetDlgItemText(hwndDlg, IDC_GAMEDESC, work);	
}

void findGame(TCHAR *directory) {
	TCHAR			 fileName[MAX_PATH];
	TCHAR			 newDirectory[MAX_PATH];
	WIN32_FIND_DATA	 desc;
	HANDLE			 x;
	int				 i;

	// Check for games in the current directory

	//MessageBox(NULL, directory, TEXT("Current"), MB_OK);

	for (i = 0 ; i < MAX_GAMES ; i++) {
		ScummGame current_game;

		current_game = GameList[i];
		if (!current_game.filename)
			break;

		if (strlen(current_game.directory)) {
			// see if the last directory matches
			TCHAR	*work;
			char	curdir[MAX_PATH];

			
			work = wcsrchr(directory, '\\');
			WideCharToMultiByte(CP_ACP, 0, work + 1, wcslen(work + 1) + 1, curdir, sizeof(curdir), NULL, NULL);
			if (stricmp(curdir, current_game.directory) == 0) {
				
				//MessageBox(NULL, TEXT("Match directory !"), TEXT("..."), MB_OK);
				
				gamesFound[i] = 1;
				gamesInstalled[installedGamesNumber].reference = i;
				wcscpy(gamesInstalled[installedGamesNumber].directory, directory);
				installedGamesNumber++;
			}
		}
		else
		{
			TCHAR	work[MAX_PATH];
			TCHAR	checkfile[MAX_PATH];


			MultiByteToWideChar(CP_ACP, 0, current_game.check_file_1, strlen(current_game.check_file_1) + 1, checkfile, sizeof(checkfile));
			wsprintf(work, TEXT("%s\\%s"), directory, checkfile);
			//MessageBox(NULL, work, TEXT("Checking file"), MB_OK);

			if (GetFileAttributes(work) == 0xFFFFFFFF)
				continue;

			//MessageBox(NULL, TEXT("Check OK"), TEXT("Checking file"), MB_OK);
			MultiByteToWideChar(CP_ACP, 0, current_game.check_file_2, strlen(current_game.check_file_2) + 1, checkfile, sizeof(checkfile));
			wsprintf(work, TEXT("%s\\%s"), directory, checkfile);			
			if (GetFileAttributes(work) == 0xFFFFFFFF)
				continue;
			
			//MessageBox(NULL, TEXT("Match file !"), TEXT("..."), MB_OK);
			gamesFound[i] = 1;
			gamesInstalled[installedGamesNumber].reference = i;
			wcscpy(gamesInstalled[installedGamesNumber].directory, directory);
			installedGamesNumber++;

		}
	}

	// Recurse

	wsprintf(fileName, TEXT("%s\\*"), directory);

	x = FindFirstFile(fileName, &desc);
	if (x == INVALID_HANDLE_VALUE)
		return;
	if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
		wsprintf(newDirectory, TEXT("%s\\%s"), directory, desc.cFileName);
		findGame(newDirectory);
	}
	while (FindNextFile(x, &desc))
		if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
		wsprintf(newDirectory, TEXT("%s\\%s"), directory, desc.cFileName);
		findGame(newDirectory);
	}	
	FindClose(x);
}

#endif
--- NEW FILE: gapi_keys.cpp ---
#ifdef _WIN32_WCE

// Handle mapping of actions to hardware keys

#include "stdafx.h"
#include <assert.h>
#include <Winuser.h>
#include <sipapi.h>
#include <Aygshell.h>
#include <gx.h>

#include "gapi_keys.h"

#include "screen.h"

struct oneAction _actions[NUMBER_ACTIONS];
struct GXKeyList _keys;
pAction *_action_functions;

const char* ActionsText[] = {
	"Pause",
	"Save",
	"Quit",
	"Skip",
	"Hide",
	"Keyboard",
	"Sound",
	"Right click"
};

bool _typeExists(int x) {
	int i;

	for (i=0; i<NUMBER_ACTIONS; i++)
		if (_actions[i].action_type == x)
			return true;

	return false;
}


const char* getActionName(int action) {
	return ActionsText[action - 1];
}

void GAPIKeysInit(pAction *functions) {
	int i;
	GXOpenInput();
	for (i=0; i<NUMBER_ACTIONS; i++) {
		_actions[i].action_key = 0;
	}

	/* Default actions */

	_actions[0].action_type = ACTION_PAUSE;
	_actions[1].action_type = ACTION_SAVE;
	_actions[2].action_type = ACTION_QUIT;
	_actions[3].action_type = ACTION_SKIP;
	_actions[4].action_type = ACTION_HIDE;

	_action_functions = functions;
	GAPIKeysGetReference();
}

void GAPIKeysGetReference() {
	if(GetScreenMode()) {
		_keys = GXGetDefaultKeys(GX_LANDSCAPEKEYS);
	} else {
		_keys = GXGetDefaultKeys(GX_NORMALKEYS);
	}
}

const unsigned char getGAPIKeyMapping(short key) {
	// first the standard GAPI controls
	if (key == _keys.vkA)
		return GAPI_KEY_VKA;
	
	if (key == _keys.vkB)
			return GAPI_KEY_VKB;
	
	if (key == _keys.vkC)
			return GAPI_KEY_VKC;
	
	if (key == _keys.vkStart)
			return GAPI_KEY_VKSTART;

	switch (key) {
		// then the "unsupported" keys 
		case INTERNAL_KEY_CALENDAR:
			return GAPI_KEY_CALENDAR;
		case INTERNAL_KEY_CONTACTS:
			return GAPI_KEY_CONTACTS;
		case INTERNAL_KEY_INBOX:
			return GAPI_KEY_INBOX;
		case INTERNAL_KEY_ITASK:
			return GAPI_KEY_ITASK;
		default:
			return 0;
	}
}

const char* getGAPIKeyName(unsigned char key) {
	switch(key) {
		case GAPI_KEY_VKA:
			return "Button A";
		case GAPI_KEY_VKB:
			return "Button B";
		case GAPI_KEY_VKC:
			return "Button C";
		case GAPI_KEY_VKSTART:
			return "Button Start";
		case GAPI_KEY_CALENDAR:
			return "Button Calendar";
		case GAPI_KEY_CONTACTS:
			return "Button Contacts";
		case GAPI_KEY_INBOX:
			return "Button Inbox";
		case GAPI_KEY_ITASK:
			return "Button ITask";
		default:
			return "Not mapped";
	}
}

struct oneAction* getAction(int action) {
	return &_actions[action];
}

void processAction (short key) {
	int i;
	unsigned char GAPI_key;

	GAPI_key = getGAPIKeyMapping(key);
	if (!GAPI_key)
		return;
	
	for (i=0; i<NUMBER_ACTIONS; i++) 
		if (_actions[i].action_key == GAPI_key &&
			_actions[i].action_type != ACTION_NONE &&
			_action_functions[_actions[i].action_type - 1])
					_action_functions[_actions[i].action_type - 1]();
}

void clearActionKey (unsigned char key) {
	int i;

	for (i=0; i<NUMBER_ACTIONS; i++)
		if (_actions[i].action_key == key) {
			_actions[i].action_key = 0;
		}
}

const unsigned char* getActionKeys() {
	int i;
	static unsigned char actionKeys[NUMBER_ACTIONS];

	for (i=0; i<NUMBER_ACTIONS; i++)
		actionKeys[i] = _actions[i].action_key;

	return actionKeys;
}

const unsigned char* getActionTypes() {
	int i;
	static unsigned char actionTypes[NUMBER_ACTIONS];

	for (i=0; i<NUMBER_ACTIONS; i++)
		actionTypes[i] = _actions[i].action_type;

	return actionTypes;

}

void setNextType(int action) {
	int start = _actions[action].action_type;
	int current = start;
	for (;;) {
		current++;
		if (current == start)
			return;
		if (current > TOTAL_ACTIONS)
			current = 1;
		if (!_typeExists(current)) {
				_actions[action].action_type = current;
				return;
		}
	}
}

void setPreviousType(int action) {
	int start = _actions[action].action_type;
	int current = start;
	for (;;) {
		current--;
		if (current == start)
			return;
		if (current <= 0)
			current = TOTAL_ACTIONS;
		if (!_typeExists(current)) {
				_actions[action].action_type = current;
				return;
		}
	}
}



void setActionKeys(unsigned char *actionKeys) {
	int i;

	for (i=0; i<NUMBER_ACTIONS; i++)
		_actions[i].action_key = actionKeys[i];
}

void setActionTypes(unsigned char *actionTypes) {
	int i;

	for (i=0; i<NUMBER_ACTIONS; i++)
		_actions[i].action_type = (ActionType)actionTypes[i];
}


#endif
--- NEW FILE: pocketscumm.ico ---

l
J†
ZÍ
Index: pocketpc.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/wince/pocketpc.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** pocketpc.cpp	11 Dec 2001 13:34:15 -0000	1.2
--- pocketpc.cpp	14 Mar 2002 14:09:14 -0000	1.3
***************
*** 31,40 ****
  #include "gui.h"
  
! #define USE_F_KEYS
! #ifdef USE_F_KEYS
! void setup_extra_windows(HWND hwndTop);
! void adjust_extra_windows();
! HWND hwndFKeys;
! #endif
  
  #define SAMPLES_PER_SEC 22050
[...1225 lines suppressed...]
- 	SHSipInfo(SPI_GETSIPINFO, 0, &si, 0);
- 	if(si.fdwFlags & SIPF_ON)
- 	{
- 		int bottom = si.rcVisibleDesktop.bottom;
- 		SetWindowPos(hwndFKeys, 0, 0, 200, GetSystemMetrics(SM_CXSCREEN), bottom-200,
- 			SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOZORDER);
- 	}
- }
- #endif
--- 1014,1023 ----
  }
  
! /* Unsupported funcs */
  
! // TODO : implement
! void setShakePos(Scumm *s, int shake_pos) {}
! // TODO : switch to MP3 support
! void cd_playtrack(int track, int offset, int delay) {}
  
  





More information about the Scummvm-git-logs mailing list