ScummVM Headers were missing

svn-id: r10381

6 files changed, 3880 insertions, 0 deletions

diff --git a/backends/PalmOS/Src/games.cpp b/backends/PalmOS/Src/games.cpp
new file mode 100644
index 0000000000..988f2d407d
--- /dev/null
+++ b/backends/PalmOS/Src/games.cpp
@@ -0,0 +1,227 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <PalmOS.h>
+#include <VFSMgr.h>
+
+#include "start.h"
+#include "games.h"
+
+#include "extend.h"
+#include "StarterRsc.h"
+
+DmOpenRef gameDB = NULL;
+
+static Err GamUpdateList() {
+	if (gameDB) {
+		UInt16 numRecs = DmNumRecords(gameDB);
+		
+		if (numRecs > 0) {
+			MemHandle tmpH;
+			UInt32 version, size;
+			UInt32 *versionP;
+
+			// get record size and version
+			tmpH = DmQueryRecord(gameDB, 0);
+			size = MemHandleSize(tmpH);
+			versionP = (UInt32 *)MemHandleLock(tmpH);
+			version = *versionP;
+			MemHandleUnlock(tmpH);
+
+			// check record
+			if (version != curItemVersion && size != sizeof(GameInfoType)) {
+				UInt16 index;
+				GameInfoType gitCur;
+				GameInfoTypeV0 git0;
+				void *tmpP;
+				FormPtr ofmP, frmP;
+				
+				// show dialog
+				ofmP = FrmGetActiveForm();
+				frmP = FrmInitForm(ConvertForm);
+				FrmSetActiveForm(frmP);
+				FrmDrawForm(frmP);
+				SysTaskDelay(200);
+
+				// need conversion from V0 -> V2
+				for (index = 0; index < numRecs; index++) {
+					
+					// get old data
+					tmpH = DmQueryRecord(gameDB, index);
+					tmpP = MemHandleLock(tmpH);
+					MemMove(&git0, tmpP, sizeof(GameInfoTypeV0));
+					MemHandleUnlock(tmpH);
+
+					// convert to new format
+					gitCur.version = curItemVersion;
+					gitCur.icnID = 0xFFFF;
+					gitCur.selected = git0.selected;
+					StrCopy(gitCur.nameP, git0.nameP);
+					StrCopy(gitCur.pathP, git0.pathP);
+					StrCopy(gitCur.gameP, git0.gameP);
+					gitCur.gfxMode = git0.gfxMode;
+					
+					gitCur.autoLoad = git0.autoLoad;
+					gitCur.autoRoom = git0.autoRoom;
+					gitCur.setPlatform = git0.amiga;	// amiga become platform amiga/atari-st/machintosh
+					gitCur.subtitles = git0.subtitles;
+					gitCur.talkSpeed = git0.talkSpeed;
+
+					gitCur.loadSlot = git0.loadSlot;
+					gitCur.roomNum = git0.roomNum;
+					gitCur.talkValue = git0.talkValue;
+					gitCur.platform = 0;	// default to amiga
+					gitCur.language = git0.language;
+					
+					tmpH = DmResizeRecord(gameDB, index, sizeof(GameInfoType));	// TODO : check error on resize tmpH==NULL
+					tmpP = MemHandleLock(tmpH);
+					DmWrite(tmpP, 0, &gitCur, sizeof(GameInfoType));
+					MemPtrUnlock(tmpP);
+				}
+
+				FrmEraseForm(frmP);
+				FrmDeleteForm(frmP);
+				if (ofmP)
+					FrmReturnToForm(MainForm);
+			}	
+		}
+	}
+	
+	return errNone;
+}
+
+Err GamOpenDatabase() {
+	Err err = errNone;
+
+	gameDB = DmOpenDatabaseByTypeCreator( 'DATA', appFileCreator, dmModeReadWrite);
+
+	if (!gameDB) {
+		err = DmCreateDatabase(0, "ScummVM-Data", appFileCreator, 'DATA', false);
+		if (!err) {
+			gameDB = DmOpenDatabaseByTypeCreator( 'DATA', appFileCreator, dmModeReadWrite);
+			
+			if (!gameDB)
+				err = DmGetLastErr();
+		}
+	}
+
+	if (err)
+		FrmCustomAlert(FrmErrorAlert,"Cannot open/create games list DB !",0,0);
+	else
+		err = GamUpdateList();
+
+	return err;
+}
+
+void GamImportDatabase() {
+	if (gPrefs->card.volRefNum != sysInvalidRefNum && gPrefs->card.moveDB) {
+		FileRef file;
+		Err e;
+		
+		e = VFSFileOpen(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata.pdb", vfsModeRead, &file);
+		if (!e) {
+			UInt16 oCardNo, nCardNo;
+			LocalID oDbID, nDbID;
+			UInt32 type = 'ODAT';	// change the type to avoid the old db to be loaded in case of crash
+
+			VFSFileClose(file);
+			if (gPrefs->card.confirmMoveDB)
+				if (FrmCustomAlert(FrmConfirmAlert, "Do you want to import games database from memory card ?", 0, 0) == FrmConfirmNo) {
+					// prevent to replace the file on memory card
+					gPrefs->card.moveDB = false;
+					return;
+				}
+ 			
+ 			// get current db info and rename it
+ 			DmOpenDatabaseInfo(gameDB, &oDbID, 0, 0, &oCardNo, 0);
+			GamCloseDatabase(true);
+			DmSetDatabaseInfo(oCardNo, oDbID, "ScummVM-Data-old.pdb", 0, 0, 0, 0, 0, 0, 0, 0, &type, 0);
+
+	
+			e = VFSImportDatabaseFromFile(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata.pdb", &nCardNo, &nDbID);
+			if (e) {
+				type = 'DATA';
+				FrmCustomAlert(FrmErrorAlert, "Failed to import games database from memory card.", 0, 0);
+				DmSetDatabaseInfo(oCardNo, oDbID, "ScummVM-Data.pdb", 0, 0, 0, 0, 0, 0, 0, 0, &type, 0);
+			} else {
+				// in OS5 the localID may change ... ? (cause Free Handle error) TODO : check if this is still required, crash now with tapwave !!!
+//				oDbID = DmFindDatabase (oCardNo, "ScummVM-Data-old.pdb");
+				e = DmDeleteDatabase(oCardNo, oDbID);
+			}
+			GamOpenDatabase();
+		}
+	}
+}
+
+void GamCloseDatabase(Boolean ignoreCardParams) {
+	if (gameDB) {
+		LocalID dbID;
+		UInt16 cardNo;
+		
+		DmOpenDatabaseInfo(gameDB, &dbID, 0, 0, &cardNo, 0);
+		DmCloseDatabase(gameDB);
+
+		if (!ignoreCardParams) {
+			if (gPrefs->card.moveDB && gPrefs->card.volRefNum != sysInvalidRefNum) {
+				VFSFileRename(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata.pdb", "listdata-old.pdb");
+				Err e = VFSExportDatabaseToFile(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata.pdb", cardNo, dbID);
+				if (!e) {
+					VFSFileDelete(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata-old.pdb");
+					if (gPrefs->card.deleteDB)
+						DmDeleteDatabase(cardNo, dbID);
+				} else {
+					VFSFileRename(gPrefs->card.volRefNum, "/Palm/Programs/ScummVM/listdata-old.pdb", "listdata.pdb");
+				}
+			}
+		}
+	}
+	gameDB = NULL;
+}
+
+static Int16 GamCompare(GameInfoType *a, GameInfoType *b, SortRecordInfoPtr, SortRecordInfoPtr, MemHandle) {
+	return StrCaselessCompare(a->nameP, b->nameP);
+}
+
+Err GamSortList() {
+	return DmQuickSort (gameDB, (DmComparF *)GamCompare, 0);
+}
+
+UInt16 GamGetSelected() {
+	MemHandle record;
+	GameInfoType *game;
+	Boolean selected;
+	UInt16 index = DmNumRecords(gameDB)-1;
+	
+	while (index != (UInt16)-1) {
+		record = DmQueryRecord(gameDB, index);
+		game = (GameInfoType *)MemHandleLock(record);
+		selected = game->selected;
+		MemHandleUnlock(record);
+
+		if (selected)
+			return index;
+
+		index--;
+	}
+
+	return dmMaxRecordIndex;
+}
diff --git a/backends/PalmOS/Src/games.h b/backends/PalmOS/Src/games.h
new file mode 100644
index 0000000000..ed60d1fb79
--- /dev/null
+++ b/backends/PalmOS/Src/games.h
@@ -0,0 +1,83 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifndef __GAMES_H__
+#define	__GAMES_H__
+
+// old config structs
+typedef struct {
+	UInt32	version;
+	UInt16	icnID;			// icon to display on the list
+	Boolean	selected;
+
+	Char 	nameP[50];		// game name to display in list
+	Char 	pathP[150];		// path to the game files
+	Char 	gameP[10];		// scumm name of the game
+	UInt16	gfxMode;
+
+	Boolean autoLoad;
+	UInt16 loadSlot;
+	Boolean autoRoom;
+	UInt16 roomNum;
+	Boolean amiga;
+	Boolean subtitles;
+	Boolean talkSpeed;
+	UInt16 talkValue;
+	UInt8 language;
+
+} GameInfoTypeV0;
+
+// Current config
+typedef struct {
+	UInt32	version;
+	UInt16	icnID;			// icon to display on the list
+	Boolean	selected;
+
+	Char 	nameP[50];		// game name to display in list
+	Char 	pathP[150];		// path to the game files
+	Char 	gameP[10];		// scumm name of the game
+	UInt16	gfxMode;
+
+	Boolean autoLoad;
+	Boolean autoRoom;
+	Boolean setPlatform;
+	Boolean subtitles;
+	Boolean talkSpeed;
+
+	UInt16 loadSlot;
+	UInt16 roomNum;
+	UInt16 talkValue;
+	UInt8 platform;
+	UInt8 language;
+
+} GameInfoType;
+
+// protos
+Err		GamOpenDatabase		();
+void	GamImportDatabase	();
+void	GamCloseDatabase	(Boolean ignoreCardParams);
+Err		GamSortList			();
+UInt16	GamGetSelected		();
+
+extern DmOpenRef gameDB;
+
+#endif
\ No newline at end of file
diff --git a/backends/PalmOS/Src/scumm_globals.cpp b/backends/PalmOS/Src/scumm_globals.cpp
new file mode 100644
index 0000000000..e27bc89466
--- /dev/null
+++ b/backends/PalmOS/Src/scumm_globals.cpp
@@ -0,0 +1,105 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+#include <PalmOS.h>
+
+#include "start.h"
+#include "globals.h"
+#include "scumm_globals.h"
+
+static void GlbInitAll() {
+#ifndef DISABLE_SCUMM
+	CALL_INIT(IMuseDigital)
+	CALL_INIT(NewGui)
+	CALL_INIT(Akos)
+	CALL_INIT(Bundle)
+	CALL_INIT(Codec47)
+	CALL_INIT(Gfx)
+	CALL_INIT(Dialogs)
+	CALL_INIT(Charset)
+	CALL_INIT(Costume)
+	CALL_INIT(PlayerV2)
+#endif
+}
+
+static void GlbReleaseAll() {
+#ifndef DISABLE_SCUMM
+	CALL_RELEASE(IMuseDigital)
+	CALL_RELEASE(NewGui)
+	CALL_RELEASE(Akos)
+	CALL_RELEASE(Bundle)
+	CALL_RELEASE(Codec47)
+	CALL_RELEASE(Gfx)
+	CALL_RELEASE(Dialogs)
+	CALL_RELEASE(Charset)
+	CALL_RELEASE(Costume)
+	CALL_RELEASE(PlayerV2)
+#endif
+}
+
+//TODO : use Boolean instead of void to check err
+static DmOpenRef GlbOpenInternal(const Char *nameP) {
+	LocalID dbID = DmFindDatabase(0, nameP);
+	if (dbID) {
+		UInt32 dbType, dbCreator;
+		Err e = DmDatabaseInfo(0, dbID, 0, 0, 0, 0, 0, 0, 0, 0, 0, &dbType, &dbCreator);
+		
+		if (!e && dbType == 'GLBS' && dbCreator == appFileCreator)
+			return DmOpenDatabase(0, dbID, dmModeReadOnly);
+	}
+	return NULL;
+}
+
+void GlbOpen() {
+	gVars->globals[GBVARS_SCUMM] = GlbOpenInternal("Scumm-Globals");
+	gVars->globals[GBVARS_SIMON] = GlbOpenInternal("Simon-Globals");
+	gVars->globals[GBVARS_SKY] = GlbOpenInternal("Sky-Globals");
+	
+	GlbInitAll();
+}
+
+void GlbClose() {
+	GlbReleaseAll();
+
+	if (gVars->globals[GBVARS_SCUMM])
+		DmCloseDatabase(gVars->globals[GBVARS_SCUMM]);
+	if (gVars->globals[GBVARS_SIMON])
+		DmCloseDatabase(gVars->globals[GBVARS_SIMON]);
+	if (gVars->globals[GBVARS_SKY])
+		DmCloseDatabase(gVars->globals[GBVARS_SKY]);
+}
+
+void *GlbGetRecord(UInt16 index, UInt16 id) {
+	if (gVars->globals[id]) {
+		MemHandle recordH = DmQueryRecord(gVars->globals[id], index);
+		if (recordH)
+			return MemHandleLock(recordH);
+	}
+	return NULL;
+}
+
+void GlbReleaseRecord(UInt16 index, UInt16 id) {
+	if (gVars->globals[id]) {
+		MemHandle recordH = DmQueryRecord(gVars->globals[id], index);
+		if (recordH)
+			MemHandleUnlock(recordH);
+	}
+}
\ No newline at end of file
diff --git a/backends/PalmOS/Src/skin.cpp b/backends/PalmOS/Src/skin.cpp
new file mode 100644
index 0000000000..092c32067a
--- /dev/null
+++ b/backends/PalmOS/Src/skin.cpp
@@ -0,0 +1,568 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <PalmOS.h>
+#include <PalmOSGlue.h>
+
+#include "start.h"
+#include "games.h"
+#include "globals.h"
+#include "skin.h"
+#include "StarterRsc.h"
+
+UInt16 lastIndex = dmMaxRecordIndex;	// last select index in the list to prevent flash
+
+static void SknGetListColors(DmOpenRef skinDBP, DmResID resID, UInt8 *text, UInt8 *selected, UInt8 *background) {
+	UInt16 colIndex;
+	MemHandle colH;
+	UInt8 *colTemp;
+
+	// default
+	*text = UIColorGetTableEntryIndex (UIMenuForeground);
+	*selected = UIColorGetTableEntryIndex (UIMenuSelectedForeground);
+	*background = UIColorGetTableEntryIndex (UIMenuSelectedFill);
+
+	if (skinDBP) {
+		colIndex = DmFindResource (skinDBP, sknColorsRsc, resID, NULL);
+		
+		if (colIndex != (UInt16)-1) {
+			colH = DmGetResourceIndex(skinDBP, colIndex);
+			
+			if (colH) {
+				colTemp = (UInt8 *)MemHandleLock(colH);
+				
+				*text = colTemp[0];
+				*selected = colTemp[1];
+				*background = colTemp[2];
+
+				MemPtrUnlock(colTemp);
+				DmReleaseResource(colH);
+			}
+		}
+	}
+}
+
+static void SknCopyBits(DmOpenRef skinDBP, DmResID bitmapID, const RectangleType *srcRect, Coord destX, Coord destY, Boolean standard) {
+	MemHandle hTemp;
+	BitmapPtr bmpTemp;
+	UInt16 index;
+	UInt8 *bmpData;
+
+	Coord cx, cy, cw, ch, bw, bh;
+	UInt8 *dst, *src;
+
+	if (skinDBP) {
+		// find the bitmap
+		index = DmFindResource (skinDBP, bitmapRsc, bitmapID, NULL);
+
+		if (index != (UInt16)-1) {
+			hTemp = DmGetResourceIndex(skinDBP,index);
+			
+			if (hTemp) {
+				bmpTemp = (BitmapType *)MemHandleLock(hTemp);
+				BmpGlueGetDimensions(bmpTemp, &bw, &bh, 0);
+
+				if (!srcRect) {
+					cx = 0;
+					cy = 0;
+					cw = bw;
+					ch = bh;
+				} else {
+					cx = srcRect->topLeft.x;
+					cy = srcRect->topLeft.y;
+					cw = srcRect->extent.x;
+					ch = srcRect->extent.y;
+				}
+
+				if (ch) {
+					Coord picth = gVars->screenFullWidth;
+					dst = (UInt8 *)BmpGetBits(WinGetBitmap(WinGetDisplayWindow()));
+				
+					dst+= destX + destY * picth;
+					bmpData = (UInt8 *)BmpGetBits(bmpTemp);
+					src	= bmpData + cx + cy * bw;
+
+					do {
+						MemMove(dst, src, cw);
+						dst += picth;
+						src += bw;
+					} while (--ch);
+				}
+
+				MemPtrUnlock(bmpTemp);
+				DmReleaseResource(hTemp);
+			}
+		}
+	}
+}
+
+void SknApplySkin() {
+	DmOpenRef skinDBP;
+	RectangleType r;
+	FormPtr frmP = FrmGetActiveForm();
+
+	WinScreenLock(winLockErase);
+	//SknSetPalette();
+	FrmDrawForm(frmP);
+
+	if (gPrefs->card.volRefNum != sysInvalidRefNum)
+		FrmShowObject(frmP, FrmGetObjectIndex (frmP, MainMSBitMap));
+	else
+		FrmShowObject(frmP, FrmGetObjectIndex (frmP, MainMSNoneBitMap));
+
+	WinSetForeColor(255);
+	WinSetDrawMode(winPaint);
+	WinDrawLine (0, 14, 159, 14);
+	WinDrawLine (0, 13, 159, 13);
+
+	skinDBP = SknOpenSkin();
+	SknGetObjectBounds(skinDBP, skinBackgroundImageTop, &r);
+	SknCopyBits(skinDBP, skinBackgroundImageTop, 0, r.topLeft.x, r.topLeft.y, 0);
+	SknGetObjectBounds(skinDBP, skinBackgroundImageBottom, &r);
+	SknCopyBits(skinDBP, skinBackgroundImageBottom, 0, r.topLeft.x, r.topLeft.y, 0);
+
+	for (UInt16 resID = 1100; resID <= 7000; resID += 100) {
+		SknSetState(skinDBP, resID, sknStateNormal);
+		SknShowObject(skinDBP, resID);
+	}
+
+	SknCloseSkin(skinDBP);
+	WinScreenUnlock();
+	SknUpdateList();
+	
+	gVars->skinSet = true;	// for winDisplayChangedEvent redraw
+}
+
+void SknGetObjectBounds(DmOpenRef skinDBP, DmResID resID, RectangleType *rP) {
+
+	UInt16 bmpIndex, strIndex;
+	MemHandle hBmp, hStr;
+	BitmapType *bmpTemp;
+	UInt8 *strTemp;
+
+	RctSetRectangle(rP, 0, 0, 0, 0);
+	
+	if (skinDBP) {
+		bmpIndex = DmFindResource (skinDBP, bitmapRsc, resID, NULL);
+		
+		if (bmpIndex != (UInt16)-1) {						// if bmp exists
+			strIndex = DmFindResource (skinDBP, sknPosRsc, resID, NULL);
+			
+			if (strIndex != (UInt16)-1) {					// if params exist
+				hBmp = DmGetResourceIndex(skinDBP,bmpIndex);
+
+				if (hBmp) {
+					hStr = DmGetResourceIndex(skinDBP,strIndex);
+					
+					if (hStr) {
+					//	buttons : state|x|y|w/h slider|draw mode|x1/y1 keep|x2/y2 keep slider
+					//	list (160mode) : state|x|y|w|h|
+						bmpTemp = (BitmapType *)MemHandleLock(hBmp);
+						strTemp = (UInt8 *)MemHandleLock(hStr);
+						
+						BmpGlueGetDimensions(bmpTemp, &(rP->extent.x), &(rP->extent.y), 0);
+						rP->topLeft.x = strTemp[sknInfoPosX] * 2;
+						rP->topLeft.y = strTemp[sknInfoPosY] * 2;
+						
+						MemPtrUnlock(strTemp);					
+						DmReleaseResource(hStr);
+					}
+
+					MemPtrUnlock(bmpTemp);
+					DmReleaseResource(hBmp);
+				}
+			}
+		}
+	}
+}
+
+DmOpenRef SknOpenSkin() {
+	return DmOpenDatabase(gPrefs->skin.cardNo, gPrefs->skin.dbID, dmModeReadOnly);
+}
+
+void SknCloseSkin(DmOpenRef skinDBP) {
+	if (skinDBP)
+		DmCloseDatabase(skinDBP);
+}
+
+UInt8 SknSetState(DmOpenRef skinDBP, DmResID resID, UInt8 newState) {
+
+	UInt16 index;
+	MemHandle hStr;
+	UInt8 *strTemp;
+	UInt8 oldState = 0;
+
+	if (skinDBP) {
+		index = DmFindResource (skinDBP, sknPosRsc, resID, NULL);
+		
+		if (index != (UInt16)-1) {
+			hStr = DmGetResourceIndex(skinDBP, index);
+			
+			if (hStr) {
+				strTemp = (UInt8 *)MemHandleLock(hStr);
+				oldState = strTemp[sknInfoState];
+				
+				if (oldState != newState) {
+					DmWrite(strTemp, 0, &newState, 1);
+				}
+				
+				MemPtrUnlock(strTemp);					
+				DmReleaseResource(hStr);				
+			}
+		}
+	}
+
+	return oldState;
+}
+
+UInt8 SknGetState(DmOpenRef skinDBP, DmResID resID) {
+
+	UInt16 index;
+	MemHandle hStr;
+	UInt8 *strTemp;
+	UInt8 oldState = sknStateDisabled;
+
+	if (skinDBP) {
+		index = DmFindResource (skinDBP, sknPosRsc, resID, NULL);
+		
+		if (index != (UInt16)-1) {
+			hStr = DmGetResourceIndex(skinDBP, index);
+			
+			if (hStr) {
+				strTemp = (UInt8 *)MemHandleLock(hStr);
+				oldState = strTemp[sknInfoState];				
+				MemPtrUnlock(strTemp);					
+				DmReleaseResource(hStr);				
+			}
+		}
+	}
+
+	return oldState;
+}
+
+void SknShowObject(DmOpenRef skinDBP, DmResID resID) {
+
+	RectangleType r;
+	UInt8 state = SknGetState(skinDBP, resID);
+	SknGetObjectBounds(skinDBP, resID, &r);
+	SknCopyBits(skinDBP, resID + state, NULL, r.topLeft.x, r.topLeft.y, 0);
+}
+
+void SknGetListBounds(RectangleType *rAreaP, RectangleType *rArea2xP) {
+	DmOpenRef skinDBP;
+	UInt16 strIndex;
+	MemHandle hStr;
+	UInt8 *strTemp;
+	UInt16 x,y,w,h;
+
+	skinDBP = DmOpenDatabase(gPrefs->skin.cardNo, gPrefs->skin.dbID, dmModeReadOnly);
+	if (skinDBP) {
+		strIndex = DmFindResource (skinDBP, sknPosRsc, skinList, NULL);
+		
+		if (strIndex != 0xFFFF) {					// if params exist
+			hStr = DmGetResourceIndex(skinDBP,strIndex);
+			if (hStr) {
+				strTemp = (UInt8 *)MemHandleLock(hStr);
+
+				x = strTemp[sknInfoPosX];
+				y = strTemp[sknInfoPosY];
+				w = strTemp[sknInfoListWidth];
+				h = strTemp[sknInfoListSize] * sknInfoListItemSize;
+				
+				if (rAreaP)
+					RctSetRectangle(rAreaP ,x, y, w, h);
+				if (rArea2xP)
+					RctSetRectangle(rArea2xP, x+x, y+y, w+w, h+h);
+
+				MemHandleUnlock(hStr);
+				DmReleaseResource(hStr);
+				
+			}
+		}
+
+		DmCloseDatabase(skinDBP);
+	}
+}
+
+static void SknRedrawTools(DmOpenRef skinDBP) {
+	if (GamGetSelected() == dmMaxRecordIndex) {
+		if (SknGetState(skinDBP, skinButtonGameDelete) == sknStateNormal) {
+			SknSetState(skinDBP, skinButtonGameDelete,sknStateDisabled);
+			SknShowObject(skinDBP, skinButtonGameDelete);
+		}
+		if (SknGetState(skinDBP, skinButtonGameEdit) == sknStateNormal) {
+			SknSetState(skinDBP, skinButtonGameEdit,sknStateDisabled);
+			SknShowObject(skinDBP, skinButtonGameEdit);
+		}
+
+	} else {
+		if (SknGetState(skinDBP, skinButtonGameDelete) == sknStateDisabled) {
+			SknSetState(skinDBP, skinButtonGameDelete,sknStateNormal);
+			SknShowObject(skinDBP, skinButtonGameDelete);
+		}
+		if (SknGetState(skinDBP, skinButtonGameEdit) == sknStateDisabled) {
+			SknSetState(skinDBP, skinButtonGameEdit,sknStateNormal);
+			SknShowObject(skinDBP, skinButtonGameEdit);
+		}
+	}
+}
+
+static void SknRedrawSlider(DmOpenRef skinDBP, UInt16 index, UInt16 maxIndex, UInt16 perPage) {
+	if (maxIndex <= perPage) {
+		if (SknGetState(skinDBP,skinSliderUpArrow) != sknStateDisabled) {
+			SknSetState(skinDBP,skinSliderUpArrow,sknStateDisabled);
+			SknShowObject(skinDBP,skinSliderUpArrow);
+		}
+		if (SknGetState(skinDBP,skinSliderDownArrow) != sknStateDisabled) {
+			SknSetState(skinDBP,skinSliderDownArrow,sknStateDisabled);
+			SknShowObject(skinDBP,skinSliderDownArrow);
+		}
+
+	} else {
+		if (SknGetState(skinDBP,skinSliderUpArrow) == sknStateDisabled) {
+			SknSetState(skinDBP,skinSliderUpArrow,sknStateNormal);
+			SknShowObject(skinDBP,skinSliderUpArrow);
+		}
+		if (SknGetState(skinDBP,skinSliderDownArrow) == sknStateDisabled) {
+			SknSetState(skinDBP,skinSliderDownArrow,sknStateNormal);
+			SknShowObject(skinDBP,skinSliderDownArrow);
+		}
+	}
+}
+
+/*
+static void SknSetPalette() {
+
+	UInt16 palIndex;
+	ColorTableType *palTemp;
+	MemHandle palH;
+
+	DmOpenRef skinDBP = SknOpenSkin();
+
+	if (skinDBP) {
+		palIndex = DmFindResource (skinDBP, colorTableRsc, skinPalette, NULL);
+
+		if (palIndex != 0xFFFF) {
+			palH = DmGetResourceIndex(skinDBP, palIndex);
+			
+			if (palH) {
+				palTemp = (ColorTableType *)MemHandleLock(palH);
+				WinPalette(winPaletteSet, 0, 256, ColorTableEntries(palTemp));
+				MemPtrUnlock(palTemp);					
+				DmReleaseResource(palH);
+			}
+		}
+	}
+	
+	SknCloseSkin(skinDBP);
+
+}
+*/
+
+void SknUpdateList() {
+	MemHandle record;
+	UInt16 index, maxIndex, maxView;
+	GameInfoType *game;
+	RectangleType rArea, rField, rCopy, rArea2x;
+	DmOpenRef skinDBP;
+
+	UInt8 txtColor, norColor, selColor, bkgColor;
+	UInt16 x,y;
+
+	WinScreenLock(winLockCopy);
+	SknGetListBounds(&rArea, &rArea2x);
+	skinDBP = SknOpenSkin();
+	// set default bg
+	WinSetForeColor(UIColorGetTableEntryIndex (UIFormFill));
+	WinDrawRectangle(&rArea,0);
+	// copy top bg
+	SknGetObjectBounds(skinDBP, skinBackgroundImageTop, &rField);
+	RctGetIntersection(&rArea2x, &rField, &rCopy);
+	x = rCopy.topLeft.x;
+	y = rCopy.topLeft.y;
+	rCopy.topLeft.x	-= rField.topLeft.x;
+	rCopy.topLeft.y	-= rField.topLeft.y;	
+	SknCopyBits(skinDBP, skinBackgroundImageTop, &rCopy, x, y, 0);
+	// copy bottom bg
+	SknGetObjectBounds(skinDBP, skinBackgroundImageBottom, &rField);
+	RctGetIntersection(&rArea2x, &rField, &rCopy);
+	x = rCopy.topLeft.x;
+	y = rCopy.topLeft.y;
+	rCopy.topLeft.x	-= rField.topLeft.x;
+	rCopy.topLeft.y	-= rField.topLeft.y;	
+	SknCopyBits(skinDBP, skinBackgroundImageBottom, &rCopy, x, y, 0);
+
+	FntSetFont(stdFont);
+
+	index = gPrefs->listPosition;
+	maxIndex = DmNumRecords(gameDB);
+	maxView = rArea.extent.y / sknInfoListItemSize;
+
+	if (index > 0 && (index+maxView) > maxIndex) {
+		index -= (index+maxView) - maxIndex;
+		 gPrefs->listPosition = index;
+	}	
+	SknRedrawSlider(skinDBP, index, maxIndex, maxView);
+	SknRedrawTools(skinDBP);
+	SknGetListColors(skinDBP, skinColors, &norColor, &selColor, &bkgColor);
+
+	SknCloseSkin(skinDBP);
+
+	while (index < (gPrefs->listPosition + maxView) && index < maxIndex) {
+		record = DmQueryRecord(gameDB, index);
+		game = (GameInfoType *)MemHandleLock(record);
+
+		// text box
+		RctSetRectangle(&rField, rArea.topLeft.x, (rArea.topLeft.y + sknInfoListItemSize * (index - gPrefs->listPosition)), rArea.extent.x, sknInfoListItemSize);
+		WinSetClip(&rField);
+
+		if (game->selected) {
+			WinSetDrawMode(winPaint);
+			WinSetForeColor(bkgColor);
+			WinDrawRectangle(&rField,0);
+			txtColor = selColor;
+		}
+		else
+			txtColor = norColor;
+
+		// clipping
+		rField.topLeft.x += 2;
+		rField.extent.x -= 4;
+		WinSetClip(&rField);
+		// draw text mask
+		WinSetTextColor(255);
+		WinSetDrawMode(winMask);
+		WinPaintChars(game->nameP, StrLen(game->nameP), rField.topLeft.x, rField.topLeft.y);
+		// draw text
+		if (txtColor) {
+			WinSetTextColor(txtColor);
+			WinSetDrawMode(winOverlay);
+			WinPaintChars(game->nameP, StrLen(game->nameP), rField.topLeft.x, rField.topLeft.y);
+		}
+
+		MemHandleUnlock(record);
+		index++;
+	}
+
+	RctSetRectangle(&rArea,0,0,160,160);
+	WinSetClip(&rArea);
+	WinScreenUnlock();
+}
+
+UInt16 SknCheckClick(DmOpenRef skinDBP, Coord mx, Coord my) {
+	UInt16 resID;
+	RectangleType r;
+
+	mx *= 2;
+	my *= 2;
+
+	if (skinDBP) {
+		for (resID = 1100; resID <= 7000; resID += 100) {
+			if (SknGetState(skinDBP, resID) != sknStateDisabled) {
+				SknGetObjectBounds(skinDBP, resID, &r);
+				if (RctPtInRectangle(mx, my, &r)) {
+					return resID;
+				}
+			}
+		}
+		
+	}
+	
+	return 0;
+}
+
+void SknSelect(Coord x, Coord y) {
+	RectangleType rArea;
+	SknGetListBounds(&rArea,0);
+
+	if (RctPtInRectangle(x, y, &rArea)) {
+		UInt16 index;
+		MemHandle record;
+		GameInfoType *game;
+		UInt16 oldIndex;
+
+		index = (y - rArea.topLeft.y) / sknInfoListItemSize + gPrefs->listPosition;
+
+		if (index == lastIndex)
+			return;
+
+		if (index < DmNumRecords(gameDB)) {
+			GameInfoType modGame;
+
+			oldIndex = GamGetSelected();
+			record = DmGetRecord(gameDB, index);
+			game = (GameInfoType *)MemHandleLock(record);
+
+			MemMove(&modGame, game, sizeof(GameInfoType));	
+			modGame.selected = !modGame.selected;
+			DmWrite(game, 0, &modGame, sizeof(GameInfoType));
+
+			MemHandleUnlock(record);
+			DmReleaseRecord (gameDB, index, 0);
+
+			if (oldIndex != index && oldIndex != dmMaxRecordIndex)	{
+				record = DmGetRecord(gameDB, oldIndex);
+				game = (GameInfoType *)MemHandleLock(record);
+
+				MemMove(&modGame, game, sizeof(GameInfoType));	
+				modGame.selected = false;
+				DmWrite(game, 0, &modGame, sizeof(GameInfoType));
+
+				MemHandleUnlock(record);
+				DmReleaseRecord (gameDB, oldIndex, 0);
+			}
+			
+			lastIndex = index;
+			SknUpdateList();
+		}
+	}
+}
+
+Boolean SknProcessArrowAction(UInt16 button) {
+	Boolean handled = false;
+
+	switch (button) {
+		case skinSliderUpArrow:
+			if (gPrefs->listPosition > 0) {
+				gPrefs->listPosition--;
+				SknUpdateList();
+			}
+			handled = true;
+			break;
+
+		case skinSliderDownArrow:
+			RectangleType rArea;
+			UInt16 maxView;
+
+			SknGetListBounds(&rArea, 0);
+			maxView = rArea.extent.y / sknInfoListItemSize;
+
+			if (gPrefs->listPosition < DmNumRecords(gameDB)-maxView) {
+				gPrefs->listPosition++;
+				SknUpdateList();
+			}
+			handled = true;
+			break;
+	}
+
+	return handled;
+}
\ No newline at end of file
diff --git a/backends/PalmOS/Src/start.cpp b/backends/PalmOS/Src/start.cpp
new file mode 100644
index 0000000000..f4da9f0b63
--- /dev/null
+++ b/backends/PalmOS/Src/start.cpp
@@ -0,0 +1,2808 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <PalmOS.h>
+#include <SonyClie.h>
+
+#include "StarterRsc.h"
+#include "skin.h"
+#include "globals.h"
+#include "scumm_globals.h"
+#include "engine.h"
+#include "vibrate.h"
+#include "pa1lib.h"
+#include "start.h"
+#include "games.h"
+
+#ifndef DISABLE_TAPWAVE
+//#include "tapwave.h"
+#endif
+
+/***********************************************************************
+ *
+ *	Internal Structures
+ *
+ ***********************************************************************/
+
+typedef struct {
+	UInt16 volRefNum;
+	Char nameP[expCardInfoStringMaxLen+1];
+
+} CardInfoType;
+
+/***********************************************************************
+ *
+ *	Global variables
+ *
+ ***********************************************************************/
+GlobalsPreferencePtr gPrefs;
+GlobalsDataPtr gVars;
+
+static UInt16 sknLastOn = skinButtonNone;
+static Boolean bStartScumm = false;
+
+// form list draw
+#define	ITEM_TYPE_UNKNOWN	'U'
+#define ITEM_TYPE_CARD		'C'
+#define ITEM_TYPE_SKIN		'S'
+
+#define frmRedrawUpdateMS		(frmRedrawUpdateCode+1)
+#define frmRedrawUpdateMSImport	(frmRedrawUpdateCode+2)
+
+static Char **itemsText = NULL;
+static void  *itemsList = NULL;
+static Char   itemsType = ITEM_TYPE_UNKNOWN;
+/***********************************************************************
+ *
+ *	Internal Constants
+ *
+ ***********************************************************************/
+#define appVersionNum			0x01
+#define appPrefID				0x00
+#define appPrefVersionNum		0x01
+
+// Define the minimum OS version we support (3.5 for now).
+#define kOurMinVersion	sysMakeROMVersion(3,5,0,sysROMStageRelease,0)
+#define kPalmOS10Version	sysMakeROMVersion(1,0,0,sysROMStageRelease,0)
+#define kOS5Version		sysMakeROMVersion(5,0,0,sysROMStageRelease,0)
+
+// edit game mode
+enum {
+	edtModeAdd,
+	edtModeEdit,
+	edtModeParams
+} editMode;
+/***********************************************************************
+ *
+ *	Internal Functions
+ *
+ ***********************************************************************/
+
+
+static void FrmReturnToMain(UInt16 updateCode = frmRedrawUpdateMS) {
+	// if there is a form loaded, prevent crash on OS5
+	if (FrmGetFirstForm()) {
+		FrmUpdateForm(MainForm, updateCode);
+		FrmReturnToForm(MainForm);
+	}
+}
+
+
+
+ /////////////////////////////////////////////////////////////////////////
+
+// Callback for ExgDBWrite to send data with Exchange Manager
+static Err WriteDBData(const void* dataP, UInt32* sizeP, void* userDataP)
+{
+	Err err;
+	*sizeP = ExgSend((ExgSocketPtr)userDataP, (void*)dataP, *sizeP, &err);
+	return err;
+}
+
+static Err SendDatabase (UInt16 cardNo, LocalID dbID, Char *nameP, Char *descriptionP)
+{
+	ExgSocketType exgSocket;
+	Err err;
+
+	// Create exgSocket structure
+	MemSet(&exgSocket, sizeof(exgSocket), 0);
+	exgSocket.description = descriptionP;
+	exgSocket.name = nameP;
+
+	// Start an exchange put operation
+	err = ExgPut(&exgSocket);
+	if (!err) {
+		err = ExgDBWrite(WriteDBData, &exgSocket, NULL, dbID, cardNo);
+		err = ExgDisconnect(&exgSocket, err);
+	}
+
+	return err;
+}
+
+static Err BeamMe() {
+	UInt16 cardNo;
+	LocalID dbID;
+	Err err;
+
+	err = SysCurAppDatabase(&cardNo, &dbID);
+	if (dbID)
+		err = SendDatabase(0, dbID, "ScummVM.prc", "\nPlay your favorite LucasArts games");
+	else
+		err = DmGetLastErr();
+	
+	return err;
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    RomVersionCompatible
+ *
+ * DESCRIPTION: This routine checks that a ROM version is meet your
+ *              minimum requirement.
+ *
+ * PARAMETERS:  requiredVersion - minimum rom version required
+ *                                (see sysFtrNumROMVersion in SystemMgr.h 
+ *                                for format)
+ *              launchFlags     - flags that indicate if the application 
+ *                                UI is initialized.
+ *
+ * RETURNED:    error code or zero if rom is compatible
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static Err RomVersionCompatible(UInt32 requiredVersion, UInt16 launchFlags)
+{
+	UInt32 romVersion;
+
+	// See if we're on in minimum required version of the ROM or later.
+	FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion);
+	if (romVersion < requiredVersion)
+		{
+		if ((launchFlags & (sysAppLaunchFlagNewGlobals | sysAppLaunchFlagUIApp)) ==
+			(sysAppLaunchFlagNewGlobals | sysAppLaunchFlagUIApp))
+			{
+			FrmAlert (RomIncompatibleAlert);
+		
+			// Palm OS 1.0 will continuously relaunch this app unless we switch to 
+			// another safe one.
+			if (romVersion <= kPalmOS10Version)
+				{
+				AppLaunchWithCommand(sysFileCDefaultApp, sysAppLaunchCmdNormalLaunch, NULL);
+				}
+			}
+		return sysErrRomIncompatible;
+		}
+
+	return errNone;
+}
+
+
+/***********************************************************************
+ *
+ * FUNCTION:    GetObjectPtr
+ *
+ * DESCRIPTION: This routine returns a pointer to an object in the current
+ *              form.
+ *
+ * PARAMETERS:  formId - id of the form to display
+ *
+ * RETURNED:    void *
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void * GetObjectPtr(UInt16 objectID)
+{
+	FormPtr frmP;
+
+	frmP = FrmGetActiveForm();
+	return FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, objectID));
+}
+
+static void FrmList(EventPtr eventP, UInt16 objectID)
+{
+	ListType *listP;
+	UInt16 listItem;
+
+	listP = (ListType *)GetObjectPtr(objectID);
+	listItem = LstPopupList(listP);
+	CtlSetLabel(eventP->data.ctlSelect.pControl, LstGetSelectionText(listP, LstGetSelection(listP)));
+}
+
+//#############################################################################
+//#############################################################################
+
+
+static void GamUnselect() {
+	GameInfoType modGame;
+	GameInfoType *game;
+
+	MemHandle recordH;
+	UInt16 index;
+
+	index = GamGetSelected();
+	
+	if (index != dmMaxRecordIndex) {
+		recordH = DmGetRecord(gameDB, index);
+		game = (GameInfoType *)MemHandleLock(recordH);
+
+		MemMove(&modGame, game, sizeof(GameInfoType));	
+		modGame.selected = !modGame.selected;
+		DmWrite(game, 0, &modGame, sizeof(GameInfoType));
+
+		MemHandleUnlock(recordH);
+		DmReleaseRecord (gameDB, index, 0);
+	}
+}
+
+static void FldTrimText(FieldType * fldP) {
+	MemHandle tmpH;
+	Char *tmpP;
+
+	tmpH = FldGetTextHandle(fldP);
+	FldSetTextHandle(fldP, NULL);
+	tmpP = (Char *)MemHandleLock(tmpH);
+	TxtGlueStripSpaces(tmpP, true, true);
+	MemHandleUnlock(tmpH);
+	FldSetTextHandle(fldP, tmpH);
+}
+
+
+/***********************************************************************
+ *
+ * FUNCTION:    EditGameFormSave
+ * FUNCTION:    EditGameFormInit
+ * FUNCTION:    EditGameFormHandleEvent
+ *
+ * DESCRIPTION: 
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void EditGameFormDelete(Boolean direct) {
+	UInt16 index = GamGetSelected();
+
+	if (index == dmMaxRecordIndex) {
+		FrmCustomAlert(FrmWarnAlert, "Select an entry first.",0,0);
+		return;
+
+	} else if (FrmCustomAlert(FrmConfirmAlert, "Do you really want to delete this entry ?", 0, 0) == FrmConfirmYes) {
+		DmRemoveRecord(gameDB, index);
+		if (!direct)
+			FrmReturnToMain();
+		GamSortList();
+		SknUpdateList();
+	}
+}
+
+static void EditGameFormSave(UInt16 index) {
+
+	FieldType *fld1P, *fld2P, *fld3P, *fld4P, *fld5P, *fld6P;	// need to change this with good names
+	ControlType *cck1P, *cck2P, *cck3P, *cck4P, *cck5P;	
+	ListType *list1P, *list2P, *list3P;
+	FormPtr frmP;
+
+	MemHandle recordH;
+	GameInfoType *gameInfo, newGameInfo;
+//	UInt16 index;
+
+	list1P = (ListType *)GetObjectPtr(EditGameGfxListList);
+	list2P = (ListType *)GetObjectPtr(EditGameLanguageList);
+	list3P = (ListType *)GetObjectPtr(EditGamePlatformList);
+	
+	fld1P = (FieldType *)GetObjectPtr(EditGameEntryNameField);
+	fld2P = (FieldType *)GetObjectPtr(EditGamePathField);
+	fld3P = (FieldType *)GetObjectPtr(EditGameGameField);
+	fld4P = (FieldType *)GetObjectPtr(EditGameLoadSlotField);
+	fld5P = (FieldType *)GetObjectPtr(EditGameStartRoomField);
+	fld6P = (FieldType *)GetObjectPtr(EditGameTalkSpeedField);
+	
+	cck1P = (ControlType *)GetObjectPtr(EditGameLoadSlotCheckbox);
+	cck2P = (ControlType *)GetObjectPtr(EditGameStartRoomCheckbox);
+	cck3P = (ControlType *)GetObjectPtr(EditGameAmigaCheckbox);
+	cck4P = (ControlType *)GetObjectPtr(EditGameSubtitlesCheckbox);
+	cck5P = (ControlType *)GetObjectPtr(EditGameTalkSpeedCheckbox);
+
+	frmP = FrmGetActiveForm();
+
+	FldTrimText(fld1P);
+	FldTrimText(fld2P);
+	FldTrimText(fld3P);
+
+	if (FldGetTextLength(fld1P) == 0) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified an entry name.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, EditGameEntryNameField));
+		return;
+	} else if (FldGetTextLength(fld2P) == 0) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified a path.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, EditGamePathField));
+		return;
+	} else if (FldGetTextLength(fld3P) == 0) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified a game.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, EditGameGameField));
+		return;
+	} else if (FldGetTextLength(fld5P) == 0 && CtlGetValue(cck2P) == 1) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified a room number.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, EditGameStartRoomField));
+		return;
+	} else if (FldGetTextLength(fld6P) == 0 && CtlGetValue(cck5P) == 1) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified a talk speed.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, EditGameTalkSpeedField));
+		return;
+	}
+
+//	index = GamGetSelected();
+
+	if (index != dmMaxRecordIndex) {
+		recordH = DmGetRecord(gameDB, index);
+	} else {
+		index = dmMaxRecordIndex;
+		GamUnselect();
+		recordH = DmNewRecord(gameDB, &index, sizeof(GameInfoType));
+	}
+
+	gameInfo = (GameInfoType *)MemHandleLock(recordH);
+
+	StrCopy(newGameInfo.nameP, FldGetTextPtr(fld1P));
+	StrCopy(newGameInfo.pathP, FldGetTextPtr(fld2P));
+	StrCopy(newGameInfo.gameP, FldGetTextPtr(fld3P));
+
+	if (newGameInfo.pathP[StrLen(newGameInfo.pathP)-1] != '/')
+		StrCat(newGameInfo.pathP, "/");
+
+	newGameInfo.version	= curItemVersion;
+	newGameInfo.icnID = 0xFFFF;
+	newGameInfo.gfxMode = LstGetSelection(list1P);
+	newGameInfo.language = LstGetSelection(list2P);
+	newGameInfo.platform = LstGetSelection(list3P);
+	newGameInfo.selected = true;
+	newGameInfo.autoLoad = CtlGetValue(cck1P);
+	newGameInfo.loadSlot = StrAToI(FldGetTextPtr(fld4P));
+	newGameInfo.autoRoom = CtlGetValue(cck2P);
+	newGameInfo.roomNum = StrAToI(FldGetTextPtr(fld5P));
+	newGameInfo.setPlatform = CtlGetValue(cck3P);
+	newGameInfo.subtitles = !(CtlGetValue(cck4P));
+	newGameInfo.talkValue = StrAToI(FldGetTextPtr(fld6P));
+	newGameInfo.talkSpeed = CtlGetValue(cck5P);
+
+	DmWrite(gameInfo, 0, &newGameInfo, sizeof(GameInfoType));
+
+	MemHandleUnlock(recordH);
+	DmReleaseRecord (gameDB, index, 0);
+	GamSortList();
+	// update list position
+	{
+		RectangleType rArea;
+		UInt16 posIndex, maxIndex, maxView;
+		
+		// get the sorted index
+		index = GamGetSelected();
+		// if new item is out of the list bounds, change current list pos
+		SknGetListBounds(&rArea, NULL);
+		maxView = rArea.extent.y / sknInfoListItemSize;
+		posIndex = gPrefs->listPosition;
+		maxIndex = DmNumRecords(gameDB);
+		
+		if (index == 0 && posIndex > 0) {
+			gPrefs->listPosition = 0;
+		} else if ((maxView + posIndex) <= index) {
+			posIndex = index - (maxView - posIndex) + 1;
+			gPrefs->listPosition = posIndex;
+		}
+	}
+
+	FrmReturnToMain();
+	SknUpdateList();
+}
+
+static void EditGameFormInit(UInt16 index) {
+
+	FieldType *fld1P, *fld2P, *fld3P, *fld4P, *fld5P, *fld6P;
+	FormPtr frmP;
+	ListType *list1P, *list2P, *list3P;
+
+	Char *nameP, *pathP, *gameP, *loadP, *roomP, *talkP;
+	MemHandle nameH, pathH, gameH, loadH, roomH, talkH;
+
+	MemHandle recordH = NULL;
+	GameInfoType *game;
+
+	list1P = (ListType *)GetObjectPtr(EditGameGfxListList);
+	list2P = (ListType *)GetObjectPtr(EditGameLanguageList);
+	list3P = (ListType *)GetObjectPtr(EditGamePlatformList);
+
+	fld1P = (FieldType *)GetObjectPtr(EditGameEntryNameField);
+	fld2P = (FieldType *)GetObjectPtr(EditGamePathField);
+	fld3P = (FieldType *)GetObjectPtr(EditGameGameField);
+	fld4P = (FieldType *)GetObjectPtr(EditGameLoadSlotField);
+	fld5P = (FieldType *)GetObjectPtr(EditGameStartRoomField);
+	fld6P = (FieldType *)GetObjectPtr(EditGameTalkSpeedField);
+
+	nameH = MemHandleNew(FldGetMaxChars(fld1P)+1);
+	pathH = MemHandleNew(FldGetMaxChars(fld2P)+1);
+	gameH = MemHandleNew(FldGetMaxChars(fld3P)+1);
+	loadH = MemHandleNew(FldGetMaxChars(fld4P)+1);
+	roomH = MemHandleNew(FldGetMaxChars(fld5P)+1);
+	talkH = MemHandleNew(FldGetMaxChars(fld6P)+1);
+
+	nameP = (Char *)MemHandleLock(nameH);
+	pathP = (Char *)MemHandleLock(pathH);
+	gameP = (Char *)MemHandleLock(gameH);
+	loadP = (Char *)MemHandleLock(loadH);
+	roomP = (Char *)MemHandleLock(roomH);
+	talkP = (Char *)MemHandleLock(talkH);
+
+//	index = GamGetSelected();
+
+	if (index != dmMaxRecordIndex) {
+		recordH = DmQueryRecord(gameDB, index);
+		game = (GameInfoType *)MemHandleLock(recordH);
+		StrCopy(nameP, game->nameP);
+		StrCopy(pathP, game->pathP);
+		StrCopy(gameP, game->gameP);
+
+		LstSetSelection(list1P, game->gfxMode);
+		LstSetSelection(list2P, game->language);
+		LstSetSelection(list3P, game->platform);
+		
+		StrIToA(loadP, game->loadSlot);
+		StrIToA(roomP, game->roomNum);
+		StrIToA(talkP, game->talkValue);
+
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameLoadSlotCheckbox), game->autoLoad);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameStartRoomCheckbox), game->autoRoom);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameAmigaCheckbox), game->setPlatform);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameSubtitlesCheckbox), !game->subtitles);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameTalkSpeedCheckbox), game->talkSpeed);
+		
+		MemHandleUnlock(recordH);
+		CtlSetUsable((ControlType *)GetObjectPtr(EditGameDeleteButton),true);
+	}
+	else {
+		MemSet(nameP,MemHandleSize(nameH),0);
+		MemSet(pathP,MemHandleSize(pathH),0);
+		MemSet(gameP,MemHandleSize(gameH),0);
+
+		StrIToA(loadP, 0);
+		StrIToA(roomP, 0);
+		StrIToA(talkP, 60);
+
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameLoadSlotCheckbox), 0);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameStartRoomCheckbox), 0);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameAmigaCheckbox), 0);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameSubtitlesCheckbox), 0);
+		CtlSetValue((ControlType *)GetObjectPtr(EditGameTalkSpeedCheckbox), 0);
+
+		LstSetSelection(list1P, 1);
+		LstSetSelection(list2P, 0);
+		LstSetSelection(list3P, 0);
+		CtlSetUsable((ControlType *)GetObjectPtr(EditGameDeleteButton),false);
+	}
+
+	MemHandleUnlock(nameH);
+	MemHandleUnlock(pathH);
+	MemHandleUnlock(gameH);
+	MemHandleUnlock(loadH);
+	MemHandleUnlock(roomH);
+	MemHandleUnlock(talkH);
+
+	FldSetTextHandle(fld1P, nameH);
+	FldSetTextHandle(fld2P, pathH);
+	FldSetTextHandle(fld3P, gameH);
+	FldSetTextHandle(fld4P, loadH);
+	FldSetTextHandle(fld5P, roomH);
+	FldSetTextHandle(fld6P, talkH);
+
+	CtlSetLabel((ControlType *)GetObjectPtr(EditGameGfxPopupPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P)));
+	CtlSetLabel((ControlType *)GetObjectPtr(EditGameLanguagePopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P)));
+	CtlSetLabel((ControlType *)GetObjectPtr(EditGamePlatformPopTrigger), LstGetSelectionText(list3P, LstGetSelection(list3P)));
+
+	frmP = FrmGetActiveForm();
+	FrmDrawForm(frmP);
+}
+
+static Boolean EditGameFormHandleEvent(EventPtr eventP)
+{
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+		case frmOpenEvent:
+			switch (editMode) {
+				case edtModeAdd:
+					EditGameFormInit(dmMaxRecordIndex);
+					break;
+				case edtModeEdit:
+				case edtModeParams:
+				default :
+					EditGameFormInit(GamGetSelected());
+					break;
+			}
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case EditGameOKButton:
+					switch (editMode) {
+						case edtModeAdd:
+							EditGameFormSave(dmMaxRecordIndex);
+							break;
+						case edtModeEdit:
+						case edtModeParams:
+						default :
+							EditGameFormSave(GamGetSelected());
+							break;
+					}
+					break;
+
+				case EditGameCancelButton:
+					FrmReturnToMain();
+					break;
+				
+				case EditGameDeleteButton:
+					EditGameFormDelete(false);
+					break;
+
+				case EditGameGfxPopupPopTrigger:
+					FrmList(eventP, EditGameGfxListList);
+					break;
+
+				case EditGameLanguagePopTrigger:
+					FrmList(eventP, EditGameLanguageList);
+					break;
+
+				case EditGamePlatformPopTrigger:
+					FrmList(eventP, EditGamePlatformList);
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    SystemInfoFormInit
+ * FUNCTION:     SystemInfoFormHandleEvent
+ *
+ * DESCRIPTION: 
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void GetMemory(UInt32* storageMemoryP, UInt32* dynamicMemoryP, UInt32 *storageFreeP, UInt32 *dynamicFreeP) {
+	UInt32		free, max;
+
+	Int16		i;
+	Int16		nCards;
+	UInt16		cardNo;
+	UInt16		heapID;
+
+	UInt32		storageMemory = 0;
+	UInt32		dynamicMemory = 0;
+	UInt32		storageFree = 0;
+	UInt32		dynamicFree = 0;
+
+	// Iterate through each card to support devices with multiple cards.
+	nCards = MemNumCards();		
+
+	for (cardNo = 0; cardNo < nCards; cardNo++) {
+		// Iterate through the RAM heaps on a card (excludes ROM).
+		for (i=0; i< MemNumRAMHeaps(cardNo); i++) {
+			// Obtain the ID of the heap.
+			heapID = MemHeapID(cardNo, i);
+			// Calculate the total memory and free memory of the heap.
+			MemHeapFreeBytes(heapID, &free, &max);
+			
+			// If the heap is dynamic, increment the dynamic memory total.
+			if (MemHeapDynamic(heapID)) {
+				dynamicMemory += MemHeapSize(heapID);
+				dynamicFree += free;
+
+			// The heap is nondynamic (storage ?).
+			} else {
+				storageMemory += MemHeapSize(heapID);
+				storageFree += free;
+			}
+		}
+	}
+	// Reduce the stats to KB.  Round the results.
+	dynamicMemory = dynamicMemory / 1024L;
+	storageMemory = storageMemory / 1024L;
+
+	dynamicFree = dynamicFree / 1024L;
+	storageFree = storageFree / 1024L;
+
+	if (dynamicMemoryP) *dynamicMemoryP = dynamicMemory;
+	if (storageMemoryP) *storageMemoryP = storageMemory;
+	if (dynamicFreeP) *dynamicFreeP = dynamicFree;
+	if (storageFreeP) *storageFreeP = storageFree;
+}
+
+static void SystemInfoFormInit() {
+	FormPtr frmP;
+	Coord x;
+	UInt32 dm, sm, df, sf;
+	Char num[10];
+
+	GetMemory(&sm, &dm, &sf, &df);
+	frmP = FrmGetActiveForm();
+	FrmDrawForm(frmP);
+
+	WinSetTextColor(255);
+	FntSetFont(stdFont);
+	
+	StrIToA(num, dm);
+	x = 149 - FntCharsWidth(num, StrLen(num));
+	WinDrawChars(num, StrLen(num), x, 30);
+
+	StrIToA(num, sm);
+	x = 149 - FntCharsWidth(num, StrLen(num));
+	WinDrawChars(num, StrLen(num), x, 42);
+
+	StrIToA(num, df);
+	x = 109 - FntCharsWidth(num, StrLen(num));
+	WinDrawChars(num, StrLen(num), x, 30);
+
+	StrIToA(num, sf);
+	x = 109 - FntCharsWidth(num, StrLen(num));
+	WinDrawChars(num, StrLen(num), x, 42);
+}
+
+static Boolean SystemInfoFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+		case frmOpenEvent:
+			SystemInfoFormInit();
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			// OK button only
+			FrmReturnToMain();
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+/***********************************************************************
+ *
+ * FUNCTION:    VolumeFormSave
+ * FUNCTION:    VolumeFormInit
+ * FUNCTION:    VolumeFormHandleEvent
+ *
+ * DESCRIPTION: 
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+
+static void VolumeFormSave() {
+	SliderControlType *slid1P, *slid2P, *slid3P, *slid4P, *slid5P;
+	
+	slid1P = (SliderControlType *)GetObjectPtr(VolumeSpeakerSliderControl);
+	slid2P = (SliderControlType *)GetObjectPtr(VolumeHeadphoneSliderControl);
+
+	slid3P = (SliderControlType *)GetObjectPtr(VolumeMasterSliderControl);
+	slid4P = (SliderControlType *)GetObjectPtr(VolumeMusicSliderControl);
+	slid5P = (SliderControlType *)GetObjectPtr(VolumeSfxSliderControl);
+	
+	CtlGetSliderValues ((ControlType *)slid1P, 0, 0, 0, &gPrefs->volume.speaker) ;
+	CtlGetSliderValues ((ControlType *)slid2P, 0, 0, 0, &gPrefs->volume.headphone) ;
+
+	CtlGetSliderValues ((ControlType *)slid3P, 0, 0, 0, &gPrefs->volume.master);
+	CtlGetSliderValues ((ControlType *)slid4P, 0, 0, 0, &gPrefs->volume.music);
+	CtlGetSliderValues ((ControlType *)slid5P, 0, 0, 0, &gPrefs->volume.sfx);
+	
+	FrmReturnToMain();
+}
+
+static void VolumeFormInit() {
+	SliderControlType *slid1P, *slid2P, *slid3P, *slid4P, *slid5P;
+	FormPtr frmP;
+	UInt16 value;
+	
+	slid1P = (SliderControlType *)GetObjectPtr(VolumeSpeakerSliderControl);
+	slid2P = (SliderControlType *)GetObjectPtr(VolumeHeadphoneSliderControl);
+
+	slid3P = (SliderControlType *)GetObjectPtr(VolumeMasterSliderControl);
+	slid4P = (SliderControlType *)GetObjectPtr(VolumeMusicSliderControl);
+	slid5P = (SliderControlType *)GetObjectPtr(VolumeSfxSliderControl);
+
+	value = gPrefs->volume.speaker;
+	CtlSetSliderValues ((ControlType *)slid1P, 0, 0, 0, &value);
+	value = gPrefs->volume.headphone;
+	CtlSetSliderValues ((ControlType *)slid2P, 0, 0, 0, &value);
+
+	value = gPrefs->volume.master;
+	CtlSetSliderValues ((ControlType *)slid3P, 0, 0, 0, &value);
+	value = gPrefs->volume.music;
+	CtlSetSliderValues ((ControlType *)slid4P, 0, 0, 0, &value);
+	value = gPrefs->volume.sfx;
+	CtlSetSliderValues ((ControlType *)slid5P, 0, 0, 0, &value);
+
+	frmP = FrmGetActiveForm();
+	FrmDrawForm(frmP);
+}
+
+static Boolean VolumeFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+		case frmOpenEvent:
+			VolumeFormInit();
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case VolumeOKButton:
+					VolumeFormSave();
+					break;
+
+				case VolumeCancelButton:
+					FrmReturnToMain();
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+
+static void SoundFormSave() {
+	ControlType *cck1P, *cck2P, *cck3P, *cck4P;
+	ListType *list1P;
+	FieldType *fld1P, *fld2P, *fld3P;
+	UInt8 tempo;
+	UInt16 firstTrack;
+
+	cck1P = (ControlType *)GetObjectPtr(SoundMusicCheckbox);
+	cck2P = (ControlType *)GetObjectPtr(SoundMultiMidiCheckbox);
+	cck3P = (ControlType *)GetObjectPtr(SoundMP3Checkbox);
+	cck4P = (ControlType *)GetObjectPtr(SoundTrackLengthCheckbox);
+	list1P = (ListType *)GetObjectPtr(SoundDriverList);
+	fld1P = (FieldType *)GetObjectPtr(SoundTempoField);
+	fld2P = (FieldType *)GetObjectPtr(SoundLengthSecsField);
+	fld3P = (FieldType *)GetObjectPtr(SoundFirstTrackField);
+
+	tempo = StrAToI(FldGetTextPtr(fld1P));
+	if (tempo < 50 || tempo > 200) {
+		FrmCustomAlert(FrmErrorAlert, "Invalid tempo value (50...200)", 0, 0);
+		return;
+	}
+
+	firstTrack = StrAToI(FldGetTextPtr(fld3P));
+	if (firstTrack < 1 || firstTrack > 999) {
+		FrmCustomAlert(FrmErrorAlert, "Invalid track value (1...999)", 0, 0);
+		return;
+	}
+
+	gPrefs->sound.music = CtlGetValue(cck1P);
+	gPrefs->sound.multiMidi = CtlGetValue(cck2P);
+	gPrefs->sound.MP3 = CtlGetValue(cck3P);
+	gPrefs->sound.setDefaultTrackLength = CtlGetValue(cck4P);
+
+	gPrefs->sound.driver = LstGetSelection(list1P);
+	gPrefs->sound.tempo = tempo;
+	gPrefs->sound.defaultTrackLength = StrAToI(FldGetTextPtr(fld2P));
+	gPrefs->sound.firstTrack = firstTrack;
+	FrmReturnToMain();
+}
+
+static void SoundFormInit() {
+	ControlType *cck1P, *cck2P, *cck3P, *cck4P;
+	ListType *list1P;
+	FieldType *fld1P, *fld2P, *fld3P;
+	FormPtr frmP;
+	MemHandle tempoH, lengthH, firstTrackH;
+	Char *tempoP, *lengthP, *firstTrackP;
+
+	cck1P = (ControlType *)GetObjectPtr(SoundMusicCheckbox);
+	cck2P = (ControlType *)GetObjectPtr(SoundMultiMidiCheckbox);
+	cck3P = (ControlType *)GetObjectPtr(SoundMP3Checkbox);
+	cck4P = (ControlType *)GetObjectPtr(SoundTrackLengthCheckbox);
+	list1P = (ListType *)GetObjectPtr(SoundDriverList);
+	fld1P = (FieldType *)GetObjectPtr(SoundTempoField);
+	fld2P = (FieldType *)GetObjectPtr(SoundLengthSecsField);
+	fld3P = (FieldType *)GetObjectPtr(SoundFirstTrackField);
+
+	CtlSetValue(cck1P, gPrefs->sound.music);
+	CtlSetValue(cck2P, gPrefs->sound.multiMidi);
+	CtlSetValue(cck3P, gPrefs->sound.MP3);
+	CtlSetValue(cck4P, gPrefs->sound.setDefaultTrackLength);
+
+	LstSetSelection(list1P, gPrefs->sound.driver);
+	CtlSetLabel((ControlType *)GetObjectPtr(SoundDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P)));
+
+	tempoH = MemHandleNew(FldGetMaxChars(fld1P)+1);
+	tempoP = (Char *)MemHandleLock(tempoH);
+	StrIToA(tempoP, gPrefs->sound.tempo);
+	MemHandleUnlock(tempoH);
+	FldSetTextHandle(fld1P, tempoH);
+
+	lengthH = MemHandleNew(FldGetMaxChars(fld2P)+1);
+	lengthP = (Char *)MemHandleLock(lengthH);
+	StrIToA(lengthP, gPrefs->sound.defaultTrackLength);
+	MemHandleUnlock(lengthH);
+	FldSetTextHandle(fld2P, lengthH);
+
+	firstTrackH = MemHandleNew(FldGetMaxChars(fld3P)+1);
+	firstTrackP = (Char *)MemHandleLock(firstTrackH);
+	StrIToA(firstTrackP, gPrefs->sound.firstTrack);
+	MemHandleUnlock(firstTrackH);
+	FldSetTextHandle(fld3P, firstTrackH);
+
+	frmP = FrmGetActiveForm();
+	FrmDrawForm(frmP);
+}
+
+static Boolean SoundFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+		case frmOpenEvent:
+			SoundFormInit();
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case SoundOKButton:
+					SoundFormSave();
+					break;
+
+				case SoundCancelButton:
+					FrmReturnToMain();
+					break;
+
+				case SoundDriverPopTrigger:
+					FrmList(eventP, SoundDriverList);
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+/***********************************************************************
+ *
+ * FUNCTION:    MiscOptionsFormSave
+ * FUNCTION:    MiscOptionsFormInit
+ * FUNCTION:    MiscOptionsFormHandleEvent
+ *
+ * DESCRIPTION: Misc. Options form functions
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+
+static void MiscOptionsFormSave() {
+
+	FieldType *fld1P;
+	ControlType *cck1P, *cck2P, *cck3P, *cck4P, *cck5P, *cck6P, *cck7P, *cck8P;	
+	FormPtr frmP;
+
+	fld1P = (FieldType *)GetObjectPtr(MiscOptionsDebugLevelField);
+	
+	cck1P = (ControlType *)GetObjectPtr(MiscOptionsVibratorCheckbox);
+	cck2P = (ControlType *)GetObjectPtr(MiscOptionsNoAutoOffCheckbox);
+	cck3P = (ControlType *)GetObjectPtr(MiscOptionsStdPaletteCheckbox);
+	cck4P = (ControlType *)GetObjectPtr(MiscOptionsDebugCheckbox);
+	cck5P = (ControlType *)GetObjectPtr(MiscOptionsWriteIniCheckbox);
+	cck6P = (ControlType *)GetObjectPtr(MiscOptionsAutoResetCheckbox);
+	cck7P = (ControlType *)GetObjectPtr(MiscOptionsDemoCheckbox);
+	cck8P = (ControlType *)GetObjectPtr(MiscOptionsFullscreenCheckbox);
+
+	frmP = FrmGetActiveForm();
+
+	if (FldGetTextLength(fld1P) == 0 && CtlGetValue(cck4P) == 1) {
+		FrmCustomAlert(FrmWarnAlert,"You must specified a debug level.",0,0);
+		FrmSetFocus(frmP, FrmGetObjectIndex(frmP, MiscOptionsDebugLevelField));
+		return;
+	}
+
+	gPrefs->vibrator = CtlGetValue(cck1P);
+	gPrefs->autoOff = !CtlGetValue(cck2P);
+	gPrefs->stdPalette = CtlGetValue(cck3P);
+	gPrefs->debug = CtlGetValue(cck4P);
+	gPrefs->saveConfig = CtlGetValue(cck5P);
+	gPrefs->autoReset = CtlGetValue(cck6P);
+	gPrefs->demoMode = CtlGetValue(cck7P);
+	gPrefs->fullscreen = CtlGetValue(cck8P);
+
+	gPrefs->debugLevel = StrAToI(FldGetTextPtr(fld1P));
+	
+	FrmReturnToMain();
+}
+
+static void MiscOptionsFormInit() {
+
+	FieldType *fld1P;
+	FormPtr frmP;
+
+	Char *levelP;
+	MemHandle levelH;
+
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsVibratorCheckbox), gPrefs->vibrator);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsNoAutoOffCheckbox), !gPrefs->autoOff);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsStdPaletteCheckbox), gPrefs->stdPalette);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsAutoResetCheckbox), gPrefs->autoReset);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsDebugCheckbox), gPrefs->debug);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsWriteIniCheckbox), gPrefs->saveConfig);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsDemoCheckbox), gPrefs->demoMode);
+	CtlSetValue((ControlType *)GetObjectPtr(MiscOptionsFullscreenCheckbox), gPrefs->fullscreen);
+
+	fld1P = (FieldType *)GetObjectPtr(MiscOptionsDebugLevelField);
+
+	levelH = MemHandleNew(FldGetMaxChars(fld1P)+1);
+	levelP = (Char *)MemHandleLock(levelH);
+	StrIToA(levelP, gPrefs->debugLevel);
+	MemHandleUnlock(levelH);
+
+	FldSetTextHandle(fld1P, levelH);
+	frmP = FrmGetActiveForm();
+	FrmDrawForm(frmP);
+}
+
+static Boolean MiscOptionsFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+		case frmOpenEvent:
+			MiscOptionsFormInit();
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case MiscOptionsOKButton:
+					MiscOptionsFormSave();
+					break;
+
+				case MiscOptionsCancelButton:
+					FrmReturnToMain();
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+///////////////////////////////////////////////////////////////////////
+static void CardSlotCreateDirs() {
+	if (gPrefs->card.volRefNum != sysInvalidRefNum) {
+		VFSDirCreate(gPrefs->card.volRefNum, "/PALM");
+		VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs");
+		VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs/ScummVM");
+		VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs/ScummVM/Games");
+		VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs/ScummVM/Saved");
+	}
+}
+
+static void CardSlotFromShowHideOptions() {
+	ControlType *cck1P;
+	FormPtr frmP = FrmGetActiveForm();
+
+	cck1P = (ControlType *)GetObjectPtr(CardSlotMoveCheckbox);
+
+	if (CtlGetValue(cck1P)) {
+		FrmShowObject(frmP, FrmGetObjectIndex (frmP, CardSlotDeleteCheckbox));
+		FrmShowObject(frmP, FrmGetObjectIndex (frmP, CardSlotConfirmCheckbox));
+	} else {
+		FrmHideObject(frmP, FrmGetObjectIndex (frmP, CardSlotDeleteCheckbox));
+		FrmHideObject(frmP, FrmGetObjectIndex (frmP, CardSlotConfirmCheckbox));
+	}
+}
+
+static UInt16 CardSlotFormInit(Boolean display, Boolean bDraw) {
+	Err err;
+	UInt16 volRefNum;
+	UInt32 volIterator = vfsIteratorStart;
+	UInt8 counter = 0;
+	UInt32 other = 1;
+
+	MemHandle cards = NULL;
+	CardInfoType *cardsInfo;
+
+	while (volIterator != vfsIteratorStop) {
+		err = VFSVolumeEnumerate(&volRefNum, &volIterator);
+
+		if (!err) {
+			Char labelP[expCardInfoStringMaxLen+1];
+			err = VFSVolumeGetLabel(volRefNum, labelP, expCardInfoStringMaxLen+1);
+
+			if (err || StrLen(labelP) == 0) {	// if no label try to retreive card type
+				VolumeInfoType volInfo;
+				err = VFSVolumeInfo(volRefNum, &volInfo);
+				
+				if (!err) {
+					ExpCardInfoType info;
+					err = ExpCardInfo(volInfo.slotRefNum, &info);
+					StrCopy(labelP, info.deviceClassStr);
+				}
+				
+				if (err)	// if err default name
+					StrPrintF(labelP,"Other Card %ld", other++);
+			}
+
+			if (!cards)
+				cards = MemHandleNew(sizeof(CardInfoType));
+			else
+				MemHandleResize(cards, MemHandleSize(cards) + sizeof(CardInfoType));
+				
+			cardsInfo = (CardInfoType *)MemHandleLock(cards);
+			cardsInfo[counter].volRefNum = volRefNum;
+			StrCopy(cardsInfo[counter].nameP, labelP);
+			MemHandleUnlock(cards);
+			counter++;
+		}
+	}
+
+	if (display) {
+		FormPtr frmP;
+		ListPtr listP;
+		ControlType *cck1P, *cck2P, *cck3P;
+		UInt16 index;
+		Int16 selected = -1;
+		
+		CardInfoType *cardsInfo;
+		MemHandle items = NULL;
+
+		listP = (ListType *)GetObjectPtr(CardSlotSlotList);
+		cck1P = (ControlType *)GetObjectPtr(CardSlotMoveCheckbox);
+		cck2P = (ControlType *)GetObjectPtr(CardSlotDeleteCheckbox);
+		cck3P = (ControlType *)GetObjectPtr(CardSlotConfirmCheckbox);
+
+		if (counter > 0) {
+			cardsInfo = (CardInfoType *)MemHandleLock(cards);
+
+			for (index = 0; index < counter; index++) {
+				if (!items)
+					items = MemHandleNew(sizeof(Char *));
+				else
+					MemHandleResize(items, MemHandleSize(items) + sizeof(Char *));
+
+				itemsText = (Char **)MemHandleLock(items);
+				itemsText[index] = cardsInfo[index].nameP;
+				MemHandleUnlock(items);
+				
+				if (cardsInfo[index].volRefNum == gPrefs->card.volRefNum)
+					selected = index;
+			}
+
+			itemsText = (Char **)MemHandleLock(items);
+			LstSetListChoices (listP, itemsText, counter);
+			LstSetSelection(listP, selected);
+			// save globals and set list
+			itemsText = (Char **)MemHandleLock(items);
+			itemsList = (void *)cardsInfo;
+			itemsType = ITEM_TYPE_CARD;
+
+		} else {
+			LstSetListChoices(listP, NULL, 0);
+			// save globals and set list
+			itemsText = NULL;
+			itemsList = NULL;
+			itemsType = ITEM_TYPE_CARD;
+		}
+
+		// bDraw = true -> draw whole from
+		// bDraw = false -> redraw list
+		if (bDraw) {
+			CtlSetValue(cck1P, gPrefs->card.moveDB);
+			CtlSetValue(cck2P, gPrefs->card.deleteDB);
+			CtlSetValue(cck3P, gPrefs->card.confirmMoveDB);
+			CardSlotFromShowHideOptions();
+			frmP = FrmGetActiveForm();
+			FrmDrawForm(frmP);
+
+		} else {
+			WinScreenLock(winLockCopy);
+			LstDrawList(listP);
+			WinScreenUnlock();
+		}
+	} else {	// if !display, we just want to retreive an avaliable card
+		if (counter > 0) {
+			UInt16 volRefNum;
+			cardsInfo = (CardInfoType *)MemHandleLock(cards);
+			volRefNum =  cardsInfo[0].volRefNum;	// return the first volref
+			MemHandleUnlock(cards);
+			MemHandleFree(cards);
+			return volRefNum;
+		}
+	}
+
+	return sysInvalidRefNum; // default
+}
+
+static void CardSlotFormExit(Boolean bSave) {
+	MemHandle cards;
+	MemHandle items;
+	CardInfoType *cardsInfo;
+	UInt16 updateCode = frmRedrawUpdateMS;
+
+	if (itemsText && itemsList) {
+		cardsInfo = (CardInfoType *)itemsList;
+		cards = MemPtrRecoverHandle(cardsInfo);
+		items = MemPtrRecoverHandle(itemsText);
+	
+		itemsText = NULL;
+		itemsList = NULL;
+	} else {
+		cards = NULL;
+		items = NULL;
+	}
+	itemsType = ITEM_TYPE_UNKNOWN;
+
+	if (bSave) {
+		ListType *listP;
+		ControlType *cck1P, *cck2P, *cck3P;
+		Int16 selected;
+
+		listP = (ListType *)GetObjectPtr(CardSlotSlotList);
+		cck1P = (ControlType *)GetObjectPtr(CardSlotMoveCheckbox);
+		cck2P = (ControlType *)GetObjectPtr(CardSlotDeleteCheckbox);
+		cck3P = (ControlType *)GetObjectPtr(CardSlotConfirmCheckbox);
+		selected = LstGetSelection(listP);
+
+		if (selected == -1) {
+			gPrefs->card.volRefNum = sysInvalidRefNum;
+		} else if (gPrefs->card.volRefNum != cardsInfo[selected].volRefNum) {
+			updateCode = frmRedrawUpdateMSImport;
+			gPrefs->card.volRefNum = cardsInfo[selected].volRefNum;
+		}
+
+		gPrefs->card.moveDB = CtlGetValue(cck1P);
+		gPrefs->card.deleteDB = CtlGetValue(cck2P);
+		gPrefs->card.confirmMoveDB = CtlGetValue(cck3P);
+		CardSlotCreateDirs();
+	}
+
+	FrmReturnToMain(updateCode);
+
+	if (items && cards) {
+		MemHandleUnlock(items);
+		MemHandleUnlock(cards);
+		MemHandleFree(items);
+		MemHandleFree(cards);
+	}
+}
+
+static void CardSlotFormUpdate() {
+	if (itemsType == ITEM_TYPE_CARD) {
+		if (itemsText && itemsList) {
+			MemHandle cards;
+			MemHandle items;
+			ListType *listP;
+
+			listP = (ListType *)GetObjectPtr(CardSlotSlotList);
+			cards = MemPtrRecoverHandle(itemsList);
+			items = MemPtrRecoverHandle(itemsText);
+
+			itemsText = NULL;
+			itemsList = NULL;
+			itemsType = ITEM_TYPE_UNKNOWN;
+
+			MemHandleUnlock(items);
+			MemHandleUnlock(cards);
+			MemHandleFree(items);
+			MemHandleFree(cards);
+		}
+		CardSlotFormInit(true, false);
+	}
+}
+
+static Boolean CardSlotFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+	
+		case frmOpenEvent:
+			CardSlotFormInit(true, true);
+			handled = true;
+			break;
+
+		case frmCloseEvent:
+			CardSlotFormExit(false);
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case CardSlotOkButton:
+					CardSlotFormExit(true);
+					break;
+
+				case CardSlotCancelButton:
+					CardSlotFormExit(false);
+					break;
+				
+				case CardSlotMoveCheckbox:
+					CardSlotFromShowHideOptions();
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+
+static UInt16 parseCards() {
+	UInt16 volRefNum = CardSlotFormInit(false, false);
+	CardSlotFormExit(false);
+	
+	return volRefNum;
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    MainFormInit
+ *
+ * DESCRIPTION: This routine initializes the MainForm form.
+ *
+ * PARAMETERS:  frm - pointer to the MainForm form.
+ *
+ * RETURNED:    nothing
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void MainFormInit()
+{
+	SknApplySkin();
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    MainFormDoCommand
+ *
+ * DESCRIPTION: This routine performs the menu command specified.
+ *
+ * PARAMETERS:  command  - menu item id
+ *
+ * RETURNED:    nothing
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+
+
+static Int16 SkinsFormCompare(SkinInfoType *a, SkinInfoType *b, SortRecordInfoPtr, SortRecordInfoPtr, MemHandle) {
+	return StrCompare(a->nameP, b->nameP);
+}
+
+static void SkinsFormInit(Boolean bDraw) {
+	MemHandle skins = NULL;
+	SkinInfoType *skinsInfo;
+	UInt16 numSkins = 0;
+
+	FormPtr frmP;
+	ListType *listP;
+	MemHandle items = NULL;
+	ControlType *cck1P;
+	DmSearchStateType stateInfo;
+	UInt16 cardNo;
+	LocalID dbID;
+
+	Err errInfo;
+	Char nameP[32];
+
+	itemsText = NULL;
+	
+	// parse and save skins
+	Err err = DmGetNextDatabaseByTypeCreator(true, &stateInfo, 'skin', appFileCreator, false, &cardNo, &dbID);
+	while (!err && dbID) {
+		errInfo = DmDatabaseInfo (cardNo, dbID, nameP, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+		if (!errInfo)
+		{
+			if (!skins)
+				skins = MemHandleNew(sizeof(SkinInfoType));
+			else
+				MemHandleResize(skins, MemHandleSize(skins) + sizeof(SkinInfoType));
+			
+			skinsInfo = (SkinInfoType *)MemHandleLock(skins);
+			StrCopy(skinsInfo[numSkins].nameP, nameP);
+			skinsInfo[numSkins].cardNo = cardNo;
+			skinsInfo[numSkins].dbID = dbID;
+			MemHandleUnlock(skins);
+			numSkins++;
+		}		
+		err = DmGetNextDatabaseByTypeCreator(false, &stateInfo, 'skin', appFileCreator, false, &cardNo, &dbID);
+	}
+
+	Int16 selected = -1;
+
+	cck1P = (ControlType *)GetObjectPtr(SkinsSoundClickCheckbox);
+	CtlSetValue(cck1P, gPrefs->soundClick);
+
+	listP = (ListType *)GetObjectPtr(SkinsSkinList);
+	skinsInfo = (SkinInfoType *)MemHandleLock(skins);
+	SysQSort(skinsInfo, numSkins, sizeof(SkinInfoType), (CmpFuncPtr)SkinsFormCompare, 0);
+
+	// create itemsText (TODO: create a custom draw function)
+	for (UInt16 index=0; index < numSkins; index++)
+	{
+		if (!items)
+			items = MemHandleNew(sizeof(Char *));
+		else
+			MemHandleResize(items, MemHandleSize(items) + sizeof(Char *));
+
+		itemsText = (Char **)MemHandleLock(items);
+		itemsText[index] = skinsInfo[index].nameP;
+		MemHandleUnlock(items);
+		
+		if (	gPrefs->skin.cardNo == skinsInfo[index].cardNo &&
+				gPrefs->skin.dbID == skinsInfo[index].dbID &&
+				StrCompare(gPrefs->skin.nameP, skinsInfo[index].nameP) == 0)
+			selected = index;
+	}
+	// save globals and set list
+	itemsText = (Char **)MemHandleLock(items);
+	itemsList = (void *)skinsInfo;
+	itemsType = ITEM_TYPE_SKIN;
+
+	LstSetListChoices (listP, itemsText, numSkins);
+	LstSetSelection(listP, selected);
+
+	// bDraw = true -> draw whole from
+	// bDraw = false -> redraw list
+	if (bDraw) {
+		frmP = FrmGetActiveForm();
+		FrmDrawForm(frmP);
+	} else {
+		WinScreenLock(winLockCopy);
+		LstDrawList(listP);
+		WinScreenUnlock();
+//		LstSetSelection(listP, 0);
+	}
+}
+
+static void SkinsFormExit(Boolean bSave) {
+	MemHandle skins;
+	MemHandle items;
+	SkinInfoType *skinsInfo;
+
+	ListType *listP;
+	Int16 selected;
+
+	listP = (ListType *)GetObjectPtr(SkinsSkinList);
+	selected = LstGetSelection(listP);
+	
+	if (bSave && selected == -1)	{	// may never occured...
+		FrmCustomAlert(FrmWarnAlert, "You didn't select a skin.", 0, 0);
+		return;
+	}
+
+	skinsInfo = (SkinInfoType *)itemsList;
+	skins = MemPtrRecoverHandle(skinsInfo);
+	items = MemPtrRecoverHandle(itemsText);
+	
+	itemsText = NULL;
+	itemsList = NULL;
+	itemsType = ITEM_TYPE_UNKNOWN;
+
+	if (bSave) {
+		ControlType *cck1P;
+
+		StrCopy(gPrefs->skin.nameP, skinsInfo[selected].nameP);
+		gPrefs->skin.cardNo = skinsInfo[selected].cardNo;
+		gPrefs->skin.dbID =  skinsInfo[selected].dbID;
+
+		cck1P = (ControlType *)GetObjectPtr(SkinsSoundClickCheckbox);
+		gPrefs->soundClick = CtlGetValue(cck1P);
+	}
+
+	FrmReturnToMain();
+
+	MemHandleUnlock(items);
+	MemHandleUnlock(skins);
+	MemHandleFree(items);
+	MemHandleFree(skins);
+
+	if (bSave)
+		SknApplySkin();
+}
+
+static void SkinsFormBeam() {
+	SkinInfoType *skinsInfo;
+
+	ListType *listP;
+	Int16 selected;
+	Err err;
+
+	listP = (ListType *)GetObjectPtr(SkinsSkinList);
+	selected = LstGetSelection(listP);
+
+	if (selected == -1)	{	// may never occured...
+		FrmCustomAlert(FrmWarnAlert, "You didn't select a skin.", 0, 0);
+		return;
+	}
+
+	skinsInfo = (SkinInfoType *)itemsList;
+	err = SendDatabase(0, skinsInfo[selected].dbID, "skin.pdb", "\nScummVM Skin");
+
+//	if (err)
+//		FrmCustomAlert(FrmErrorAlert, "Unable to beam this skin.",0,0);
+}
+
+static void SkinsFormDelete() {
+	MemHandle skins;
+	MemHandle items;
+	SkinInfoType *skinsInfo;
+
+	ListType *listP;
+	Int16 selected;
+
+	listP = (ListType *)GetObjectPtr(SkinsSkinList);
+	selected = LstGetSelection(listP);
+
+	if (selected == -1)	{	// may never occured...
+		FrmCustomAlert(FrmInfoAlert, "You didn't select a skin.", 0, 0);
+		return;
+	}
+
+	skinsInfo = (SkinInfoType *)itemsList;
+	skins = MemPtrRecoverHandle(skinsInfo);
+	items = MemPtrRecoverHandle(itemsText);
+
+	if (	gPrefs->skin.cardNo == skinsInfo[selected].cardNo &&
+			gPrefs->skin.dbID == skinsInfo[selected].dbID &&
+			StrCompare(gPrefs->skin.nameP, skinsInfo[selected].nameP) == 0) {
+			FrmCustomAlert(FrmInfoAlert, "You cannot delete the active skin.",0,0);
+			return;
+
+	} else {
+		Err err = DmDeleteDatabase(0, skinsInfo[selected].dbID);
+		if (!err) {
+
+			itemsText = NULL;
+			itemsList = NULL;
+			itemsType = ITEM_TYPE_UNKNOWN;
+
+			MemHandleUnlock(items);
+			MemHandleUnlock(skins);
+			MemHandleFree(items);
+			MemHandleFree(skins);
+
+			SkinsFormInit(false);
+		} else {
+			FrmCustomAlert(FrmErrorAlert, "Skin deletion failed.",0,0);
+		}
+	}
+
+}
+static Boolean SkinsFormHandleEvent(EventPtr eventP) {
+	Boolean handled = false;
+
+	switch (eventP->eType) {
+	
+		case frmOpenEvent:
+			SkinsFormInit(true);
+			handled = true;
+			break;
+
+		case frmCloseEvent:
+			SkinsFormExit(false);
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case SkinsOKButton:
+					SkinsFormExit(true);
+					break;
+
+				case SkinsCancelButton:
+					SkinsFormExit(false);
+					break;
+					
+				case SkinsBeamButton:
+					SkinsFormBeam();
+					break;
+				
+				case SkinsDeleteButton:
+					SkinsFormDelete();
+					break;
+			}
+			handled = true;
+			break;
+
+		default:
+			break;
+	}
+	
+	return handled;
+}
+
+
+static void MainFormAbout() {
+	FormPtr frmP;
+	FormLabelType *versionP;
+
+	frmP = FrmInitForm(AboutForm);
+	versionP = FrmNewLabel(&frmP, 1111, gScummVMVersion, 4, 142, stdFont);
+	FrmDoDialog (frmP);					// Display the About Box.
+	FrmDeleteForm (frmP);
+}
+
+static Boolean MainFormDoCommand(UInt16 command)
+{
+	Boolean handled = false;
+
+	switch (command) {
+		case MainGamesMemoryCards:
+			FrmPopupForm(CardSlotForm);
+			handled = true;
+			break;
+
+		case MainGamesViewMemory:
+			FrmPopupForm(SystemInfoForm);
+			handled = true;
+			break;
+
+		case MainGamesNewEdit:
+			editMode = edtModeParams;
+			FrmPopupForm(EditGameForm);
+			handled = true;
+			break;
+
+		case MainGamesBeam:
+			BeamMe();
+			//if (BeamMe())
+				//FrmCustomAlert(FrmErrorAlert,"Unable to beam ScummVM for PalmOS.",0,0);
+			handled = true;
+			break;
+
+		case MainOptionsAbout:
+ 			MainFormAbout();
+ 			handled = true;
+			break;
+		
+		case MainOptionsVolumeControl:
+			FrmPopupForm(VolumeForm);
+			handled = true;
+			break;
+
+		case MainOptionsMusic:
+			FrmPopupForm(SoundForm);
+			handled = true;
+			break;
+		
+		case MainOptionsSkins:
+			FrmPopupForm(SkinsForm);
+			handled = true;
+			break;
+
+		case MainOptionsMisc:
+			FrmPopupForm(MiscOptionsForm);
+			handled = true;
+			break;
+		}
+
+	MenuEraseStatus(0);
+	return handled;
+}
+
+
+static void SavePrefs() {
+	if (gPrefs) {
+		PrefSetAppPreferences(appFileCreator, appPrefID, appPrefVersionNum, gPrefs, sizeof (GlobalsPreferenceType), true);
+		MemPtrFree(gPrefs);
+		gPrefs = NULL;
+	}
+}
+
+static Boolean CheckVibratorExists() {
+	UInt32 romVersion;
+	Err err;
+	Boolean exists = false;
+
+	err = FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion);
+	if (!err) {
+		if (romVersion >= sysMakeROMVersion(4,0,0,sysROMStageRelease,0)) {
+			Boolean active = false;
+			err = HwrVibrateAttributes(0, kHwrVibrateActive, &active);
+			exists = (!err) ? true : exists;
+		}
+	}
+
+	return exists;
+}
+
+// need to move this on a .h file
+#define sonySysFileCSystem      'SsYs'  /* Sony overall System */
+#define sonySysFtrCreatorSystem     sonySysFileCSystem
+
+#define sonySysFtrNumSystemBase         10000
+#define sonySysFtrNumSystemAOutSndStateOnHandlerP   (sonySysFtrNumSystemBase + 4)
+#define sonySysFtrNumSystemAOutSndStateOffHandlerP  (sonySysFtrNumSystemBase + 5)
+
+typedef void (*sndStateOnType)(UInt8 /* kind */, UInt8 /* L volume 0-31 */, UInt8 /* R volume 0-31 */);
+typedef void (*sndStateOffType)(UInt8 /* kind */);
+
+/* kind */
+#define aOutSndKindSp       (0) /* Speaker volume */
+#define aOutSndKindHp       (2) /* HeadPhone volume */
+////////////////////////////////////////////////////////////
+#define MAX_ARG	25
+
+static Boolean checkPath(const Char *pathP) {
+	FileRef *tmpRef;
+
+	if (!(tmpRef = fopen(pathP, "r"))) {
+		return false;
+	} else {
+		fclose(tmpRef);
+		return true;
+	}
+}
+
+static void AddArg(Char **argvP, const Char *argP, const Char *parmP, UInt8 *countArgP)
+{
+	if (argP)
+	{
+		UInt16 len2 = 0;
+		UInt16 len1 = StrLen(argP);
+
+		if (len1 > 0)
+		{	
+			if (parmP)
+				len2 = StrLen(parmP);
+
+			(*countArgP)++;
+			*argvP = (Char *)MemPtrNew(len1 + len2 + 1);
+			StrCopy(*argvP, argP);
+			
+			if (parmP)
+				StrCat(*argvP, parmP);
+		}
+	}
+}
+
+static void StartScummVM() {
+	Char *argvP[MAX_ARG];
+	UInt8 argc	= 0;
+	UInt8 count;
+
+	Boolean autoOff;
+	UInt16 autoOffDelay;
+	Boolean debug;
+	UInt16 musicDriver = sysInvalidRefNum; // for launch call
+
+	bStartScumm = false;	//
+	UInt16 index = GamGetSelected();
+
+	for(count = 0; count < MAX_ARG; count++)
+		argvP[count] = NULL;
+
+	if (index != dmMaxRecordIndex) {
+		Char pathP[256];
+		Char num[4];
+		MemHandle recordH;
+		GameInfoType *gameInfoP;
+
+		recordH = DmQueryRecord(gameDB,index);
+		gameInfoP = (GameInfoType *)MemHandleLock(recordH);
+
+		// build path
+		StrCopy(pathP,"/Palm/Programs/ScummVM/Games/");
+		if (gameInfoP->pathP[0] == '/')
+			StrCopy(pathP,gameInfoP->pathP);
+		else
+			StrCat(pathP,gameInfoP->pathP);
+		
+		// path exists ?
+/*		if (!checkPath(pathP)) {
+			MemHandleUnlock(recordH);
+			FrmCustomAlert(FrmErrorAlert,"The specified path was not found !",0,0);
+			return;
+		}
+*/
+		AddArg(&argvP[argc], "ScummVM", NULL, &argc);
+
+		// save scummvm.ini ?
+		if (gPrefs->saveConfig)
+			AddArg(&argvP[argc], "-w", NULL, &argc);
+
+		// path
+		AddArg(&argvP[argc], "-p", pathP, &argc);
+
+		// language
+		if (gameInfoP->language > 0) {
+			const Char *lang = "en\0de\0fr\0it\0p\0es\0jp\0z\0kr\0hb\0";
+			AddArg(&argvP[argc], "-q", (lang + (gameInfoP->language - 1) * 3), &argc);
+		}
+
+		// fullscreen ?
+		if (gPrefs->fullscreen) {
+			AddArg(&argvP[argc], "-f", NULL, &argc);
+		}
+
+		// gfx mode
+		switch (gameInfoP->gfxMode)
+		{
+			case 1:
+				AddArg(&argvP[argc], "-g", "flipping", &argc);
+				break;
+			case 2:
+				AddArg(&argvP[argc], "-g", "dbuffer", &argc);
+				break;
+			case 3:
+				AddArg(&argvP[argc], "-g", "wide", &argc);
+				break;
+			default:
+				AddArg(&argvP[argc], "-g", "normal", &argc);
+				break;
+		}
+
+		// load state
+		if (gameInfoP->autoLoad) {
+			StrIToA(num, gameInfoP->loadSlot);
+			AddArg(&argvP[argc], "-x", num, &argc);
+		}
+		// start in room
+		if (gameInfoP->autoRoom) {
+			StrIToA(num, gameInfoP->roomNum);
+			AddArg(&argvP[argc], "-b", num, &argc);
+		}
+		// not a PC version
+		if (gameInfoP->setPlatform) {
+			switch (gPrefs->sound.driver) {
+				case 0:
+					AddArg(&argvP[argc], "--platform=", "amiga", &argc);
+					break;
+				case 1:
+					AddArg(&argvP[argc], "--platform=", "atari-st", &argc);
+					break;
+				case 2:
+					AddArg(&argvP[argc], "--platform=", "machintosh", &argc);
+					break;
+			}		
+		}
+
+		// subtitles
+		if (!gameInfoP->subtitles) {
+			AddArg(&argvP[argc], "-n", NULL, &argc);
+		}
+		// talk speed
+		if (gameInfoP->talkSpeed) {
+			StrIToA(num, gameInfoP->talkValue);
+			AddArg(&argvP[argc], "-y", num, &argc);
+		}
+		// debug level
+		debug = gPrefs->debug;
+		if (gPrefs->debug) {
+			StrIToA(num, gPrefs->debugLevel);
+			AddArg(&argvP[argc], "-d", num, &argc);
+		}
+		// demo mode ?
+		if (gPrefs->demoMode)
+			AddArg(&argvP[argc], "--demo-mode", NULL, &argc);
+
+		// multi midi ?
+		if (gPrefs->sound.multiMidi)
+			AddArg(&argvP[argc], "--multi-midi", NULL, &argc);
+
+		// music driver
+		musicDriver = gPrefs->sound.music;
+		if (musicDriver) {
+			switch (gPrefs->sound.driver) {
+				case 0:	// NULL
+					AddArg(&argvP[argc], "-e", "null", &argc);
+					break;
+				case 1:	// yamaha Pa1
+					AddArg(&argvP[argc], "-e", "ypa1", &argc);
+					break;
+			}		
+		}
+		else	// NULL as default
+			AddArg(&argvP[argc], "-e", "null", &argc);
+
+		// music tempo
+		StrIToA(num, gPrefs->sound.tempo);
+		AddArg(&argvP[argc], "-t", num, &argc);
+
+		// volume control
+		StrIToA(num, gPrefs->volume.master);
+		AddArg(&argvP[argc], "-o", num, &argc);
+		StrIToA(num, gPrefs->volume.sfx);
+		AddArg(&argvP[argc], "-s", num, &argc);
+		StrIToA(num, gPrefs->volume.music);
+		AddArg(&argvP[argc], "-m", num, &argc);
+
+		// game name
+		AddArg(&argvP[argc], gameInfoP->gameP, NULL, &argc);
+
+		MemHandleUnlock(recordH);
+	}
+
+	gVars->skinSet = false;
+	GamCloseDatabase(false);
+	FrmCloseAllForms();
+
+	autoOff = gPrefs->autoOff;
+	if (!autoOff) {
+		autoOffDelay = SysSetAutoOffTime(0);
+		EvtResetAutoOffTimer();
+	}
+
+	// gVars values
+	//gVars->HRrefNum defined in checkHRmode on Clié OS4
+	//gVars->logFile defined bellow, must be defined only if debug option is checked
+	gVars->screenLocked = false;
+	gVars->volRefNum = gPrefs->card.volRefNum;
+	gVars->vibrator = gPrefs->vibrator;
+	gVars->stdPalette = gPrefs->stdPalette;
+	gVars->autoReset = gPrefs->autoReset;
+	gVars->music.MP3 = gPrefs->sound.MP3;
+	gVars->music.setDefaultTrackLength = gPrefs->sound.setDefaultTrackLength;
+	gVars->music.defaultTrackLength = gPrefs->sound.defaultTrackLength;
+	gVars->music.firstTrack = gPrefs->sound.firstTrack;
+
+	// TODO : support tapwave rumble
+	if (gVars->vibrator)
+	{
+		if (CheckVibratorExists()) {
+			UInt16 cycle	= (SysTicksPerSecond())/2;
+			UInt32 pattern	= 0xFF000000;
+			UInt16 delay	= 1;
+			UInt16 repeat	= 1;
+
+			HwrVibrateAttributes(1, kHwrVibrateRate, &cycle);
+			HwrVibrateAttributes(1, kHwrVibratePattern, &pattern);
+			HwrVibrateAttributes(1, kHwrVibrateDelay, &delay);
+			HwrVibrateAttributes(1, kHwrVibrateRepeatCount, &repeat);
+
+		} else {
+			gVars->vibrator = false;
+		}
+	}
+
+	if (debug) {
+		VFSFileDelete(gVars->volRefNum,"PALM/Programs/ScummVM/scumm.log");
+		VFSFileCreate(gVars->volRefNum,"PALM/Programs/ScummVM/scumm.log");
+		VFSFileOpen(gVars->volRefNum,"PALM/Programs/ScummVM/scumm.log",vfsModeWrite, &gVars->logFile);
+	}
+
+	void *sndStateOnFuncP = NULL,
+		 *sndStateOffFuncP = NULL;
+
+	if (musicDriver == 1 || musicDriver == sysInvalidRefNum) {
+
+		Pa1Lib_Open();
+
+		// Don't work on T4xx and T6xx series ?
+		FtrGet(sonySysFtrCreatorSystem, sonySysFtrNumSystemAOutSndStateOnHandlerP, (UInt32*) &sndStateOnFuncP);
+		FtrGet(sonySysFtrCreatorSystem, sonySysFtrNumSystemAOutSndStateOffHandlerP, (UInt32*) &sndStateOffFuncP);
+
+		if (sndStateOnFuncP && sndStateOffFuncP) {
+			((sndStateOnType)(sndStateOnFuncP))(aOutSndKindSp, gPrefs->volume.headphone, gPrefs->volume.headphone);
+			((sndStateOnType)(sndStateOnFuncP))(aOutSndKindHp, gPrefs->volume.speaker, gPrefs->volume.speaker);
+
+		}
+
+		Pa1Lib_devHpVolume(gPrefs->volume.headphone, gPrefs->volume.headphone);
+		Pa1Lib_devSpVolume(gPrefs->volume.speaker);
+	}
+
+	SavePrefs();	// free globals pref memory
+	GlbOpen();
+	main(argc, argvP);
+	GlbClose();
+
+	if (musicDriver == 1 || musicDriver == sysInvalidRefNum) {
+		if (sndStateOnFuncP && sndStateOffFuncP) {
+			((sndStateOffType)(sndStateOffFuncP))(aOutSndKindSp);
+			((sndStateOffType)(sndStateOffFuncP))(aOutSndKindHp);
+		}
+
+		Pa1Lib_Close();
+	}
+
+	if (debug)
+		VFSFileClose(gVars->logFile);
+
+	for(count = 0; count < MAX_ARG; count++)
+		if (argvP[count])
+			MemPtrFree(argvP[count]);
+	
+	if (gVars->vibrator) {
+		Boolean active = false;
+		HwrVibrateAttributes(1, kHwrVibrateActive, &active);
+	}
+
+	if (!autoOff) {
+		SysSetAutoOffTime(autoOffDelay);SystemPreferencesChoice
+		EvtResetAutoOffTimer();
+	}
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    MainFormHandleEvent
+ *
+ * DESCRIPTION: This routine is the event handler for the 
+ *              "MainForm" of this application.
+ *
+ * PARAMETERS:  eventP  - a pointer to an EventType structure
+ *
+ * RETURNED:    true if the event has handle and should not be passed
+ *              to a higher level handler.
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+
+static Boolean PenDownRepeat() {
+	Coord x,y;
+	Boolean penDown, handled = false;
+	EvtGetPen(&x, &y, &penDown);
+
+	if (penDown && sknLastOn) {
+		RectangleType r;
+		DmOpenRef skinDBP;
+	
+		skinDBP = SknOpenSkin();
+		SknGetObjectBounds(skinDBP, sknLastOn, &r);
+
+		if (RctPtInRectangle(x*2, y*2, &r)) {
+			if (SknGetState(skinDBP, sknLastOn) != sknStateSelected) {
+				SknSetState(skinDBP, sknLastOn, sknStateSelected);
+				SknShowObject(skinDBP, sknLastOn);
+			}
+			
+			switch (sknLastOn) {
+				case skinSliderUpArrow:
+				case skinSliderDownArrow:
+					handled = SknProcessArrowAction(sknLastOn);
+					break;
+			}
+			
+		} else {
+			if (SknGetState(skinDBP, sknLastOn) != sknStateNormal) {
+				SknSetState(skinDBP, sknLastOn, sknStateNormal);
+				SknShowObject(skinDBP, sknLastOn);
+			}
+		}
+
+		SknCloseSkin(skinDBP);
+	}
+	
+	return handled;
+}
+
+
+static Boolean MainFormHandleEvent(EventPtr eventP)
+{
+	Boolean handled = false;
+	FormPtr frmP;
+	Coord x,y;
+	DmOpenRef skinDBP;
+	
+	switch (eventP->eType) {
+		case frmUpdateEvent:
+		frmP = FrmGetFormPtr(MainForm);
+			if (gPrefs->card.volRefNum != sysInvalidRefNum)
+				FrmShowObject(frmP, FrmGetObjectIndex (frmP, MainMSBitMap));
+			else
+				FrmShowObject(frmP, FrmGetObjectIndex (frmP, MainMSNoneBitMap));
+			if (eventP->data.frmUpdate.updateCode == frmRedrawUpdateMSImport) {
+				GamImportDatabase();
+				SknUpdateList();
+			}
+			handled = true;
+			break;
+
+		case winDisplayChangedEvent:
+			if (gVars) {
+				if (gVars->skinSet)
+					SknApplySkin();
+			}
+			break;
+
+		case menuEvent:
+			handled = MainFormDoCommand(eventP->data.menu.itemID);
+			break;
+
+		case frmOpenEvent:
+			MainFormInit();
+			handled = true;
+			break;
+
+		case ctlSelectEvent:
+			switch (eventP->data.ctlSelect.controlID)
+			{
+				case MainCardsButton:
+					//gPrefs->card.volRefNum = parseCards(true);
+					FrmPopupForm(CardSlotForm);
+					break;
+			
+				case MainAboutButton:
+					MainFormAbout();
+					break;
+				
+//				case MainListTypeSelTrigger:
+//					FrmList(eventP, MainListTypeList);
+//					break;
+			}
+			handled = true;
+			break;
+
+		case penUpEvent:
+			x = eventP->screenX;
+			y = eventP->screenY;
+			lastIndex = dmMaxRecordIndex;	// enable select/unselect list item
+			
+			if (sknLastOn != skinButtonNone) {
+				RectangleType r;
+				skinDBP = SknOpenSkin();
+				SknGetObjectBounds(skinDBP, sknLastOn, &r);
+				SknSetState(skinDBP, sknLastOn, sknStateNormal);
+				SknShowObject(skinDBP, sknLastOn);
+				SknCloseSkin(skinDBP);
+				
+				if (RctPtInRectangle(x*2, y*2, &r)) {
+					switch (sknLastOn) {
+						case skinButtonGameAdd:
+							editMode = edtModeAdd;
+							FrmPopupForm(EditGameForm);
+							handled = true;
+							break;
+
+						case skinButtonGameEdit:
+						case skinButtonGameParams:
+							editMode = edtModeParams;
+							FrmPopupForm(EditGameForm);
+							handled = true;
+							break;
+
+						case skinButtonGameStart:
+							if (gPrefs->card.volRefNum == sysInvalidRefNum)
+								FrmCustomAlert(FrmWarnAlert,"Please select/insert a memory card.", 0, 0);
+							else
+								bStartScumm = true;
+							handled = true;
+							break;
+
+						case skinButtonGameDelete:
+							EditGameFormDelete(true);
+							break;
+					}
+				}
+				sknLastOn = skinButtonNone;
+			}
+			break;
+
+		case penDownEvent:
+		case penMoveEvent:
+			if (sknLastOn == skinButtonNone) {
+				x = eventP->screenX;
+				y = eventP->screenY;
+				skinDBP = SknOpenSkin();
+
+				switch (sknLastOn = SknCheckClick(skinDBP, x,y)) {
+					case skinButtonNone:
+						break;
+					case skinSliderUpArrow:
+					case skinSliderDownArrow:
+					case skinButtonGameAdd:
+					case skinButtonGameEdit:
+					case skinButtonGameParams:
+					case skinButtonGameStart:
+					case skinButtonGameDelete:
+						SknSetState(skinDBP, sknLastOn, sknStateSelected);
+						SknShowObject(skinDBP, sknLastOn);				
+						if (gPrefs->soundClick)
+							SndPlaySystemSound(sndClick);
+						handled = true;
+						break;
+					default:
+						FrmCustomAlert(FrmWarnAlert,"Unknown button !",0,0);
+				}
+				SknCloseSkin(skinDBP);
+				SknSelect(x, y);
+			}
+			break;
+		
+		default:
+			handled = PenDownRepeat();
+	}
+
+	return handled;
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    AppHandleEvent
+ *
+ * DESCRIPTION: This routine loads form resources and set the event
+ *              handler for the form loaded.
+ *
+ * PARAMETERS:  event  - a pointer to an EventType structure
+ *
+ * RETURNED:    true if the event has handle and should not be passed
+ *              to a higher level handler.
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static Boolean AppHandleEvent(EventPtr eventP)
+{
+	UInt16 formId;
+	FormPtr frmP;
+
+	if (eventP->eType == frmLoadEvent)
+		{
+		// Load the form resource.
+		formId = eventP->data.frmLoad.formID;
+		frmP = FrmInitForm(formId);
+		FrmSetActiveForm(frmP);
+
+		// Set the event handler for the form.  The handler of the currently
+		// active form is called by FrmHandleEvent each time is receives an
+		// event.
+		switch (formId)
+			{
+			case MainForm:
+				FrmSetEventHandler(frmP, MainFormHandleEvent);
+				break;
+
+			case SkinsForm:
+				FrmSetEventHandler(frmP, SkinsFormHandleEvent);
+				break;
+
+			case EditGameForm:
+				FrmSetEventHandler(frmP, EditGameFormHandleEvent);
+				break;
+
+			case MiscOptionsForm:
+				FrmSetEventHandler(frmP, MiscOptionsFormHandleEvent);
+				break;
+
+			case VolumeForm:
+				FrmSetEventHandler(frmP, VolumeFormHandleEvent);
+				break;
+			
+			case SoundForm:
+				FrmSetEventHandler(frmP, SoundFormHandleEvent);
+				break;
+
+			case SystemInfoForm:
+				FrmSetEventHandler(frmP, SystemInfoFormHandleEvent);
+				break;
+
+			case CardSlotForm:
+				FrmSetEventHandler(frmP, CardSlotFormHandleEvent);
+				break;
+
+			default:
+//				ErrFatalDisplay("Invalid Form Load Event");
+				break;
+
+			}
+		return true;
+		}
+	
+	return false;
+}
+
+
+/***********************************************************************
+ *
+ * FUNCTION:    AppEventLoop
+ *
+ * DESCRIPTION: This routine is the event loop for the application.  
+ *
+ * PARAMETERS:  nothing
+ *
+ * RETURNED:    nothing
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void AppEventLoop(void)
+{
+	UInt16 error;
+	EventType event;
+
+	do {
+		EvtGetEvent(&event, evtNoWait);
+
+		if(bStartScumm)
+			StartScummVM();
+
+		if (! SysHandleEvent(&event))
+			if (! MenuHandleEvent(0, &event, &error))
+				if (! AppHandleEvent(&event))
+					FrmDispatchEvent(&event);
+
+	} while (event.eType != appStopEvent);
+}
+
+
+/***********************************************************************
+ *
+ * FUNCTION:     AppStart
+ *
+ * DESCRIPTION:  Get the current application's preferences.
+ *
+ * PARAMETERS:   nothing
+ *
+ * RETURNED:     Err value 0 if nothing went wrong
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static Err AppStartCheckHRmode()
+{
+	SonySysFtrSysInfoP sonySysFtrSysInfoP;
+	UInt32 version;
+	Err error = errNone;
+
+	// test if sonyHR is present
+	if (!(error = FtrGet(sonySysFtrCreator, sonySysFtrNumSysInfoP, (UInt32*)&sonySysFtrSysInfoP))) {
+		if (sonySysFtrSysInfoP->libr & sonySysFtrSysInfoLibrHR) {		// HR available
+
+			if ((error = SysLibFind(sonySysLibNameHR, &gVars->HRrefNum)))
+				if (error == sysErrLibNotFound)							// couldn't find lib
+					error = SysLibLoad( 'libr', sonySysFileCHRLib, &gVars->HRrefNum);
+
+			if (!error) {	// Now we can use HR lib. Executes Open library.
+				error = HROpen(gVars->HRrefNum);
+				gVars->options |= optIsClieDevice;
+			}
+		}
+	}
+	// if not Hi-Density ?
+	if (error && !(error = FtrGet(sysFtrCreator, sysFtrNumWinVersion, &version))) {
+		gVars->HRrefNum = sysInvalidRefNum;	// Not sony HR
+		gVars->options &= ~optIsClieDevice;
+
+		if (version<4)
+			error = 1;
+	}
+
+	if (!error) { // Not, error processing
+		UInt32 width, height, depth;
+		Boolean color;
+
+		width = hrWidth;
+		height= hrHeight;
+		depth = 8;
+		color = true;
+
+		if (gVars->HRrefNum != sysInvalidRefNum)
+			error = HRWinScreenMode (gVars->HRrefNum, winScreenModeSet, &width, &height, &depth, &color );
+		else
+			error = WinScreenMode (winScreenModeSet, &width, &height, &depth, &color );
+
+		// high-resolution mode entered from here if no error
+		if (error != errNone)
+			FrmCustomAlert(FrmErrorAlert,"Your device doesn't seems to support 256 colors mode.",0,0);
+
+		// check for 16bit mode
+		if (!WinScreenMode(winScreenModeGetSupportedDepths, NULL, NULL, &depth, &color))
+			gVars->options |= ((depth & 0x8000) ? optHas16BitMode : 0);
+	}
+	else
+		FrmCustomAlert(FrmErrorAlert,"This device doesn't seems to support\nHi-Res mode.",0,0);
+
+	return error;
+}
+
+static void AppStopHRMode() {
+	if (gVars->HRrefNum != sysInvalidRefNum) {
+			HRClose(gVars->HRrefNum);
+			//SysLibRemove(gVars->HRrefNum);	// never call this !!
+	}
+}
+
+static Err AppStartCheckNotify() {
+	UInt32 romVersion;
+	Err err;
+
+	err = FtrGet(sysFtrCreator, sysFtrNumNotifyMgrVersion, &romVersion); 
+	if (!err) {
+		UInt16 cardNo;
+		LocalID dbID;
+
+		err = SysCurAppDatabase(&cardNo, &dbID);
+		if (!err) {
+			SysNotifyRegister(cardNo, dbID, sysNotifyVolumeMountedEvent, NULL, sysNotifyNormalPriority, NULL);
+			SysNotifyRegister(cardNo, dbID, sysNotifyVolumeUnmountedEvent, NULL, sysNotifyNormalPriority, NULL);
+			SysNotifyRegister(cardNo, dbID, sonySysNotifyMsaEnforceOpenEvent, NULL, sysNotifyNormalPriority, NULL);
+			SysNotifyRegister(cardNo, dbID, sysNotifyDisplayResizedEvent, NULL, sysNotifyNormalPriority, NULL);
+		}
+	}
+
+	return err;
+}
+
+static Err AppStartLoadSkin() {
+	Err err = errNone;
+
+	// if skin defined, check if the db still exists
+	if (gPrefs->skin.dbID) {
+		UInt32 type, creator;
+
+		// remember to check version for next revision of the skin
+		err = DmDatabaseInfo (gPrefs->skin.cardNo, gPrefs->skin.dbID, gPrefs->skin.nameP, 0, 0, 0, 0, 0, 0, 0,0, &type, &creator);
+		if (!err)
+			if (type != 'skin' || creator != appFileCreator)
+				err = dmErrInvalidParam;
+
+		if (err)
+			MemSet(&(gPrefs->skin),sizeof(SkinInfoType),0);
+	}
+
+	// No skin ? try to get the first one
+	if (!gPrefs->skin.dbID) {
+		DmSearchStateType stateInfo;
+
+		err = DmGetNextDatabaseByTypeCreator(true, &stateInfo, 'skin', appFileCreator, false, &gPrefs->skin.cardNo, &gPrefs->skin.dbID);
+		if (!err)
+			err = DmDatabaseInfo (gPrefs->skin.cardNo, gPrefs->skin.dbID, gPrefs->skin.nameP, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+
+	if (err)
+		FrmCustomAlert(FrmErrorAlert,"No skin found.\nPlease install a skin and restart ScummVM.",0,0);
+	
+	return err;
+}
+
+static Err AppStartCheckMathLib()
+{
+	Err error = errNone;
+
+	if ((error = SysLibFind(MathLibName, &MathLibRef)))
+		if (error == sysErrLibNotFound)									// couldn't find lib
+			error = SysLibLoad( LibType, MathLibCreator, &MathLibRef);
+
+	if (!error) {// Now we can use lib. Executes Open library.
+		error = MathLibOpen(MathLibRef, MathLibVersion);
+		if (error)
+			FrmCustomAlert(FrmErrorAlert,"Can't open MathLib !",0,0);
+
+	} else {
+		FrmCustomAlert(FrmErrorAlert,"Can't find MathLib.\nPlease install it first.",0,0);
+	}
+
+	return error;
+}
+
+static void AppStopMathLib() {
+	UInt16 useCount;
+
+	if (MathLibRef != sysInvalidRefNum) {
+		MathLibClose(MathLibRef, &useCount);
+		
+		if (!useCount)
+			SysLibRemove(MathLibRef);
+	}
+}
+
+static Err AppStartCheckScreenSize() {
+	SonySysFtrSysInfoP sonySysFtrSysInfoP;
+	Err error = errNone;
+	UInt32 ftr = 0;
+
+//	WinGetDisplayExtent(&gVars->screenWidth, &gVars->screenHeight);
+	
+//	gVars->screenWidth <<= 1;
+//	gVars->screenHeight <<= 1;
+	gVars->screenWidth = 320;
+	gVars->screenHeight = 320;
+
+	gVars->screenFullWidth = gVars->screenWidth;
+	gVars->screenFullHeight = gVars->screenHeight;
+
+	// Sony HiRes+
+	if (!(error = FtrGet(sonySysFtrCreator, sonySysFtrNumSysInfoP, (UInt32*)&sonySysFtrSysInfoP))) {
+		if (sonySysFtrSysInfoP->libr & sonySysFtrSysInfoLibrSilk) {
+
+			if ((error = SysLibFind(sonySysLibNameSilk, &gVars->slkRefNum)))
+				if (error == sysErrLibNotFound)	
+					error = SysLibLoad( sonySysFileTSilkLib, sonySysFileCSilkLib, &gVars->slkRefNum);
+
+			if (!error) {
+				error = FtrGet(sonySysFtrCreator, sonySysFtrNumVskVersion, &gVars->slkVersion);
+				// Get screen size
+				if (error) {
+					// v1 = NR
+				 	error = SilkLibOpen(gVars->slkRefNum);
+					if(!error) {
+						gVars->slkVersion = vskVersionNum1;
+						SilkLibEnableResize(gVars->slkRefNum);
+						SilkLibResizeDispWin(gVars->slkRefNum, silkResizeMax);
+						HRWinGetWindowExtent(gVars->HRrefNum, &gVars->screenFullWidth, &gVars->screenFullHeight);
+						SilkLibResizeDispWin(gVars->slkRefNum, silkResizeNormal);
+						SilkLibDisableResize(gVars->slkRefNum);
+					}
+				} else {
+					// v2 = NX/NZ
+					// v3 = UX
+				 	error = VskOpen(gVars->slkRefNum);
+					if(!error) {
+						VskSetState(gVars->slkRefNum, vskStateEnable, (gVars->slkVersion == vskVersionNum2 ? vskResizeVertically : vskResizeHorizontally));
+						gVars->options |= (gVars->slkVersion == vskVersionNum2 ? optIsLandscapeMode : 0);
+						VskSetState(gVars->slkRefNum, vskStateResize, vskResizeNone);
+						HRWinGetWindowExtent(gVars->HRrefNum, &gVars->screenFullWidth, &gVars->screenFullHeight);
+						VskSetState(gVars->slkRefNum, vskStateResize, vskResizeMax);
+						VskSetState(gVars->slkRefNum, vskStateEnable, vskResizeDisable);
+					}
+				}
+			}
+		}
+
+		if (error)
+			gVars->slkRefNum = sysInvalidRefNum;
+		else
+			gVars->options |= optHasWideMode;
+	}
+
+	// Tapwave Zodiac and other DIA API compatible devies, TODO : a better handler, read the doc
+	if (error) {
+		if (!(error = FtrGet(sysFtrCreator, sysFtrNumInputAreaFlags, &ftr))) {
+			if (ftr & grfFtrInputAreaFlagLandscape) {
+				UInt16 old = SysGetOrientation();
+				error = SysSetOrientation(sysOrientationLandscape);
+				error = (error) ? error : PINSetInputAreaState(pinInputAreaClosed);
+				error = (error) ? error : StatHide();
+
+				if (!error) {
+					RectangleType r;
+					WinGetBounds(WinGetDisplayWindow(), &r);
+					gVars->screenFullWidth = r.extent.x << 1;
+					gVars->screenFullHeight = r.extent.y << 1;
+					gVars->options |= optHasWideMode|optIsLandscapeMode;
+				}
+				
+				error = StatShow();
+				error = PINSetInputAreaState(pinInputAreaOpen);
+				error = SysSetOrientation(old);
+			}
+		}	
+	}
+	
+	return error;
+}
+
+static void AppStopSilk() {
+	if (gVars->slkRefNum != sysInvalidRefNum)
+		SilkLibClose(gVars->slkRefNum);
+}
+
+static Err AppStart(void) {
+	UInt16 dataSize, checkSize = 0;
+	UInt32 ulProcessorType;
+	UInt32 romVersion;
+	Err error;
+
+	// allocate global variables space
+	dataSize = sizeof(GlobalsDataType);
+	gVars = (GlobalsDataType *)MemPtrNew(dataSize);
+	MemSet(gVars, dataSize, 0);
+
+	gVars->indicator.on	= 255;
+	gVars->indicator.off = 0;
+	gVars->HRrefNum = sysInvalidRefNum;
+	gVars->volRefNum = sysInvalidRefNum;
+	gVars->slkRefNum = sysInvalidRefNum;
+	gVars->skinSet = false;
+	gVars->options = optNone;
+
+	// OS5 ?
+	if (!FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion))
+		gVars->options |= ((romVersion >= kOS5Version) ? optIsOS5Device : 0);
+
+	// ARM ?
+ 	if (!FtrGet(sysFileCSystem, sysFtrNumProcessorID, &ulProcessorType))
+ 		gVars->options |= ((sysFtrNumProcessorIsARM(ulProcessorType)) ? optIsARMDevice : 0);
+
+	// allocate prefs space
+	dataSize = sizeof(GlobalsPreferenceType);
+	gPrefs	= (GlobalsPreferenceType *)MemPtrNew(dataSize);
+	MemSet(gPrefs, dataSize, 0);
+
+	// Read the saved preferences / saved-state information.
+	if (PrefGetAppPreferences(appFileCreator, appPrefID, NULL, &checkSize, true) == noPreferenceFound || checkSize != dataSize) {
+		// reset all elements
+		MemSet(gPrefs, dataSize, 0);
+
+		gPrefs->card.volRefNum = sysInvalidRefNum;
+
+		gPrefs->autoOff = true;
+		gPrefs->vibrator = CheckVibratorExists();
+		gPrefs->debug = false;
+
+		gPrefs->stdPalette = (gVars->options & optIsOS5Device);
+		
+		gPrefs->volume.speaker = 16;
+		gPrefs->volume.headphone = 16;
+		
+		gPrefs->volume.master = 192;
+		gPrefs->volume.music = 192;
+		gPrefs->volume.sfx = 192;
+		
+		gPrefs->sound.tempo = 100;
+		gPrefs->sound.defaultTrackLength = 10;
+		gPrefs->sound.firstTrack = 1;
+		
+	} else {
+		PrefGetAppPreferences(appFileCreator, appPrefID, gPrefs, &dataSize, true);
+	}
+
+	error = AppStartCheckMathLib();
+	if (error) return (error);
+
+	error = AppStartCheckHRmode();
+	if (error) return (error);
+	
+	error = AppStartLoadSkin();
+	if (error) return (error);
+
+	if (gPrefs->card.volRefNum != sysInvalidRefNum) {	// if volref previously defined, check if it's a valid one
+		VolumeInfoType volInfo;
+		Err err = VFSVolumeInfo(gPrefs->card.volRefNum, &volInfo);
+		if (err)
+			gPrefs->card.volRefNum = sysInvalidRefNum;
+	}
+	else
+		gPrefs->card.volRefNum = parseCards(); //parseCards(0);	// get first volref
+
+	error = GamOpenDatabase();
+	if (error) return (error);
+	GamImportDatabase();
+
+	AppStartCheckNotify(); // not fatal error if not avalaible
+	AppStartCheckScreenSize();
+
+	return error;
+}
+
+/***********************************************************************
+ *
+ * FUNCTION:    AppStop
+ *
+ * DESCRIPTION: Save the current state of the application.
+ *
+ * PARAMETERS:  nothing
+ *
+ * RETURNED:    nothing
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static Err AppStopCheckNotify()
+{
+	UInt32 romVersion;
+	Err err;
+	
+	err = FtrGet(sysFtrCreator, sysFtrNumNotifyMgrVersion, &romVersion); 
+	if (!err) {
+		UInt16 cardNo;
+		LocalID dbID;
+
+		err = SysCurAppDatabase(&cardNo, &dbID);
+		if (!err) {
+			SysNotifyUnregister(cardNo, dbID, sysNotifyVolumeUnmountedEvent, sysNotifyNormalPriority);
+			SysNotifyUnregister(cardNo, dbID, sysNotifyVolumeMountedEvent, sysNotifyNormalPriority);
+			// sonySysNotifyMsaEnforceOpenEvent
+			SysNotifyUnregister(cardNo, dbID, sysNotifyDisplayResizedEvent, sysNotifyNormalPriority);
+		}
+	}
+	
+	return err;
+}
+
+static void AppStop(void) {
+	// Close all the open forms.
+	FrmCloseAllForms();
+	WinEraseWindow();
+	WinPalette(winPaletteSetToDefault, 0, 256, NULL);
+
+	// Close and move Game list database
+	GamCloseDatabase(false);
+
+	// Write the saved preferences / saved-state information.  This data 
+	// will saved during a HotSync backup.
+	SavePrefs();
+
+	// stop all
+	AppStopSilk();
+	AppStopCheckNotify();
+	AppStopMathLib();
+	AppStopHRMode();
+
+	// reset if needed
+	if (gVars) {
+		Boolean autoReset = gVars->autoReset;
+		MemPtrFree(gVars);
+		if (autoReset)
+			SysReset();
+	}
+}
+
+
+/***********************************************************************
+ *
+ * FUNCTION:    ScummVMPalmMain
+ *
+ * DESCRIPTION: This is the main entry point for the application.
+ *
+ * PARAMETERS:  cmd - word value specifying the launch code. 
+ *              cmdPB - pointer to a structure that is associated with the launch code. 
+ *              launchFlags -  word value providing extra information about the launch.
+ *
+ * RETURNED:    Result of launch
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+static void AppLaunchCmdNotify(UInt16 LaunchFlags, SysNotifyParamType * pData)
+{
+	switch (pData->notifyType)
+	{
+		case sysNotifyVolumeMountedEvent:
+			pData->handled = true;	// don't switch
+
+			if (gPrefs) {	// gPrefs exists ? so we are in the palm selector
+				CardSlotFormUpdate(); // redraw card list if needed
+
+				if (gPrefs->card.volRefNum == sysInvalidRefNum) {
+					VFSAnyMountParamType *notifyDetailsP = (VFSAnyMountParamType *)pData->notifyDetailsP;
+					gPrefs->card.volRefNum = notifyDetailsP->volRefNum;
+
+					if (FrmGetFormPtr(MainForm) == FrmGetActiveForm())
+						if (gPrefs->card.volRefNum != sysInvalidRefNum) {
+							CardSlotCreateDirs();
+							FrmUpdateForm(MainForm, frmRedrawUpdateMSImport);
+						}
+				}
+			}
+			break;
+		
+		case sysNotifyVolumeUnmountedEvent:
+			if (gPrefs) {
+				CardSlotFormUpdate();
+
+				if (gPrefs->card.volRefNum == (UInt16)pData->notifyDetailsP) {
+					gPrefs->card.volRefNum = sysInvalidRefNum;
+
+					if (FrmGetFormPtr(MainForm) == FrmGetActiveForm())
+						FrmUpdateForm(MainForm, frmRedrawUpdateMS);
+				}
+			}
+			break;
+
+		case sysNotifyDisplayResizedEvent:
+			EventType ev;
+			MemSet(&ev, sizeof(EventType), 0);
+			ev.eType = (enum eventsEnum)winDisplayChangedEvent;
+			EvtAddUniqueEventToQueue(&ev, 0, true);
+			break;
+
+		case sonySysNotifyMsaEnforceOpenEvent:
+			// what am i supposed to do here ???
+			break;
+	}
+}
+
+static UInt32 ScummVMPalmMain(UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
+{
+	Err error;
+
+	error = RomVersionCompatible (kOurMinVersion, launchFlags);
+	if (error) return (error);
+
+	switch (cmd)
+		{
+		case sysAppLaunchCmdNotify:
+			AppLaunchCmdNotify(launchFlags, (SysNotifyParamType *) cmdPBP);
+			break;
+
+		case sysAppLaunchCmdNormalLaunch:
+			error = AppStart();
+			if (error) 
+				goto end;
+				
+			FrmGotoForm(MainForm);
+			AppEventLoop();
+end:
+			AppStop();
+			break;
+
+		default:
+			break;
+
+		}
+
+	return error;
+}
+/***********************************************************************
+ *
+ * FUNCTION:    PilotMain
+ *
+ * DESCRIPTION: This is the main entry point for the application.
+ *
+ * PARAMETERS:  cmd - word value specifying the launch code. 
+ *              cmdPB - pointer to a structure that is associated with the launch code. 
+ *              launchFlags -  word value providing extra information about the launch.
+ * RETURNED:    Result of launch
+ *
+ * REVISION HISTORY:
+ *
+ *
+ ***********************************************************************/
+
+UInt32 PilotMain( UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
+{
+	return ScummVMPalmMain(cmd, cmdPBP, launchFlags);
+}
diff --git a/backends/PalmOS/Src/start.h b/backends/PalmOS/Src/start.h
new file mode 100644
index 0000000000..aefb5bb76d
--- /dev/null
+++ b/backends/PalmOS/Src/start.h
@@ -0,0 +1,89 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2003 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+ 
+#ifndef __START_H__
+#define __START_H__
+
+#define appFileCreator 'ScVM'
+#define curItemVersion sysMakeROMVersion(2,0,0,0,0)
+
+typedef struct {
+	Char nameP[32];
+	UInt16 cardNo;
+	LocalID dbID;
+} SkinInfoType, *SkinInfoPtr;
+
+typedef	struct {
+
+	//skin params
+	SkinInfoType skin;	//	card where is located the skin
+	Boolean soundClick;	
+	//
+	Boolean vibrator;
+	Boolean autoOff;
+
+	UInt16 listPosition;
+
+	struct {
+		UInt16 volRefNum;
+		Boolean moveDB;
+		Boolean deleteDB;
+		Boolean confirmMoveDB;
+	} card;
+
+	Boolean debug;
+	UInt16 debugLevel;
+	Boolean saveConfig;
+	Boolean stdPalette;
+	Boolean autoReset;
+	Boolean demoMode;
+	Boolean fullscreen;
+
+	struct {
+		UInt16 speaker;
+		UInt16 headphone;
+		
+		UInt16 master;
+		UInt16 music;
+		UInt16 sfx;
+	} volume;
+	
+	struct {
+		// midi
+		Boolean multiMidi;
+		Boolean music;
+		UInt8 driver;
+		UInt8 tempo;
+		// CD audio
+		Boolean MP3;
+		Boolean setDefaultTrackLength;
+		UInt16 defaultTrackLength;
+		UInt16 firstTrack;
+		// sound FX
+		Boolean sfx;
+	} sound;
+
+} GlobalsPreferenceType, *GlobalsPreferencePtr;
+
+extern GlobalsPreferencePtr gPrefs;
+
+#endif
\ No newline at end of file