From 2ef4f1fea2c04092e512fabc80aff2eced31c69d Mon Sep 17 00:00:00 2001 From: Chris Apers Date: Sun, 26 Feb 2006 16:36:51 +0000 Subject: Move launcher files to a new folder svn-id: r20931 --- backends/PalmOS/Src/launcher/forms/formCards.cpp | 378 +++++++++++++ backends/PalmOS/Src/launcher/forms/formCards.h | 32 ++ .../PalmOS/Src/launcher/forms/formEditGame.cpp | 611 +++++++++++++++++++++ backends/PalmOS/Src/launcher/forms/formEditGame.h | 38 ++ backends/PalmOS/Src/launcher/forms/formMisc.cpp | 261 +++++++++ backends/PalmOS/Src/launcher/forms/formSkins.cpp | 267 +++++++++ backends/PalmOS/Src/launcher/forms/formUtil.cpp | 60 ++ backends/PalmOS/Src/launcher/forms/formUtil.h | 21 + backends/PalmOS/Src/launcher/forms/forminfo.cpp | 146 +++++ backends/PalmOS/Src/launcher/forms/formmain.cpp | 363 ++++++++++++ backends/PalmOS/Src/launcher/forms/formmusic.cpp | 387 +++++++++++++ backends/PalmOS/Src/launcher/forms/forms.h | 22 + backends/PalmOS/Src/launcher/forms/formtabs.cpp | 242 ++++++++ backends/PalmOS/Src/launcher/forms/formtabs.h | 24 + 14 files changed, 2852 insertions(+) create mode 100644 backends/PalmOS/Src/launcher/forms/formCards.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formCards.h create mode 100644 backends/PalmOS/Src/launcher/forms/formEditGame.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formEditGame.h create mode 100644 backends/PalmOS/Src/launcher/forms/formMisc.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formSkins.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formUtil.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formUtil.h create mode 100644 backends/PalmOS/Src/launcher/forms/forminfo.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formmain.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formmusic.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/forms.h create mode 100644 backends/PalmOS/Src/launcher/forms/formtabs.cpp create mode 100644 backends/PalmOS/Src/launcher/forms/formtabs.h (limited to 'backends') diff --git a/backends/PalmOS/Src/launcher/forms/formCards.cpp b/backends/PalmOS/Src/launcher/forms/formCards.cpp new file mode 100644 index 0000000000..1c22ea647a --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formCards.cpp @@ -0,0 +1,378 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include +#include +#include + +#include "start.h" +#include "formTabs.h" +#include "forms.h" +#include "globals.h" + +typedef struct { + UInt16 volRefNum; + Char nameP[expCardInfoStringMaxLen+1]; + +} CardInfoType; + +static TabType *myTabP; +static UInt16 lastTab = 0; + +static void CardSlotFormExit(Boolean bSave); + +static void CardSlotFreeList() { + MemHandle cards = NULL; + MemHandle items = NULL; + + if (itemsText && itemsList) { + cards = MemPtrRecoverHandle(itemsList); + items = MemPtrRecoverHandle(itemsText); + + itemsText = NULL; + itemsList = NULL; + } + itemsType = ITEM_TYPE_UNKNOWN; + + if (items && cards) { + MemHandleUnlock(items); + MemHandleUnlock(cards); + MemHandleFree(items); + MemHandleFree(cards); + } +} + +static UInt16 CardSlotFillList(Boolean getRefNum = false) { + Err err; + UInt16 index; + UInt16 volRefNum; + UInt32 volIterator = vfsIteratorStart|vfsIncludePrivateVolumes; + UInt8 counter = 0; + UInt32 other = 1; + + MemHandle items = NULL; + MemHandle cards = NULL; + CardInfoType *cardsInfo; + + // retreive card infos + while (volIterator != vfsIteratorStop) { + err = VFSVolumeEnumerate(&volRefNum, &volIterator); + + if (!err) { + Char labelP[expCardInfoStringMaxLen+1]; + MemSet(labelP, expCardInfoStringMaxLen+1, 0); + 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 (counter > 0) { + // set the list items ... + if (!getRefNum) { + 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); + } + + // save globals + itemsText = (Char **)MemHandleLock(items); + itemsList = (void *)MemHandleLock(cards); + itemsType = ITEM_TYPE_CARD; + + // ... or just return a default volRefNum + } else { + UInt16 volRefNum; + + cardsInfo = (CardInfoType *)MemHandleLock(cards); + volRefNum = cardsInfo[0].volRefNum; // return the first volref + MemHandleUnlock(cards); + MemHandleFree(cards); + + return volRefNum; + } + + // no card found ? free old list in any or return invalid volref + } else { + if (!getRefNum) + CardSlotFreeList(); + else + return vfsInvalidVolRef; + } + + return counter; +} + +static void ConfigTabInit(Boolean update = false) { + ListPtr listP; + + UInt16 index; + Int16 selected = -1; + + UInt16 counter = CardSlotFillList(); + listP = (ListType *)GetObjectPtr(TabCardConfigSlotList); + + // itemsText can be NULL if counter = 0 + LstSetListChoices (listP, itemsText, counter); + if (counter > 0) { + CardInfoType *cardsInfo = (CardInfoType *)itemsList; + + for (index = 0; index < counter; index++) { + if (cardsInfo[index].volRefNum == gPrefs->card.volRefNum) { + selected = index; + break; + } + } + + LstSetSelection(listP, selected); + } + + if (!update) { + FieldType *fld1P; + Char *cacheP; + MemHandle cacheH; + + fld1P = (FieldType *)GetObjectPtr(TabCardConfigCacheSizeField); + cacheH = MemHandleNew(FldGetMaxChars(fld1P)+1); + cacheP = (Char *)MemHandleLock(cacheH); + StrIToA(cacheP, gPrefs->card.cacheSize / 1024); + MemHandleUnlock(cacheH); + + FldSetTextHandle(fld1P, cacheH); + CtlSetValue((ControlType *)GetObjectPtr(TabCardConfigCacheCheckbox), gPrefs->card.useCache); + CtlSetValue((ControlType *)GetObjectPtr(TabCardConfigLedCheckbox), gPrefs->card.showLED); + // update ? redraw the list + } else { + WinScreenLock(winLockCopy); + LstDrawList(listP); + WinScreenUnlock(); + } +} + +static UInt16 ConfigTabSave() { + ControlType *cckP[2]; + FieldType *fld1P; + ListPtr listP; + FormPtr frmP; + UInt16 updateCode = frmRedrawUpdateMS; + + cckP[0] = (ControlType *)GetObjectPtr(TabCardConfigCacheCheckbox); + cckP[1] = (ControlType *)GetObjectPtr(TabCardConfigLedCheckbox); + + gPrefs->card.useCache = CtlGetValue(cckP[0]); + gPrefs->card.showLED = CtlGetValue(cckP[1]); + + fld1P = (FieldType *)GetObjectPtr(TabCardConfigCacheSizeField); + frmP = FrmGetActiveForm(); + if (FldGetTextLength(fld1P) == 0 && CtlGetValue(cckP[0]) == 1) { + TabSetActive(frmP, myTabP, 0); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabCardConfigCacheSizeField)); + FrmCustomAlert(FrmWarnAlert,"You must specified a cache size.",0,0); + return 0; + } + gPrefs->card.cacheSize = StrAToI(FldGetTextPtr(fld1P)) * 1024; + + Int16 selected; + CardInfoType *cardsInfo = (CardInfoType *)itemsList; + + listP = (ListType *)GetObjectPtr(TabCardConfigSlotList); + selected = LstGetSelection(listP); + if (selected == -1) { + gPrefs->card.volRefNum = vfsInvalidVolRef; + } else if (gPrefs->card.volRefNum != cardsInfo[selected].volRefNum) { + updateCode = frmRedrawUpdateMSImport; + gPrefs->card.volRefNum = cardsInfo[selected].volRefNum; + } + + CardSlotCreateDirs(); + CardSlotFreeList(); + + return updateCode; +} + +static void GameListTabInit() { + CtlSetValue((ControlType *)GetObjectPtr(TabCardGameListMoveCheckbox), gPrefs->card.moveDB); + CtlSetValue((ControlType *)GetObjectPtr(TabCardGameListDeleteCheckbox), gPrefs->card.deleteDB); + CtlSetValue((ControlType *)GetObjectPtr(TabCardGameListConfirmCheckbox), gPrefs->card.confirmMoveDB); +} + +static void GameListTabSave() { + ControlType *cckP[3]; + + cckP[0] = (ControlType *)GetObjectPtr(TabCardGameListMoveCheckbox); + cckP[1] = (ControlType *)GetObjectPtr(TabCardGameListDeleteCheckbox); + cckP[2] = (ControlType *)GetObjectPtr(TabCardGameListConfirmCheckbox); + + gPrefs->card.moveDB = CtlGetValue(cckP[0]); + gPrefs->card.deleteDB = CtlGetValue(cckP[1]); + gPrefs->card.confirmMoveDB = CtlGetValue(cckP[2]); +} + +static void GameListTabDraw() { + ControlType *cck1P; + FormPtr frmP = FrmGetActiveForm(); + + cck1P = (ControlType *)GetObjectPtr(TabCardGameListMoveCheckbox); + if (CtlGetValue(cck1P)) { + FrmShowObject(frmP, FrmGetObjectIndex (frmP, TabCardGameListDeleteCheckbox)); + FrmShowObject(frmP, FrmGetObjectIndex (frmP, TabCardGameListConfirmCheckbox)); + } else { + FrmHideObject(frmP, FrmGetObjectIndex (frmP, TabCardGameListDeleteCheckbox)); + FrmHideObject(frmP, FrmGetObjectIndex (frmP, TabCardGameListConfirmCheckbox)); + } +} + +static void CardSlotFormInit() { + TabType *tabP; + FormType *frmP = FrmGetActiveForm(); + + tabP = TabNewTabs(2); + TabAddContent(&frmP, tabP, "Cards", TabCardConfigForm); + TabAddContent(&frmP, tabP, "Game List", TabCardGameListForm, GameListTabDraw); + + ConfigTabInit(); + GameListTabInit(); + + FrmDrawForm(frmP); + TabSetActive(frmP, tabP, lastTab); + + myTabP = tabP; +} + +static void CardSlotFormSave() { + UInt16 updateCode; + updateCode = ConfigTabSave(); + if (!updateCode) return; + GameListTabSave(); + CardSlotCreateDirs(); + + TabDeleteTabs(myTabP); + FrmReturnToMain(updateCode); +} + +static void CardSlotFormCancel() { + CardSlotFreeList(); + TabDeleteTabs(myTabP); + FrmReturnToMain(); +} + +Boolean CardSlotFormHandleEvent(EventPtr eventP) { + FormPtr frmP = FrmGetActiveForm(); + Boolean handled = false; + + switch (eventP->eType) { + case frmOpenEvent: + CardSlotFormInit(); + handled = true; + break; + + case frmCloseEvent: + CardSlotFormCancel(); + handled = true; + break; + + case ctlSelectEvent: + switch (eventP->data.ctlSelect.controlID) + { + case (CardSlotForm + 1) : + case (CardSlotForm + 2) : + lastTab = (eventP->data.ctlSelect.controlID - CardSlotForm - 1); + TabSetActive(frmP, myTabP, lastTab); + break; + + case CardSlotOkButton: + CardSlotFormSave(); + break; + + case CardSlotCancelButton: + CardSlotFormCancel(); + break; + + case TabCardGameListMoveCheckbox: + GameListTabDraw(); + break; + } + handled = true; + break; + + default: + break; + } + + return handled; +} + +void CardSlotCreateDirs() { + if (gPrefs->card.volRefNum != vfsInvalidVolRef) { + 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"); + VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs/ScummVM/Audio"); + VFSDirCreate(gPrefs->card.volRefNum, "/PALM/Programs/ScummVM/Mods"); + } +} + +void CardSlotFormUpdate() { + if (itemsType == ITEM_TYPE_CARD) { + CardSlotFreeList(); + ConfigTabInit(true); + } +} + +UInt16 parseCards() { + UInt16 volRefNum = CardSlotFillList(true); + CardSlotFreeList(); + return volRefNum; +} diff --git a/backends/PalmOS/Src/launcher/forms/formCards.h b/backends/PalmOS/Src/launcher/forms/formCards.h new file mode 100644 index 0000000000..956ef86340 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formCards.h @@ -0,0 +1,32 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __FORMCARDS_H__ +#define __FORMCARDS_H__ + +UInt16 parseCards(); +void CardSlotFormUpdate(); +void CardSlotCreateDirs(); + +#endif diff --git a/backends/PalmOS/Src/launcher/forms/formEditGame.cpp b/backends/PalmOS/Src/launcher/forms/formEditGame.cpp new file mode 100644 index 0000000000..42953ad15e --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formEditGame.cpp @@ -0,0 +1,611 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include +#include +#include +#include + +#include "formTabs.h" +#include "forms.h" + +#include "start.h" +#include "games.h" +#include "skin.h" + +#define errBadParam 0x1000 + +static TabType *myTabP; +static UInt16 lastTab = 0; + +UInt8 gFormEditMode; + +static void GameTabInit(GameInfoType *gameInfoP) { + FieldType *fld1P, *fld2P, *fld3P; + Char *nameP, *pathP, *gameP; + MemHandle nameH, pathH, gameH; + ListType *list1P; + + list1P = (ListType *)GetObjectPtr(TabGameInfoEngineList); + + itemsText = (Char **)MemPtrNew(ENGINE_COUNT * sizeof(Char *)); + for (int i = 0; i < ENGINE_COUNT; i++) + itemsText[i] = (Char *)engines[i].nameP; + LstSetListChoices(list1P, itemsText, ENGINE_COUNT); + + fld1P = (FieldType *)GetObjectPtr(TabGameInfoEntryNameField); + fld2P = (FieldType *)GetObjectPtr(TabGameInfoPathField); + fld3P = (FieldType *)GetObjectPtr(TabGameInfoGameField); + + nameH = MemHandleNew(FldGetMaxChars(fld1P)+1); + pathH = MemHandleNew(FldGetMaxChars(fld2P)+1); + gameH = MemHandleNew(FldGetMaxChars(fld3P)+1); + + nameP = (Char *)MemHandleLock(nameH); + pathP = (Char *)MemHandleLock(pathH); + gameP = (Char *)MemHandleLock(gameH); + + if (gameInfoP) { + LstSetSelection(list1P, gameInfoP->engine); + LstSetTopItem(list1P, gameInfoP->engine); + StrCopy(nameP, gameInfoP->nameP); + StrCopy(pathP, gameInfoP->pathP); + StrCopy(gameP, gameInfoP->gameP); + } else { + LstSetSelection(list1P, 0); + MemSet(nameP,MemHandleSize(nameH),0); + MemSet(pathP,MemHandleSize(pathH),0); + MemSet(gameP,MemHandleSize(gameH),0); + } + + CtlSetLabel((ControlType *)GetObjectPtr(TabGameInfoEnginePopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + + MemHandleUnlock(nameH); + MemHandleUnlock(pathH); + MemHandleUnlock(gameH); + + FldSetTextHandle(fld1P, nameH); + FldSetTextHandle(fld2P, pathH); + FldSetTextHandle(fld3P, gameH); +} + +static Err GameTabSave(GameInfoType *gameInfoP) { + FieldType *fld1P, *fld2P, *fld3P; + ListType *list1P; + + FormType *frmP = FrmGetActiveForm(); + list1P = (ListType *)GetObjectPtr(TabGameInfoEngineList); + + fld1P = (FieldType *)GetObjectPtr(TabGameInfoEntryNameField); + fld2P = (FieldType *)GetObjectPtr(TabGameInfoPathField); + fld3P = (FieldType *)GetObjectPtr(TabGameInfoGameField); + + FldTrimText(fld1P); + FldTrimText(fld2P); + FldTrimText(fld3P); + + // test case + if (!gameInfoP) { + if (FldGetTextLength(fld1P) == 0) { + FrmCustomAlert(FrmWarnAlert,"You must specify an entry name.",0,0); + TabSetActive(frmP, myTabP, 0); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameInfoEntryNameField)); + return errBadParam; + + } else if (FldGetTextLength(fld2P) == 0) { + FrmCustomAlert(FrmWarnAlert,"You must specify a path.",0,0); + TabSetActive(frmP, myTabP, 0); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameInfoPathField)); + return errBadParam; + + } else if (FldGetTextLength(fld3P) == 0) { + FrmCustomAlert(FrmWarnAlert,"You must specify a game.",0,0); + TabSetActive(frmP, myTabP, 0); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameInfoGameField)); + return errBadParam; + } + + } else { + gameInfoP->engine = LstGetSelection(list1P); + StrCopy(gameInfoP->nameP, FldGetTextPtr(fld1P)); + StrCopy(gameInfoP->pathP, FldGetTextPtr(fld2P)); + StrCopy(gameInfoP->gameP, FldGetTextPtr(fld3P)); + + if (gameInfoP->pathP[StrLen(gameInfoP->pathP)-1] != '/') + StrCat(gameInfoP->pathP, "/"); + + MemPtrFree(itemsText); + itemsText = NULL; + } + + return errNone; +} + +static void DisplayInit(GameInfoType *gameInfoP) { + ListType *list1P, *list2P; + + list1P = (ListType *)GetObjectPtr(TabGameDisplayGfxListList); + list2P = (ListType *)GetObjectPtr(TabGameDisplayRenderList); + + if (gameInfoP) { + LstSetSelection(list1P, gameInfoP->gfxMode); + LstSetSelection(list2P, gameInfoP->renderMode); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayFilterCheckbox), gameInfoP->filter); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayFullscreenCheckbox), gameInfoP->fullscreen); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayAspectRatioCheckbox), gameInfoP->aspectRatio); + + } else { + LstSetSelection(list1P, 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayFilterCheckbox), 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayFullscreenCheckbox), 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameDisplayAspectRatioCheckbox), 0); + } + + CtlSetLabel((ControlType *)GetObjectPtr(TabGameDisplayGfxPopupPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + CtlSetLabel((ControlType *)GetObjectPtr(TabGameDisplayRenderPopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P))); +} + +static Err DisplaySave(GameInfoType *gameInfoP) { + ListType *list1P, *list2P; + ControlType *cck6P, *cck7P, *cck8P; + + FormType *frmP = FrmGetActiveForm(); + + list1P = (ListType *)GetObjectPtr(TabGameDisplayGfxListList); + list2P = (ListType *)GetObjectPtr(TabGameDisplayRenderList); + cck6P = (ControlType *)GetObjectPtr(TabGameDisplayFilterCheckbox); + cck7P = (ControlType *)GetObjectPtr(TabGameDisplayFullscreenCheckbox); + cck8P = (ControlType *)GetObjectPtr(TabGameDisplayAspectRatioCheckbox); + + if (!gameInfoP) { + } else { + gameInfoP->gfxMode = LstGetSelection(list1P); + gameInfoP->renderMode = LstGetSelection(list2P); + gameInfoP->filter = CtlGetValue(cck6P); + gameInfoP->fullscreen = CtlGetValue(cck7P); + gameInfoP->aspectRatio = CtlGetValue(cck8P); + } + + return errNone; +} + +static void OptionsInit(GameInfoType *gameInfoP) { + ListType *list2P, *list3P; + FieldType *fld4P, *fld5P, *fld6P; + Char *loadP, *roomP, *talkP; + MemHandle loadH, roomH, talkH; + + list2P = (ListType *)GetObjectPtr(TabGameOptionsLanguageList); + list3P = (ListType *)GetObjectPtr(TabGameOptionsPlatformList); + + fld4P = (FieldType *)GetObjectPtr(TabGameOptionsLoadSlotField); + fld5P = (FieldType *)GetObjectPtr(TabGameOptionsStartRoomField); + fld6P = (FieldType *)GetObjectPtr(TabGameOptionsTalkSpeedField); + + loadH = MemHandleNew(FldGetMaxChars(fld4P)+1); + roomH = MemHandleNew(FldGetMaxChars(fld5P)+1); + talkH = MemHandleNew(FldGetMaxChars(fld6P)+1); + + loadP = (Char *)MemHandleLock(loadH); + roomP = (Char *)MemHandleLock(roomH); + talkP = (Char *)MemHandleLock(talkH); + + if (gameInfoP) { + LstSetSelection(list2P, gameInfoP->language); + LstSetTopItem(list2P, gameInfoP->language); + LstSetSelection(list3P, gameInfoP->platform); + LstSetTopItem(list3P, gameInfoP->platform); + + StrIToA(loadP, gameInfoP->loadSlot); + StrIToA(roomP, gameInfoP->bootValue); + StrIToA(talkP, gameInfoP->talkValue); + + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsLoadSlotCheckbox), gameInfoP->autoLoad); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsStartRoomCheckbox), gameInfoP->bootParam); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsAmigaCheckbox), gameInfoP->setPlatform); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsSubtitlesCheckbox), gameInfoP->subtitles); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsTalkSpeedCheckbox), gameInfoP->talkSpeed); + + } else { + LstSetSelection(list2P, 0); + LstSetSelection(list3P, 0); + + StrIToA(loadP, 0); + StrIToA(roomP, 0); + StrIToA(talkP, 60); + + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsLoadSlotCheckbox), 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsStartRoomCheckbox), 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsAmigaCheckbox), 0); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsSubtitlesCheckbox), 1); + CtlSetValue((ControlType *)GetObjectPtr(TabGameOptionsTalkSpeedCheckbox), 0); + } + + MemHandleUnlock(loadH); + MemHandleUnlock(roomH); + MemHandleUnlock(talkH); + + FldSetTextHandle(fld4P, loadH); + FldSetTextHandle(fld5P, roomH); + FldSetTextHandle(fld6P, talkH); + + CtlSetLabel((ControlType *)GetObjectPtr(TabGameOptionsLanguagePopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P))); + CtlSetLabel((ControlType *)GetObjectPtr(TabGameOptionsPlatformPopTrigger), LstGetSelectionText(list3P, LstGetSelection(list3P))); +} + +static Err OptionsSave(GameInfoType *gameInfoP) { + FieldType *fld4P, *fld5P, *fld6P; + ControlType *cck1P, *cck2P, *cck3P, *cck4P, *cck5P; + ListType *list2P, *list3P; + + FormType *frmP = FrmGetActiveForm(); + + list2P = (ListType *)GetObjectPtr(TabGameOptionsLanguageList); + list3P = (ListType *)GetObjectPtr(TabGameOptionsPlatformList); + + fld4P = (FieldType *)GetObjectPtr(TabGameOptionsLoadSlotField); + fld5P = (FieldType *)GetObjectPtr(TabGameOptionsStartRoomField); + fld6P = (FieldType *)GetObjectPtr(TabGameOptionsTalkSpeedField); + + cck1P = (ControlType *)GetObjectPtr(TabGameOptionsLoadSlotCheckbox); + cck2P = (ControlType *)GetObjectPtr(TabGameOptionsStartRoomCheckbox); + cck3P = (ControlType *)GetObjectPtr(TabGameOptionsAmigaCheckbox); + cck4P = (ControlType *)GetObjectPtr(TabGameOptionsSubtitlesCheckbox); + cck5P = (ControlType *)GetObjectPtr(TabGameOptionsTalkSpeedCheckbox); + + if (!gameInfoP) { + if (FldGetTextLength(fld5P) == 0 && CtlGetValue(cck2P) == 1) { + FrmCustomAlert(FrmWarnAlert,"You must specify a room number.",0,0); + TabSetActive(frmP, myTabP, 2); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameOptionsStartRoomField)); + return errBadParam; + + } else if (FldGetTextLength(fld6P) == 0 && CtlGetValue(cck5P) == 1) { + FrmCustomAlert(FrmWarnAlert,"You must specify a talk speed.",0,0); + TabSetActive(frmP, myTabP, 2); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameOptionsTalkSpeedField)); + return errBadParam; + } + } else { + gameInfoP->language = LstGetSelection(list2P); + gameInfoP->platform = LstGetSelection(list3P); + + gameInfoP->autoLoad = CtlGetValue(cck1P); + gameInfoP->bootParam = CtlGetValue(cck2P); + gameInfoP->setPlatform = CtlGetValue(cck3P); + gameInfoP->subtitles = (CtlGetValue(cck4P)); + gameInfoP->talkSpeed = CtlGetValue(cck5P); + + gameInfoP->loadSlot = StrAToI(FldGetTextPtr(fld4P)); + gameInfoP->bootValue = StrAToI(FldGetTextPtr(fld5P)); + gameInfoP->talkValue = StrAToI(FldGetTextPtr(fld6P)); + } + + return errNone; +} + +static void GameManInit(UInt16 index) { + TabType *tabP; + FormType *frmP = FrmGetActiveForm(); + UInt16 active = lastTab; + + tabP = TabNewTabs(3); + TabAddContent(&frmP, tabP, "Game", TabGameInfoForm); + TabAddContent(&frmP, tabP, "Display", TabGameDisplayForm); + TabAddContent(&frmP, tabP, "Options", TabGameOptionsForm); + + UInt16 refNum; + if (SysLibFind(kFileBrowserLibName, &refNum)) + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabGameInfoBrowsePushButton)); + + if (index != dmMaxRecordIndex) { + MemHandle recordH = NULL; + GameInfoType *gameInfoP; + + recordH = DmQueryRecord(gameDB, index); + gameInfoP = (GameInfoType *)MemHandleLock(recordH); + + GameTabInit(gameInfoP); + DisplayInit(gameInfoP); + OptionsInit(gameInfoP); + + MemHandleUnlock(recordH); + CtlSetUsable((ControlType *)GetObjectPtr(GameEditDeleteButton),true); + } else { + active = 0; // new game ? start with first tab + GameTabInit(0); + DisplayInit(0); + OptionsInit(0); + CtlSetUsable((ControlType *)GetObjectPtr(GameEditDeleteButton),false); + } + + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabGameInfoEntryNameField)); + FrmDrawForm(frmP); + TabSetActive(frmP, tabP, active); + + myTabP = tabP; +} + +static void GameManSave(UInt16 index) { + MemHandle recordH; + GameInfoType *gameInfoP, newGameInfo; + + if (GameTabSave(0) == errBadParam) return; + if (DisplaySave(0) == errBadParam) return; + if (OptionsSave(0) == errBadParam) return; + + if (index != dmMaxRecordIndex) { + recordH = DmGetRecord(gameDB, index); + gameInfoP = (GameInfoType *)MemHandleLock(recordH); + MemMove(&newGameInfo, gameInfoP, sizeof(GameInfoType)); + + } else { + index = dmMaxRecordIndex; + GamUnselect(); + recordH = DmNewRecord(gameDB, &index, sizeof(GameInfoType)); + gameInfoP = (GameInfoType *)MemHandleLock(recordH); + + MemSet(&newGameInfo, sizeof(GameInfoType), 0); + newGameInfo.version = curItemVersion; + newGameInfo.icnID = 0xFFFF; + newGameInfo.selected = true; + + // default sound data + newGameInfo.musicInfo.volume.palm = 50; + newGameInfo.musicInfo.volume.music = 192; + newGameInfo.musicInfo.volume.sfx = 192; + newGameInfo.musicInfo.volume.speech = 192; + newGameInfo.musicInfo.volume.audiocd = 50; + + newGameInfo.musicInfo.sound.tempo = 100; + newGameInfo.musicInfo.sound.defaultTrackLength = 10; + newGameInfo.musicInfo.sound.firstTrack = 1; + } + + GameTabSave(&newGameInfo); + DisplaySave(&newGameInfo); + OptionsSave(&newGameInfo); + + DmWrite(gameInfoP, 0, &newGameInfo, sizeof(GameInfoType)); + + MemHandleUnlock(recordH); + DmReleaseRecord (gameDB, index, 0); + GamSortList(); + // update list position + { + RectangleType rArea; + UInt16 posIndex, 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; + + // if out of the current list position + if (!(index >= posIndex && index < (posIndex + maxView))) + gPrefs->listPosition = index; // this value is corrected in SknUpdateList if needed + } + + TabDeleteTabs(myTabP); + FrmReturnToMain(); + SknUpdateList(); +} + +/*********************************************************************** + * + * FUNCTION: EditGameFormSave + * FUNCTION: EditGameFormInit + * FUNCTION: EditGameFormHandleEvent + * + * DESCRIPTION: + * + * REVISION HISTORY: + * + * + ***********************************************************************/ +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) { + TabDeleteTabs(myTabP); + FrmReturnToMain(); + } + GamSortList(); + SknUpdateList(); + } +} + +static void EditGameCancel() { + if (itemsText) { + MemPtrFree(itemsText); + itemsText = NULL; + } + TabDeleteTabs(myTabP); + FrmReturnToMain(); +} + +static void EditGameBowser() { + UInt16 refNum; + Err e; + + ControlPtr butP = (ControlType *)GetObjectPtr(TabGameInfoBrowsePushButton); + CtlSetValue(butP, 0); + + e = SysLibFind (kFileBrowserLibName, &refNum); + if (!e) { + e = FileBrowserLibOpen (refNum); + if (!e) { + UInt16 volRefNum = gPrefs->card.volRefNum; + Char *textP, *pathP = (Char *)MemPtrNew(kFileBrowserLibPathBufferSize); + pathP[0] = chrNull; + + if (FileBrowserLibShowOpenDialog(refNum, &volRefNum, pathP, 0, 0, 0, "Game Data Path", kFileBrowserLibFlagNoFiles)) { + FieldPtr fldP; + MemHandle textH; + Int16 offset, copySize, maxSize; + + fldP = (FieldType *)GetObjectPtr(TabGameInfoPathField); + maxSize = FldGetMaxChars(fldP); + textH = FldGetTextHandle(fldP); + + FldSetTextHandle(fldP, NULL); + textP = (Char *)MemHandleLock(textH); + offset = 0; + copySize = StrLen(pathP); + + if (StrNCaselessCompare(pathP, "/Palm/Programs/ScummVM/Games/", 29) == 0) { + if (StrLen(pathP) == 29) { + copySize = 1; + pathP[0] = '.'; + } else { + copySize -= 29; + offset = 29; + } + } + + if (copySize > maxSize) + copySize = maxSize; + StrNCopy(textP, pathP + offset, copySize); + + MemHandleUnlock(textH); + FldSetTextHandle(fldP, textH); + FldDrawField(fldP); + FldGrabFocus(fldP); + } + + MemPtrFree(pathP); + FileBrowserLibClose(refNum); + } + } +} + +Boolean EditGameFormHandleEvent(EventPtr eventP) { + FormPtr frmP = FrmGetActiveForm(); + Boolean handled = false; + + switch (eventP->eType) { + case frmCloseEvent: + EditGameCancel(); + handled = true; + break; + + case frmOpenEvent: + switch (gFormEditMode) { + case edtModeAdd: + GameManInit(dmMaxRecordIndex); + break; + case edtModeEdit: + case edtModeParams: + default : + GameManInit(GamGetSelected()); + break; + } + handled = true; + break; + + case keyDownEvent: + switch (eventP->data.keyDown.chr) { + case chrLineFeed: + case chrCarriageReturn: + return true; + } + break; + + case ctlSelectEvent: + switch (eventP->data.ctlSelect.controlID) + { + case (GameEditForm + 1) : + case (GameEditForm + 2) : + case (GameEditForm + 3) : + lastTab = (eventP->data.ctlSelect.controlID - GameEditForm - 1); + TabSetActive(frmP, myTabP, lastTab); + break; + + case GameEditOKButton: + switch (gFormEditMode) { + case edtModeAdd: + GameManSave(dmMaxRecordIndex); + break; + case edtModeEdit: + case edtModeParams: + default : + GameManSave(GamGetSelected()); + break; + } + break; + + case GameEditCancelButton: + EditGameCancel(); + break; + + case GameEditDeleteButton: + EditGameFormDelete(false); + break; + + case TabGameInfoBrowsePushButton: + EditGameBowser(); + break; + + case TabGameInfoEnginePopTrigger: + FrmList(eventP, TabGameInfoEngineList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabGameInfoEngineList)); + break; + + case TabGameDisplayGfxPopupPopTrigger: + FrmList(eventP, TabGameDisplayGfxListList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabGameDisplayGfxListList)); + break; + + case TabGameDisplayRenderPopTrigger: + FrmList(eventP, TabGameDisplayRenderList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabGameDisplayRenderList)); + break; + + case TabGameOptionsLanguagePopTrigger: + FrmList(eventP, TabGameOptionsLanguageList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabGameOptionsLanguageList)); + break; + + case TabGameOptionsPlatformPopTrigger: + FrmList(eventP, TabGameOptionsPlatformList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabGameOptionsPlatformList)); + break; + } + handled = true; + break; + + default: + break; + } + + return handled; +} diff --git a/backends/PalmOS/Src/launcher/forms/formEditGame.h b/backends/PalmOS/Src/launcher/forms/formEditGame.h new file mode 100644 index 0000000000..2e76e7ebb5 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formEditGame.h @@ -0,0 +1,38 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#ifndef __FORMEDITGAME_H__ +#define __FORMEDITGAME_H__ + +// edit game mode +enum { + edtModeAdd, + edtModeEdit, + edtModeParams +}; + +extern UInt8 gFormEditMode; +void EditGameFormDelete(Boolean direct); + +#endif diff --git a/backends/PalmOS/Src/launcher/forms/formMisc.cpp b/backends/PalmOS/Src/launcher/forms/formMisc.cpp new file mode 100644 index 0000000000..afa566f49b --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formMisc.cpp @@ -0,0 +1,261 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include + +#include "start.h" +#include "formTabs.h" +#include "forms.h" +#include "globals.h" + +static TabType *myTabP; +static UInt16 lastTab = 0; + +static Boolean ScummVMTabSave() { + FieldType *fld1P, *fld2P; + ControlType *cckP[11]; + FormPtr frmP; + + fld1P = (FieldType *)GetObjectPtr(TabMiscScummVMDebugLevelField); + fld2P = (FieldType *)GetObjectPtr(TabMiscScummVMAutosaveField); + + cckP[0] = (ControlType *)GetObjectPtr(TabMiscScummVMAutosaveCheckbox); + cckP[3] = (ControlType *)GetObjectPtr(TabMiscScummVMDebugCheckbox); + cckP[6] = (ControlType *)GetObjectPtr(TabMiscScummVMDemoCheckbox); + cckP[9] = (ControlType *)GetObjectPtr(TabMiscScummVMCopyProtectionCheckbox); + cckP[10]= (ControlType *)GetObjectPtr(TabMiscScummVMAltIntroCheckbox); + + frmP = FrmGetActiveForm(); + if (FldGetTextLength(fld1P) == 0 && CtlGetValue(cckP[3]) == 1) { + TabSetActive(frmP, myTabP, 1); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabMiscScummVMDebugLevelField)); + FrmCustomAlert(FrmWarnAlert,"You must specify a debug level.",0,0); + return false; + + } else if (FldGetTextLength(fld2P) == 0 && CtlGetValue(cckP[0]) == 1) { + TabSetActive(frmP, myTabP, 1); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabMiscScummVMAutosaveField)); + FrmCustomAlert(FrmWarnAlert,"You must specify a period.",0,0); + return false; + } + + gPrefs->autoSave = CtlGetValue(cckP[0]); + gPrefs->debug = CtlGetValue(cckP[3]); + gPrefs->demoMode = CtlGetValue(cckP[6]); + gPrefs->copyProtection = CtlGetValue(cckP[9]); + gPrefs->altIntro = CtlGetValue(cckP[10]); + + gPrefs->debugLevel = StrAToI(FldGetTextPtr(fld1P)); + gPrefs->autoSavePeriod = StrAToI(FldGetTextPtr(fld2P)); + + return true; +} + +static void PalmOSTabSave() { + ControlType *cckP[11]; + + if (OPTIONS_TST(kOptDeviceARM) && !OPTIONS_TST(kOptDeviceZodiac)) { + cckP[3]= (ControlType *)GetObjectPtr(TabMiscPalmOSAdvancedCheckbox); + gPrefs->advancedMode = CtlGetValue(cckP[3]); + } + + cckP[0] = (ControlType *)GetObjectPtr(TabMiscPalmOSVibratorCheckbox); + cckP[1] = (ControlType *)GetObjectPtr(TabMiscPalmOSNoAutoOffCheckbox); + cckP[2] = (ControlType *)GetObjectPtr(TabMiscPalmOSStdPaletteCheckbox); + cckP[4] = (ControlType *)GetObjectPtr(TabMiscPalmOSLargerStackCheckbox); + cckP[5] = (ControlType *)GetObjectPtr(TabMiscPalmOSExitLauncherCheckbox); + cckP[6] = (ControlType *)GetObjectPtr(TabMiscPalmOSStylusClickCheckbox); + + gPrefs->vibrator = CtlGetValue(cckP[0]); + gPrefs->autoOff = !CtlGetValue(cckP[1]); + gPrefs->stdPalette = CtlGetValue(cckP[2]); + gPrefs->setStack = CtlGetValue(cckP[4]); + gPrefs->exitLauncher = CtlGetValue(cckP[5]); + gPrefs->stylusClick = !CtlGetValue(cckP[6]); +} + +static void ExtsTabSave() { + ControlType *cckP[2]; + + if (OPTIONS_TST(kOptLightspeedAPI)) { + ListType *list1P = (ListType *)GetObjectPtr(TabMiscExtsLightspeedList); + cckP[0] = (ControlType *)GetObjectPtr(TabMiscExtsLightspeedCheckbox); + + gPrefs->lightspeed.enable = CtlGetValue(cckP[0]); + gPrefs->lightspeed.mode = LstGetSelection(list1P); + } + if (OPTIONS_TST(kOptGoLcdAPI)) { + cckP[1] = (ControlType *)GetObjectPtr(TabMiscExtsGolcdCheckbox); + gPrefs->goLCD = CtlGetValue(cckP[1]); + } +} + +static void ScummVMTabInit() { + FieldType *fld1P, *fld2P; + Char *levelP, *periodP; + MemHandle levelH, periodH; + + CtlSetValue((ControlType *)GetObjectPtr(TabMiscScummVMAutosaveCheckbox), gPrefs->autoSave); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscScummVMDebugCheckbox), gPrefs->debug); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscScummVMDemoCheckbox), gPrefs->demoMode); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscScummVMCopyProtectionCheckbox), gPrefs->copyProtection); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscScummVMAltIntroCheckbox), gPrefs->altIntro); + + fld1P = (FieldType *)GetObjectPtr(TabMiscScummVMDebugLevelField); + fld2P = (FieldType *)GetObjectPtr(TabMiscScummVMAutosaveField); + + levelH = MemHandleNew(FldGetMaxChars(fld1P)+1); + levelP = (Char *)MemHandleLock(levelH); + StrIToA(levelP, gPrefs->debugLevel); + MemHandleUnlock(levelH); + + periodH = MemHandleNew(FldGetMaxChars(fld2P)+1); + periodP = (Char *)MemHandleLock(periodH); + StrIToA(periodP, gPrefs->autoSavePeriod); + MemHandleUnlock(periodH); + + FldSetTextHandle(fld1P, levelH); + FldSetTextHandle(fld2P, periodH); +} + +static void PalmOSTabInit() { + if (OPTIONS_TST(kOptDeviceARM) && !OPTIONS_TST(kOptDeviceZodiac)) + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSAdvancedCheckbox), gPrefs->advancedMode); + + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSExitLauncherCheckbox), gPrefs->exitLauncher); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSLargerStackCheckbox), gPrefs->setStack); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSVibratorCheckbox), gPrefs->vibrator); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSNoAutoOffCheckbox), !gPrefs->autoOff); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSStdPaletteCheckbox), gPrefs->stdPalette); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscPalmOSStylusClickCheckbox), !gPrefs->stylusClick); +} + +static void ExtsTabInit() { + if (OPTIONS_TST(kOptLightspeedAPI)) { + ListType *list1P = (ListType *)GetObjectPtr(TabMiscExtsLightspeedList); + LstSetSelection(list1P, gPrefs->lightspeed.mode); + CtlSetLabel((ControlType *)GetObjectPtr(TabMiscExtsLightspeedPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + CtlSetValue((ControlType *)GetObjectPtr(TabMiscExtsLightspeedCheckbox), gPrefs->lightspeed.enable); + } + + if (OPTIONS_TST(kOptGoLcdAPI)) + CtlSetValue((ControlType *)GetObjectPtr(TabMiscExtsGolcdCheckbox), gPrefs->goLCD); +} + +static void MiscFormSave() { + if (!ScummVMTabSave()) return; + PalmOSTabSave(); + ExtsTabSave(); + + TabDeleteTabs(myTabP); + FrmReturnToMain(); +} + +static void MiscFormInit() { + TabType *tabP; + FormType *frmP = FrmGetActiveForm(); + UInt8 extsCnt = 2; + + tabP = TabNewTabs(3); + TabAddContent(&frmP, tabP, "PalmOS", TabMiscPalmOSForm); + TabAddContent(&frmP, tabP, "ScummVM", TabMiscScummVMForm); + TabAddContent(&frmP, tabP, "More ...", TabMiscExtsForm); + + if (!OPTIONS_TST(kOptDeviceARM) || OPTIONS_TST(kOptDeviceZodiac)) { + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscPalmOSAdvancedCheckbox)); + } + if (!OPTIONS_TST(kOptGoLcdAPI)) { + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscExtsGolcdCheckbox)); + // move lightspeed + TabMoveUpObject(frmP, TabMiscExtsLightspeedCheckbox, 12); + TabMoveUpObject(frmP, TabMiscExtsLightspeedPopTrigger, 12); + TabMoveUpObject(frmP, TabMiscExtsLightspeedList, 12); + TabMoveUpObject(frmP, TabMiscExtsNothingLabel, 12); + extsCnt--; + } + + if (!OPTIONS_TST(kOptLightspeedAPI)) { + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscExtsLightspeedCheckbox)); +// FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscExtsLightspeedList)); // cannot remove this ? + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscExtsLightspeedPopTrigger)); + TabMoveUpObject(frmP, TabMiscExtsNothingLabel, 12); + extsCnt--; + } + + if (extsCnt) + FrmRemoveObject(&frmP, FrmGetObjectIndex(frmP, TabMiscExtsNothingLabel)); + + PalmOSTabInit(); + ScummVMTabInit(); + ExtsTabInit(); + + FrmDrawForm(frmP); + TabSetActive(frmP, tabP, lastTab); + + myTabP = tabP; +} + +Boolean MiscFormHandleEvent(EventPtr eventP) { + FormPtr frmP = FrmGetActiveForm(); + Boolean handled = false; + + switch (eventP->eType) { + case frmOpenEvent: + MiscFormInit(); + handled = true; + break; + + case ctlSelectEvent: + switch (eventP->data.ctlSelect.controlID) + { + case (MiscForm + 1) : + case (MiscForm + 2) : + case (MiscForm + 3) : + lastTab = (eventP->data.ctlSelect.controlID - MiscForm - 1); + TabSetActive(frmP, myTabP, lastTab); + break; + + case TabMiscExtsLightspeedPopTrigger: + FrmList(eventP, TabMiscExtsLightspeedList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabMiscExtsLightspeedList)); + break; + + case MiscOKButton: + MiscFormSave(); + break; + + case MiscCancelButton: + TabDeleteTabs(myTabP); + FrmReturnToMain(); + break; + } + handled = true; + break; + + default: + break; + } + + return handled; +} diff --git a/backends/PalmOS/Src/launcher/forms/formSkins.cpp b/backends/PalmOS/Src/launcher/forms/formSkins.cpp new file mode 100644 index 0000000000..b4c1e222d0 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formSkins.cpp @@ -0,0 +1,267 @@ +#include + +#include "palmdefs.h" +#include "start.h" +#include "forms.h" +#include "skin.h" +#include "globals.h" + +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; + +/* DmOpenRef skinDB = SknOpenSkin(); + UInt32 depth = SknGetDepth(skinDB); + SknCloseSkin(skinDB); + + if (depth != 8 && depth != 16) depth = 8; + + if (depth == 16 && !OPTIONS_TST(kOptMode16Bit)) { + FrmCustomAlert(FrmInfoAlert, "You can only use 8bit skin on your device.", 0, 0); + gPrefs->skin.cardNo = cardNo; + gPrefs->skin.dbID = 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); + } + } + +} +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; +} diff --git a/backends/PalmOS/Src/launcher/forms/formUtil.cpp b/backends/PalmOS/Src/launcher/forms/formUtil.cpp new file mode 100644 index 0000000000..6d1d55e6e2 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formUtil.cpp @@ -0,0 +1,60 @@ +#include +#include + +#include "forms.h" + +Char **itemsText = NULL; +void *itemsList = NULL; +Char itemsType = ITEM_TYPE_UNKNOWN; + +void FrmReturnToMain(UInt16 updateCode) { + // if there is a form loaded, prevent crash on OS5 + if (FrmGetFirstForm()) { + FrmUpdateForm(MainForm, updateCode); + FrmReturnToForm(MainForm); + } +} + +void FldTrimText(FieldPtr 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: 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: + * + * + ***********************************************************************/ +void * GetObjectPtr(UInt16 objectID) { + FormPtr frmP; + + frmP = FrmGetActiveForm(); + return FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, objectID)); +} + +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))); +} + diff --git a/backends/PalmOS/Src/launcher/forms/formUtil.h b/backends/PalmOS/Src/launcher/forms/formUtil.h new file mode 100644 index 0000000000..90cf1ff37a --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formUtil.h @@ -0,0 +1,21 @@ +#ifndef __FORMUTIL_H__ +#define __FORMUTIL_H__ + +#define frmRedrawUpdateMS (frmRedrawUpdateCode + 1) +#define frmRedrawUpdateMSImport (frmRedrawUpdateCode + 2) + +// form list draw +#define ITEM_TYPE_UNKNOWN 'U' +#define ITEM_TYPE_CARD 'C' +#define ITEM_TYPE_SKIN 'S' + +extern Char **itemsText; +extern void *itemsList; +extern Char itemsType; + +void FrmReturnToMain(UInt16 updateCode = frmRedrawUpdateMS); +void * GetObjectPtr(UInt16 objectID); +void FldTrimText(FieldPtr fldP); +void FrmList(EventPtr eventP, UInt16 objectID); + +#endif diff --git a/backends/PalmOS/Src/launcher/forms/forminfo.cpp b/backends/PalmOS/Src/launcher/forms/forminfo.cpp new file mode 100644 index 0000000000..74622d8f14 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/forminfo.cpp @@ -0,0 +1,146 @@ +#include + +#include "start.h" +#include "formTabs.h" +#include "forms.h" + +#include "base/version.h" +#include "globals.h" +#include "init_palmos.h" + +/*********************************************************************** + * + * FUNCTION: MiscOptionsFormSave + * FUNCTION: MiscOptionsFormInit + * FUNCTION: MiscOptionsFormHandleEvent + * + * DESCRIPTION: Misc. Options form functions + * + * REVISION HISTORY: + * + * + ***********************************************************************/ +static TabType *myTabP; +static UInt16 lastTab = 0; + +static UInt32 GetStackSize() { + MemPtr startPP, endPP; + SysGetStackInfo(&startPP, &endPP); + + return ((Char *)endPP - (Char *)startPP) / 1024L; +} + +static void VersionTabDraw() { + WinDrawChars(gScummVMVersion, StrLen(gScummVMVersion), 47, 12 + 30); + WinDrawChars(gScummVMBuildDate, StrLen(gScummVMBuildDate), 47, 24 + 30); +} + +static void SystemTabDraw() { + Coord x; + UInt32 dm, sm, df, sf, stack; + Char num[10]; + + PalmGetMemory(&sm, &dm, &sf, 0); + stack = GetStackSize(); + df = gVars->startupMemory; + + WinSetTextColor(UIColorGetTableEntryIndex(UIObjectForeground)); + FntSetFont(stdFont); + + StrIToA(num, dm); + x = 147 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 12 + 30); + + StrIToA(num, sm); + x = 147 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 24 + 30); + + StrIToA(num, stack); + x = 147 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 36 + 30); + + StrIToA(num, df); + x = 107 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 12 + 30); + + StrIToA(num, sf); + x = 107 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 24 + 30); + + StrCopy(num,"-"); + x = 107 - FntCharsWidth(num, StrLen(num)) + 5; + WinDrawChars(num, StrLen(num), x, 36 + 30); +} + +static void InfoFormSave() { + TabDeleteTabs(myTabP); + FrmReturnToMain(); +} + +static void AboutTabDraw() { + MemHandle hTemp; + BitmapPtr bmpTemp; + + hTemp = DmGetResource (bitmapRsc, 1200); + if (hTemp) { + bmpTemp = (BitmapType *)MemHandleLock(hTemp); + WinDrawBitmap(bmpTemp,3,44); + MemPtrUnlock(bmpTemp); + DmReleaseResource(hTemp); + } +} + +static void InfoFormInit() { + TabType *tabP; + FormType *frmP = FrmGetActiveForm(); + + tabP = TabNewTabs(3); + TabAddContent(&frmP, tabP, "About", TabInfoAboutForm, AboutTabDraw); + TabAddContent(&frmP, tabP, "Version", TabInfoVersionForm, VersionTabDraw); + TabAddContent(&frmP, tabP, "Memory", TabInfoSystemForm, SystemTabDraw); + + lastTab = 0; + FrmDrawForm(frmP); + TabSetActive(frmP, tabP, lastTab); + + myTabP = tabP; +} + +Boolean InfoFormHandleEvent(EventPtr eventP) { + FormPtr frmP = FrmGetActiveForm(); + Boolean handled = false; + + switch (eventP->eType) { + case frmOpenEvent: + InfoFormInit(); + handled = true; + break; + + case frmCloseEvent: + InfoFormSave(); + handled = true; + break; + + case ctlSelectEvent: + switch (eventP->data.ctlSelect.controlID) + { + case (InfoForm + 1) : + case (InfoForm + 2) : + case (InfoForm + 3) : + lastTab = (eventP->data.ctlSelect.controlID - InfoForm - 1); + TabSetActive(frmP, myTabP, lastTab); + break; + + case InfoOKButton: + InfoFormSave(); + break; + } + handled = true; + break; + + default: + break; + } + + return handled; +} diff --git a/backends/PalmOS/Src/launcher/forms/formmain.cpp b/backends/PalmOS/Src/launcher/forms/formmain.cpp new file mode 100644 index 0000000000..1709b4c7a2 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formmain.cpp @@ -0,0 +1,363 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include + +#include "StarterRsc.h" +#include "start.h" +#include "skin.h" +#include "games.h" +#include "scumm_globals.h" +#include "globals.h" + +#include "common/stdafx.h" +#include "base/version.h" + +#include "formEditGame.h" +#include "formUtil.h" + +static UInt16 sknLastOn = skinButtonNone; + +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: 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 Boolean MainFormDoCommand(UInt16 command) +{ + Boolean handled = false; + + switch (command) { + case MainGamesMemoryCard: + FrmPopupForm(CardSlotForm); + handled = true; + break; + + case MainGamesNew: + gFormEditMode = edtModeAdd; + FrmPopupForm(GameEditForm); + handled = true; + break; + + case MainGamesEdit: + gFormEditMode = edtModeEdit; + FrmPopupForm(GameEditForm); + handled = true; + break; + + case MainGamesDelete: + EditGameFormDelete(true); + handled = true; + break; + + case MainOptionsBeam: + BeamMe(); + //if (BeamMe()) + //FrmCustomAlert(FrmErrorAlert,"Unable to beam ScummVM for PalmOS.",0,0); + handled = true; + break; + + case MainOptionsAbout: + FrmPopupForm(InfoForm); + handled = true; + break; + + case MainGamesMusicSound: + FrmPopupForm(MusicForm); + handled = true; + break; + + case MainOptionsSkins: + FrmPopupForm(SkinsForm); + handled = true; + break; + + case MainOptionsMisc: + FrmPopupForm(MiscForm); + handled = true; + break; + } + + MenuEraseStatus(0); + return handled; +} + +/*********************************************************************** + * + * 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; +} + + +Boolean MainFormHandleEvent(EventPtr eventP) +{ + Boolean handled = false; + FormPtr frmP; + Coord x,y; + DmOpenRef skinDBP; + + switch (eventP->eType) { + case frmUpdateEvent: + { + RectangleType r; + UInt16 idx; + IndexedColorType bgColor = UIColorGetTableEntryIndex(UIFormFill); + frmP = FrmGetFormPtr(MainForm); + + if (gPrefs->card.volRefNum != vfsInvalidVolRef) + idx = FrmGetObjectIndex (frmP, MainMSBitMap); + else + idx = FrmGetObjectIndex (frmP, MainMSNoneBitMap); + + WinSetDrawMode(winPaint); + WinSetBackColor(bgColor); + FrmGetObjectBounds(frmP, idx, &r); + WinEraseRectangle(&r, 0); + FrmShowObject(frmP, idx); + + if (eventP->data.frmUpdate.updateCode == frmRedrawUpdateMSImport) { + GamImportDatabase(); + SknUpdateList(); + } + handled = true; + 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: + FrmPopupForm(InfoForm); + 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: + gFormEditMode = edtModeAdd; + FrmPopupForm(GameEditForm); + handled = true; + break; + + case skinButtonGameAudio: + FrmPopupForm(MusicForm); + handled = true; + break; + + case skinButtonGameEdit: + case skinButtonGameParams: + gFormEditMode = edtModeParams; + FrmPopupForm(GameEditForm); + handled = true; + break; + + case skinButtonGameStart: + if (gPrefs->card.volRefNum == vfsInvalidVolRef) + 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: + case skinButtonGameAudio: + 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; + + case keyDownEvent: + if ( (eventP->data.keyDown.chr >= 'a' && eventP->data.keyDown.chr <= 'z') || + (eventP->data.keyDown.chr >= 'A' && eventP->data.keyDown.chr <= 'Z')) { + if (GamJumpTo(eventP->data.keyDown.chr)) { + SknUpdateList(); + handled = true; + } + } + break; + + default: + handled = PenDownRepeat(); + } + + return handled; +} diff --git a/backends/PalmOS/Src/launcher/forms/formmusic.cpp b/backends/PalmOS/Src/launcher/forms/formmusic.cpp new file mode 100644 index 0000000000..9b4b5355a7 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formmusic.cpp @@ -0,0 +1,387 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2001 Ludvig Strigeus + * Copyright (C) 2001-2006 The ScummVM project + * Copyright (C) 2002-2006 Chris Apers - PalmOS Backend + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include + +#include "start.h" +#include "formTabs.h" +#include "forms.h" +#include "games.h" + +#include "globals.h" + +static TabType *myTabP; +static UInt16 lastTab = 0; + +static GameInfoType *gameInfoP = NULL; + +// Music +static Boolean MusicTabSave() { + ControlType *cck1P, *cck2P; + ListType *list1P, *list2P, *list3P; + FieldType *fld1P; + UInt16 tempo; + FormPtr frmP; + + frmP = FrmGetActiveForm(); + + cck1P = (ControlType *)GetObjectPtr(TabMusicMusicCheckbox); + cck2P = (ControlType *)GetObjectPtr(TabMusicMultiMidiCheckbox); + + list1P = (ListType *)GetObjectPtr(TabMusicDriverList); + list2P = (ListType *)GetObjectPtr(TabMusicRateList); + list3P = (ListType *)GetObjectPtr(TabMusicQualityList); + + fld1P = (FieldType *)GetObjectPtr(TabMusicTempoField); + + tempo = StrAToI(FldGetTextPtr(fld1P)); + if (tempo < 50 || tempo > 200) { + TabSetActive(frmP, myTabP, 0); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabMusicTempoField)); + FrmCustomAlert(FrmErrorAlert, "Invalid tempo value (50...200)", 0, 0); + return false; + } + + gameInfoP->musicInfo.sound.music = CtlGetValue(cck1P); + gameInfoP->musicInfo.sound.multiMidi = CtlGetValue(cck2P); + + gameInfoP->musicInfo.sound.drvMusic = LstGetSelection(list1P); + gameInfoP->musicInfo.sound.rate = LstGetSelection(list2P); + gameInfoP->fmQuality = LstGetSelection(list3P); + gameInfoP->musicInfo.sound.tempo = tempo; + + return true; +} + +static void MusicTabInit() { + ControlType *cck1P, *cck2P; + ListType *list1P, *list2P, *list3P; + FieldType *fld1P; + MemHandle tempoH; + Char *tempoP; + + cck1P = (ControlType *)GetObjectPtr(TabMusicMusicCheckbox); + cck2P = (ControlType *)GetObjectPtr(TabMusicMultiMidiCheckbox); + + list1P = (ListType *)GetObjectPtr(TabMusicDriverList); + list2P = (ListType *)GetObjectPtr(TabMusicRateList); + list3P = (ListType *)GetObjectPtr(TabMusicQualityList); + + fld1P = (FieldType *)GetObjectPtr(TabMusicTempoField); + + CtlSetValue(cck1P, gameInfoP->musicInfo.sound.music); + CtlSetValue(cck2P, gameInfoP->musicInfo.sound.multiMidi); + + if (gameInfoP->musicInfo.sound.drvMusic > 5) + gameInfoP->musicInfo.sound.drvMusic = 0; + + + LstSetSelection(list1P, gameInfoP->musicInfo.sound.drvMusic); + LstSetTopItem(list1P, gameInfoP->musicInfo.sound.drvMusic); + CtlSetLabel((ControlType *)GetObjectPtr(TabMusicDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + + LstSetSelection(list2P, gameInfoP->musicInfo.sound.rate); + LstSetTopItem(list2P, gameInfoP->musicInfo.sound.rate); + CtlSetLabel((ControlType *)GetObjectPtr(TabMusicRatePopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P))); + + LstSetSelection(list3P, gameInfoP->fmQuality); + CtlSetLabel((ControlType *)GetObjectPtr(TabMusicQualityPopTrigger), LstGetSelectionText(list3P, LstGetSelection(list3P))); + + tempoH = MemHandleNew(FldGetMaxChars(fld1P)+1); + tempoP = (Char *)MemHandleLock(tempoH); + StrIToA(tempoP, gameInfoP->musicInfo.sound.tempo); + MemHandleUnlock(tempoH); + FldSetTextHandle(fld1P, tempoH); +} + +// Audio CD +static Boolean AudioCDTabSave() { + ControlType *cck3P; + FieldType *fld2P, *fld3P; + ListType *list1P, *list2P; + UInt16 firstTrack; + FormPtr frmP; + + frmP = FrmGetActiveForm(); + + cck3P = (ControlType *)GetObjectPtr(TabAudioCDMP3Checkbox); + fld2P = (FieldType *)GetObjectPtr(TabAudioCDLengthSecsField); + fld3P = (FieldType *)GetObjectPtr(TabAudioCDFirstTrackField); + list1P = (ListType *)GetObjectPtr(TabAudioCDDriverList); + list2P = (ListType *)GetObjectPtr(TabAudioCDFormatList); + + firstTrack = StrAToI(FldGetTextPtr(fld3P)); + if (firstTrack < 1 || firstTrack > 999) { + TabSetActive(frmP, myTabP, 2); + FrmSetFocus(frmP, FrmGetObjectIndex(frmP, TabAudioCDFirstTrackField)); + FrmCustomAlert(FrmErrorAlert, "Invalid track value (1...999)", 0, 0); + return false; + } + + gameInfoP->musicInfo.sound.CD = CtlGetValue(cck3P); + + gameInfoP->musicInfo.sound.drvCD = LstGetSelection(list1P); + gameInfoP->musicInfo.sound.frtCD = LstGetSelection(list2P); + + gameInfoP->musicInfo.sound.defaultTrackLength = StrAToI(FldGetTextPtr(fld2P)); + gameInfoP->musicInfo.sound.firstTrack = firstTrack; + + return true; +} + +static void AudioCDTabInit() { + ControlType *cck3P; + FieldType *fld2P, *fld3P; + ListType *list1P, *list2P; + MemHandle lengthH, firstTrackH; + Char *lengthP, *firstTrackP; + + cck3P = (ControlType *)GetObjectPtr(TabAudioCDMP3Checkbox); + fld2P = (FieldType *)GetObjectPtr(TabAudioCDLengthSecsField); + fld3P = (FieldType *)GetObjectPtr(TabAudioCDFirstTrackField); + list1P = (ListType *)GetObjectPtr(TabAudioCDDriverList); + list2P = (ListType *)GetObjectPtr(TabAudioCDFormatList); + + LstSetSelection(list1P, gameInfoP->musicInfo.sound.drvCD); + CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + + LstSetSelection(list2P, gameInfoP->musicInfo.sound.frtCD); + CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDFormatPopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P))); + + CtlSetValue(cck3P, gameInfoP->musicInfo.sound.CD); + + lengthH = MemHandleNew(FldGetMaxChars(fld2P)+1); + lengthP = (Char *)MemHandleLock(lengthH); + StrIToA(lengthP, gameInfoP->musicInfo.sound.defaultTrackLength); + MemHandleUnlock(lengthH); + FldSetTextHandle(fld2P, lengthH); + + firstTrackH = MemHandleNew(FldGetMaxChars(fld3P)+1); + firstTrackP = (Char *)MemHandleLock(firstTrackH); + StrIToA(firstTrackP, gameInfoP->musicInfo.sound.firstTrack); + MemHandleUnlock(firstTrackH); + FldSetTextHandle(fld3P, firstTrackH); +} + +// Volume +static void VolumeTabSave() { + SliderControlType *slid1P, *slid2P, *slid3P, *slid4P, *slid5P; + + slid1P = (SliderControlType *)GetObjectPtr(TabVolumePalmSliderControl); + slid2P = (SliderControlType *)GetObjectPtr(TabVolumeMusicSliderControl); + slid3P = (SliderControlType *)GetObjectPtr(TabVolumeSfxSliderControl); + slid4P = (SliderControlType *)GetObjectPtr(TabVolumeSpeechSliderControl); + slid5P = (SliderControlType *)GetObjectPtr(TabVolumeAudioCDSliderControl); + + CtlGetSliderValues ((ControlType *)slid1P, 0, 0, 0, &gameInfoP->musicInfo.volume.palm); + CtlGetSliderValues ((ControlType *)slid2P, 0, 0, 0, &gameInfoP->musicInfo.volume.music); + CtlGetSliderValues ((ControlType *)slid3P, 0, 0, 0, &gameInfoP->musicInfo.volume.sfx); + CtlGetSliderValues ((ControlType *)slid4P, 0, 0, 0, &gameInfoP->musicInfo.volume.speech); + CtlGetSliderValues ((ControlType *)slid5P, 0, 0, 0, &gameInfoP->musicInfo.volume.audiocd); +} + +static void VolumeTabInit() { + SliderControlType *slid1P, *slid2P, *slid3P, *slid4P, *slid5P; + UInt16 value; + + slid1P = (SliderControlType *)GetObjectPtr(TabVolumePalmSliderControl); + slid2P = (SliderControlType *)GetObjectPtr(TabVolumeMusicSliderControl); + slid3P = (SliderControlType *)GetObjectPtr(TabVolumeSfxSliderControl); + slid4P = (SliderControlType *)GetObjectPtr(TabVolumeSpeechSliderControl); + slid5P = (SliderControlType *)GetObjectPtr(TabVolumeAudioCDSliderControl); + + value = gameInfoP->musicInfo.volume.palm; + CtlSetSliderValues ((ControlType *)slid1P, 0, 0, 0, &value); + value = gameInfoP->musicInfo.volume.music; + CtlSetSliderValues ((ControlType *)slid2P, 0, 0, 0, &value); + value = gameInfoP->musicInfo.volume.sfx; + CtlSetSliderValues ((ControlType *)slid3P, 0, 0, 0, &value); + value = gameInfoP->musicInfo.volume.speech; + CtlSetSliderValues ((ControlType *)slid4P, 0, 0, 0, &value); + value = gameInfoP->musicInfo.volume.audiocd; + CtlSetSliderValues ((ControlType *)slid5P, 0, 0, 0, &value); +} + +static void MusicFormSave(UInt16 index) { + if (index != dmMaxRecordIndex) { + MemHandle recordH; + GameInfoType *ogameInfoP; + + if (!MusicTabSave()) return; + if (!AudioCDTabSave()) return; + VolumeTabSave(); + + recordH = DmGetRecord(gameDB, index); + ogameInfoP = (GameInfoType *)MemHandleLock(recordH); + DmWrite(ogameInfoP, 0, gameInfoP, sizeof(GameInfoType)); + MemHandleUnlock(recordH); + DmReleaseRecord (gameDB, index, 0); + } + + MemPtrFree(gameInfoP); + gameInfoP = NULL; + + TabDeleteTabs(myTabP); + FrmReturnToMain(); +} +static void MusicFormInit(UInt16 index) { + TabType *tabP; + FormType *frmP = FrmGetActiveForm(); + + if (index != dmMaxRecordIndex) { + MemHandle recordH = NULL; + GameInfoType *ogameInfoP; + + recordH = DmQueryRecord(gameDB, index); + ogameInfoP = (GameInfoType *)MemHandleLock(recordH); + + if (!ogameInfoP) { + FrmCustomAlert(FrmErrorAlert, "An error occured.",0,0); + return; + } + + gameInfoP = (GameInfoType *)MemPtrNew(sizeof(GameInfoType)); + MemMove(gameInfoP, ogameInfoP, sizeof(GameInfoType)); + MemHandleUnlock(recordH); + + } else { + FrmCustomAlert(FrmWarnAlert, "Select an entry first.",0,0); + FrmReturnToMain(); + return; + } + + tabP = TabNewTabs(3); + TabAddContent(&frmP, tabP, "Sound", TabMusicForm); + TabAddContent(&frmP, tabP, "Volume", TabVolumeForm); + TabAddContent(&frmP, tabP, "Audio CD", TabAudioCDForm); + + MusicTabInit(); + AudioCDTabInit(); + VolumeTabInit(); + + FrmDrawForm(frmP); + TabSetActive(frmP, tabP, lastTab); + + myTabP = tabP; +} + +Boolean MusicFormHandleEvent(EventPtr eventP) { + FormPtr frmP = FrmGetActiveForm(); + Boolean handled = false; + + switch (eventP->eType) { + case frmOpenEvent: + MusicFormInit(GamGetSelected()); + handled = true; + break; + + case frmCloseEvent: + MusicFormSave(dmMaxRecordIndex); + handled = true; + break; + + case ctlSelectEvent: + switch (eventP->data.ctlSelect.controlID) + { + case (MusicForm + 1) : + case (MusicForm + 2) : + case (MusicForm + 3) : + lastTab = (eventP->data.ctlSelect.controlID - MusicForm - 1); + TabSetActive(frmP, myTabP, lastTab); + break; + + case TabMusicDriverPopTrigger: + FrmList(eventP, TabMusicDriverList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabMusicDriverList)); + + if (!OPTIONS_TST(kOptDeviceZodiac) && !OPTIONS_TST(kOptSonyPa1LibAPI)) { + ListType *list1P = (ListType *)GetObjectPtr(TabMusicDriverList); + + if (LstGetSelection(list1P) == 4) { + FrmCustomAlert(FrmInfoAlert, "There is no built-in MIDI support on your device.", 0, 0); + LstSetSelection(list1P, 0); + CtlSetLabel((ControlType *)GetObjectPtr(TabMusicDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + } + } + break; + + case TabMusicQualityPopTrigger: + FrmList(eventP, TabMusicQualityList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabMusicQualityList)); + break; + + case TabMusicRatePopTrigger: + FrmList(eventP, TabMusicRateList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabMusicRateList)); + + if (!OPTIONS_TST(kOptPalmSoundAPI)) { + ListType *list1P = (ListType *)GetObjectPtr(TabMusicRateList); + + if (LstGetSelection(list1P) != 0) { + FrmCustomAlert(FrmInfoAlert, "You cannot use this rate on your device.", 0, 0); + LstSetSelection(list1P, 0); + CtlSetLabel((ControlType *)GetObjectPtr(TabMusicRatePopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + } + } + break; + + case TabAudioCDFormatPopTrigger: + FrmList(eventP, TabAudioCDFormatList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabAudioCDFormatList)); + + if (LstGetSelection((ListPtr)GetObjectPtr(TabAudioCDDriverList)) == 1) { + ListType *list1P = (ListType *)GetObjectPtr(TabAudioCDFormatList); + LstSetSelection(list1P, 0); + CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDFormatPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + } + break; + + case TabAudioCDDriverPopTrigger: + FrmList(eventP, TabAudioCDDriverList); + FrmHideObject(frmP, FrmGetObjectIndex(frmP, TabAudioCDDriverList)); + + if (LstGetSelection((ListPtr)GetObjectPtr(TabAudioCDDriverList)) == 1) { + ListType *list1P = (ListType *)GetObjectPtr(TabAudioCDFormatList); + LstSetSelection(list1P, 0); + CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDFormatPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P))); + } + break; + + case MusicOKButton: + MusicFormSave(GamGetSelected()); + break; + + case MusicCancelButton: + MusicFormSave(dmMaxRecordIndex); + break; + } + handled = true; + break; + + default: + break; + } + + return handled; +} diff --git a/backends/PalmOS/Src/launcher/forms/forms.h b/backends/PalmOS/Src/launcher/forms/forms.h new file mode 100644 index 0000000000..0bdfd356c7 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/forms.h @@ -0,0 +1,22 @@ +#ifndef __FORMS_H__ +#define __FORMS_H__ + +#include "StarterRsc.h" +#include "formUtil.h" + +#include "formEditGame.h" +#include "formCards.h" + + +#define HANDLER(x) Boolean x##FormHandleEvent(EventPtr eventP); + +HANDLER(Main) +HANDLER(EditGame) +HANDLER(SystemInfo) +HANDLER(Misc) +HANDLER(CardSlot) +HANDLER(Skins) +HANDLER(Music) +HANDLER(Info) + +#endif diff --git a/backends/PalmOS/Src/launcher/forms/formtabs.cpp b/backends/PalmOS/Src/launcher/forms/formtabs.cpp new file mode 100644 index 0000000000..0dd3427c1a --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formtabs.cpp @@ -0,0 +1,242 @@ +#include +#include +#include +#include + +#include "globals.h" +#include "formTabs.h" + +TabType *TabNewTabs(UInt16 cnt) { + TabType *newP = new TabType; + + newP->count = 0; + newP->width = 0; + newP->tabs = new TabDataType[cnt]; + + return newP; +} + +void TabMoveUpObject(FormType *frmP, UInt16 objID, Coord amount) { + Coord x, y; + FrmGetObjectPosition(frmP, FrmGetObjectIndex(frmP, objID), &x, &y); + FrmSetObjectPosition(frmP, FrmGetObjectIndex(frmP, objID), x, y - amount); +} + +void TabDeleteTabs(TabType *tabP) { + UInt16 cnt, num; + num = MemPtrSize(tabP->tabs) / sizeof(TabDataType); + + for (cnt = 0; cnt < num; cnt++) + FrmDeleteForm(tabP->tabs[cnt].srcP); + + delete tabP->tabs; + delete tabP; +} + +Err TabAddContent(FormType **frmP, TabType *tabP, const Char *nameP, UInt16 rscID, TabProc *drawFunc) { + FormType *srcP; + UInt16 cnt; + void *objP, **dstP; + UInt16 objNum; + Coord x, y, w, h; + UInt16 id; + RectangleType r; + + dstP = (void **)frmP; + srcP = FrmInitForm(rscID); + + objNum = FrmGetNumberOfObjects(srcP); + + // save tab data + + // it's required to keep to source forms active + // while the tab form is not close for list data ptr (items text) + // TODO : fix this ! + tabP->tabs[tabP->count].srcP = srcP; + tabP->tabs[tabP->count].first = FrmGetObjectId(srcP, 0); + tabP->tabs[tabP->count].last = FrmGetObjectId(srcP, objNum - 1); + tabP->tabs[tabP->count].drawFunc= drawFunc; + tabP->count++; + tabP->active = tabP->count; + + // create tab + FntSetFont(stdFont); + x = 4 + tabP->width; + y = 16; + w = FntCharsWidth(nameP, StrLen(nameP)) + 6; + h = 12; + ControlType *addP = CtlNewControl(dstP, (FrmGetFormId(*frmP) + tabP->count), buttonCtl, nameP, x, y, w, h, stdFont, 0, true); + CtlGlueSetFrameStyle(addP, noButtonFrame); + tabP->width += w + 3; + + // create tab content + for (cnt = 0; cnt < objNum; cnt++) { + objP = FrmGetObjectPtr(srcP, cnt); + id = FrmGetObjectId(srcP, cnt); + FrmGetObjectBounds(srcP, cnt, &r); + x = r.topLeft.x - 2; + y = r.topLeft.y + 30; + w = r.extent.x; + h = r.extent.y; + + FrmSetObjectPosition(srcP, cnt, x, y); + + switch (FrmGetObjectType(srcP, cnt)) { + case frmListObj: { + // HOWTO : to auto link the list to a popup trigger the listID must be popupID + 1 if popup id + // desn't exist the triggerID will be 0 and the list will be shown, but take care to not define + // ListID - 1 object if you want to show the list. + ListType *newP; + Char **itemsP = LstGlueGetItemsText((ListType *)objP); + FontID font = LstGlueGetFont((ListType *)objP); + UInt16 visible = LstGetVisibleItems((ListType *)objP); + UInt16 items = LstGetNumberOfItems((ListType *)objP); + UInt16 trigger = id - 1; + trigger = (FrmGetObjectIndex((FormType *)*dstP, trigger) != frmInvalidObjectId) ? trigger : 0; + + LstNewList(dstP, id, x, y, w, h, font, visible, trigger); + newP = (ListType *)FrmGetObjectPtr((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); + LstSetListChoices(newP, itemsP, items); + FrmHideObject((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); + break; + } + case frmFieldObj: { + FieldAttrType attr; + FontID font = FldGetFont((FieldType *)objP); + UInt16 maxChars = FldGetMaxChars((FieldType *)objP); + FldGetAttributes((FieldType *)objP, &attr); + FldNewField(dstP, id, x, y, w, h, font, maxChars, attr.editable, attr.underlined, attr.singleLine, attr.dynamicSize, (JustificationType)attr.justification, attr.autoShift, attr.hasScrollBar, attr.numeric); + FrmHideObject((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); + break; + } + case frmControlObj: { + const Char *textP = CtlGetLabel((ControlType *)objP); + ControlStyleType style = CtlGlueGetControlStyle((ControlType *)objP); + FontID font = CtlGlueGetFont((ControlType *)objP); + ControlType *newP = CtlNewControl(dstP, id, style, textP, x, y, w, h, font, 0, true); + FrmHideObject((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); + switch (style) { + case sliderCtl: + { + UInt16 min, max, page, val; + CtlGetSliderValues((ControlType *)objP, &min, &max, &page, &val); + CtlSetSliderValues(newP, &min, &max, &page, &val); + break; + } + } + break; + } + case frmLabelObj: { + const Char *textP = FrmGetLabel(srcP, id); + FontID font = FrmGlueGetLabelFont(srcP, id); + FrmNewLabel((FormType **)dstP, id, textP, x, y, font); + FrmHideObject((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); + break; + } + + case frmBitmapObj: { +/* UInt16 family = id + 1; + FrmNewBitmap((FormType **)dstP, id, id, x, y); + //FrmHideObject((FormType *)*dstP, FrmGetObjectIndex((FormType *)*dstP, id)); +*/ break; + } + } + } + + frmP = (FormType **)dstP; // save new form ptr + return errNone; +} + +void TabSetActive(FormType *frmP, TabType *tabP, UInt16 num) { + UInt16 cnt, idx; + RectangleType r; + TabDataPtr dataP; + + if (tabP->active == num) + return; + + dataP = &tabP->tabs[tabP->active]; + + // hide active tab objects + if (tabP->active != tabP->count) { + for (cnt = dataP->first; cnt <= dataP->last; cnt++) { + if ((idx = FrmGetObjectIndex(frmP, cnt)) != frmInvalidObjectId) + FrmHideObject(frmP, idx); + } + } + + // save active tab + tabP->active = num; + dataP = &tabP->tabs[num]; + + // draw tab limit + WinSetForeColor(UIColorGetTableEntryIndex(UIFormFill)); + WinDrawLine(1, 14, 154,14); + WinDrawLine(1, 15, 154,15); + RctSetRectangle(&r, 1, 30, 154, 100); + WinDrawRectangle(&r, 0); + WinSetForeColor(UIColorGetTableEntryIndex(UIObjectFrame)); + WinDrawLine(1, 28, 154,28); + + // set tabs size + for (cnt = 0; cnt < tabP->count; cnt++) { + idx = FrmGetObjectIndex (frmP, (FrmGetFormId(frmP) + cnt + 1)); + + if (idx != frmInvalidObjectId) { + FrmGetObjectBounds(frmP, idx, &r); + r.topLeft.y = (num == cnt) ? 17 : 17; + r.extent.y = (num == cnt) ? 12 : 11; + FrmSetObjectBounds(frmP, idx, &r); + + if (num == cnt) { + RGBColorType yellow = {0,255,192,0}; + + UInt8 line = /*(UIColorGetTableEntryIndex(UIFormFill) == UIColorGetTableEntryIndex(UIFieldTextHighlightBackground)) ? + WinRGBToIndex(&yellow) :*/ + UIColorGetTableEntryIndex(UIFieldTextHighlightBackground); + + r.topLeft.y -= 1; + WinSetForeColor(UIColorGetTableEntryIndex(UIObjectFrame)); + WinDrawRectangleFrame(simpleFrame, &r); + WinSetForeColor(line); + WinDrawLine(r.topLeft.x, r.topLeft.y, r.topLeft.x + r.extent.x - 1, r.topLeft.y); + FrmShowObject(frmP, idx); + + } else { + UInt8 frame = UIColorGetTableEntryIndex(UIObjectFrame); + RGBColorType light; + WinIndexToRGB(frame, &light); + light.r = (255 - light.r) > 72 ? light.r + 72 : 255; + light.g = (255 - light.g) > 72 ? light.g + 72 : 255; + light.b = (255 - light.b) > 72 ? light.b + 72 : 255; + + WinSetForeColor(WinRGBToIndex(&light)); + WinDrawRectangleFrame(simpleFrame, &r); + WinSetForeColor(frame); + WinDrawLine(r.topLeft.x - 1, r.topLeft.y + r.extent.y, r.topLeft.x + r.extent.x, r.topLeft.y + r.extent.y); + } + + // round corner + WinSetForeColor(UIColorGetTableEntryIndex(UIFormFill)); + if (OPTIONS_TST(kOptModeHiDensity)) { + WinSetCoordinateSystem(kCoordinatesNative); + WinDrawPixel((r.topLeft.x - 1) * 2, (r.topLeft.y - 1) * 2); + WinDrawPixel((r.topLeft.x + r.extent.x) * 2 + 1, (r.topLeft.y - 1) * 2); + WinSetCoordinateSystem(kCoordinatesStandard); + + } else { + // TODO + } + } + } + + // show objects + for (cnt = dataP->first; cnt <= dataP->last; cnt++) { + if ((idx = FrmGetObjectIndex(frmP, cnt)) != frmInvalidObjectId) + FrmShowObject(frmP, idx); + } + + // post draw function + if (dataP->drawFunc) + (dataP->drawFunc)(); +} diff --git a/backends/PalmOS/Src/launcher/forms/formtabs.h b/backends/PalmOS/Src/launcher/forms/formtabs.h new file mode 100644 index 0000000000..5371485bf1 --- /dev/null +++ b/backends/PalmOS/Src/launcher/forms/formtabs.h @@ -0,0 +1,24 @@ +#ifndef __FORMTABS_H__ +#define __FORMTABS_H__ + +typedef void (TabProc)(); + +typedef struct { + FormPtr srcP; + UInt16 first; + UInt16 last; + TabProc *drawFunc; +} TabDataType, *TabDataPtr; + +typedef struct { + UInt16 count, active; + Coord width; + TabDataPtr tabs; +} TabType, *TabPtr; + +TabType *TabNewTabs (UInt16 cnt); +void TabDeleteTabs (TabType *tabP); +Err TabAddContent (FormType **frmP, TabType *tabP, const Char *nameP, UInt16 rscID, TabProc *drawFunc = 0); +void TabSetActive (FormType *frmP, TabType *tabP, UInt16 num); +void TabMoveUpObject (FormType *frmP, UInt16 objID, Coord amount); +#endif -- cgit v1.2.3