2266 lines
68 KiB
C
Executable File
2266 lines
68 KiB
C
Executable File
/*****************************************************************************
|
|
*
|
|
* 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
|
|
*
|
|
* $Id: pace.c 531 2006-01-04 12:56:13Z picard $
|
|
*
|
|
* The Core Pocket Media Player
|
|
* Copyright (c) 2004-2005 Gabor Kovacs
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "../common.h"
|
|
|
|
#if defined(TARGET_PALMOS)
|
|
|
|
#include "pace.h"
|
|
#include "peal/arm/pealstub.h"
|
|
|
|
//tremor uses lot of alloca()
|
|
#define STACKSIZE 0x8000
|
|
//#define STACKCHECK
|
|
|
|
#ifdef HAVE_PALMONE_SDK
|
|
#define NO_HSEXT_TRAPS
|
|
#include <68K/System/HardwareUtils68K.h>
|
|
#include <Common/System/HsNavCommon.h>
|
|
#include <68K/System/HsExt.h>
|
|
#endif
|
|
|
|
typedef struct launch
|
|
{
|
|
UInt32 PealCall; //BE
|
|
UInt32 Module; //BE
|
|
UInt32 LoadModule; //BE
|
|
UInt32 FreeModule; //BE
|
|
UInt32 GetSymbol; //BE
|
|
|
|
UInt16 launchParameters[2];
|
|
UInt16 launchCode;
|
|
UInt16 launchFlags;
|
|
|
|
} launch;
|
|
|
|
typedef struct gadgethandler
|
|
{
|
|
uint8_t Code[68];
|
|
struct gadgethandler* Next;
|
|
|
|
FormGadgetTypeInCallback* Gadget; //BE
|
|
uint16_t* Event; //BE
|
|
UInt16 Cmd; //BE
|
|
UInt32 Module; //BE
|
|
UInt32 PealCall; //BE
|
|
UInt32 Wrapper; //BE
|
|
|
|
FormType* Form;
|
|
int Index;
|
|
FormGadgetHandlerType* Handler;
|
|
|
|
} gadgethandler;
|
|
|
|
typedef struct eventhandler
|
|
{
|
|
uint8_t Code[48];
|
|
struct eventhandler* Next;
|
|
|
|
uint16_t* Event; //BE
|
|
UInt32 Module; //BE
|
|
UInt32 PealCall; //BE
|
|
UInt32 Wrapper; //BE
|
|
|
|
FormType* Form;
|
|
FormEventHandlerType *Handler;
|
|
|
|
} eventhandler;
|
|
|
|
static gadgethandler* GadgetHandler = NULL;
|
|
static eventhandler* EventHandler = NULL;
|
|
static launch Peal = {0};
|
|
|
|
static NOINLINE void FreeHandlers()
|
|
{
|
|
gadgethandler* j;
|
|
eventhandler* i;
|
|
while ((i=EventHandler)!=NULL)
|
|
{
|
|
EventHandler = i->Next;
|
|
MemPtrFree(i);
|
|
}
|
|
while ((j=GadgetHandler)!=NULL)
|
|
{
|
|
GadgetHandler = j->Next;
|
|
MemPtrFree(j);
|
|
}
|
|
}
|
|
|
|
static NOINLINE void SwapLanchParameters(int launchCode,void* launchParameters,bool_t From)
|
|
{
|
|
if (launchCode == sysAppLaunchCmdCustomBase)
|
|
{
|
|
vfspath* p = (vfspath*)launchParameters;
|
|
p->volRefNum = SWAP16(p->volRefNum);
|
|
}
|
|
|
|
if (launchCode == sysAppLaunchCmdOpenDB)
|
|
{
|
|
UInt16 tmp;
|
|
SysAppLaunchCmdOpenDBType2* p = (SysAppLaunchCmdOpenDBType2*)launchParameters;
|
|
p->cardNo = SWAP16(p->cardNo);
|
|
tmp = p->dbID[0];
|
|
p->dbID[0] = SWAP16(p->dbID[1]);
|
|
p->dbID[1] = SWAP16(tmp);
|
|
}
|
|
|
|
if (launchCode == sysAppLaunchCmdNotify)
|
|
{
|
|
SysNotifyParamType* p = (SysNotifyParamType*)launchParameters;
|
|
UInt32 Type = p->notifyType;
|
|
void* Details = p->notifyDetailsP;
|
|
|
|
p->notifyType = SWAP32(p->notifyType);
|
|
p->broadcaster = SWAP32(p->broadcaster);
|
|
p->notifyDetailsP = (void*)SWAP32(p->notifyDetailsP);
|
|
p->userDataP = (void*)SWAP32(p->userDataP);
|
|
|
|
if (From)
|
|
{
|
|
Type = p->notifyType;
|
|
Details = p->notifyDetailsP;
|
|
}
|
|
|
|
if (Type == sysNotifySleepRequestEvent)
|
|
{
|
|
SleepEventParamType* i = (SleepEventParamType*)Details;
|
|
i->reason = SWAP16(i->reason);
|
|
i->deferSleep = SWAP16(i->deferSleep);
|
|
}
|
|
}
|
|
}
|
|
|
|
static INLINE uint32_t ReadSwap32(const void* p)
|
|
{
|
|
return
|
|
(((const uint8_t*)p)[0] << 24)|
|
|
(((const uint8_t*)p)[1] << 16)|
|
|
(((const uint8_t*)p)[2] << 8)|
|
|
(((const uint8_t*)p)[3] << 0);
|
|
}
|
|
|
|
static INLINE void WriteSwap32(void* p,uint32_t i)
|
|
{
|
|
((uint8_t*)p)[0] = ((uint8_t*)&i)[3];
|
|
((uint8_t*)p)[1] = ((uint8_t*)&i)[2];
|
|
((uint8_t*)p)[2] = ((uint8_t*)&i)[1];
|
|
((uint8_t*)p)[3] = ((uint8_t*)&i)[0];
|
|
}
|
|
|
|
void Event_M68K_To_ARM(const uint16_t* In,EventType* Out)
|
|
{
|
|
Out->eType = SWAP16(In[0]);
|
|
Out->penDown = ((uint8_t*)In)[2];
|
|
Out->tapCount = ((uint8_t*)In)[3];
|
|
Out->screenX = SWAP16(In[2]);
|
|
Out->screenY = SWAP16(In[3]);
|
|
|
|
switch (Out->eType)
|
|
{
|
|
// 1*16bit
|
|
case frmLoadEvent:
|
|
case menuEvent:
|
|
Out->data.menu.itemID = SWAP16(In[4]);
|
|
break;
|
|
|
|
// 3*16bit
|
|
case frmUpdateEvent:
|
|
case keyUpEvent:
|
|
case keyDownEvent:
|
|
case keyHoldEvent:
|
|
Out->data.keyDown.chr = SWAP16(In[4]);
|
|
Out->data.keyDown.keyCode = SWAP16(In[5]);
|
|
Out->data.keyDown.modifiers = SWAP16(In[6]);
|
|
break;
|
|
|
|
// 16bit,32bit
|
|
/* case fldChangedEvent:
|
|
Out->data.fldChanged.fieldID = SWAP16(In[4]);
|
|
Out->data.fldChanged.pField = (FieldType*)ReadSwap32(In+5);
|
|
break;
|
|
*/
|
|
// 16bit,32bit,16bit,32bit,16bit,16bit
|
|
case popSelectEvent:
|
|
Out->data.popSelect.controlID = SWAP16(In[4]);
|
|
Out->data.popSelect.controlP = (ControlType*)ReadSwap32(In+5);
|
|
Out->data.popSelect.listID = SWAP16(In[7]);
|
|
Out->data.popSelect.listP = (ListType*)SWAP32(*(uint32_t*)(In+8));
|
|
Out->data.popSelect.selection = SWAP16(In[10]);
|
|
Out->data.popSelect.priorSelection = SWAP16(In[11]);
|
|
break;
|
|
|
|
// 16bit,32bit,16bit
|
|
case lstSelectEvent:
|
|
Out->data.lstSelect.listID = SWAP16(In[4]);
|
|
Out->data.lstSelect.pList = (ListType*)ReadSwap32(In+5);
|
|
Out->data.lstSelect.selection = SWAP16(In[7]);
|
|
break;
|
|
|
|
//custom
|
|
case sclRepeatEvent:
|
|
Out->data.sclRepeat.scrollBarID = SWAP16(In[4]);
|
|
Out->data.sclRepeat.pScrollBar = (ScrollBarType*)ReadSwap32(In+5);
|
|
Out->data.sclRepeat.value = SWAP16(In[7]);
|
|
Out->data.sclRepeat.newValue = SWAP16(In[8]);
|
|
Out->data.sclRepeat.time = ReadSwap32(In+9);
|
|
break;
|
|
|
|
//custom
|
|
case ctlRepeatEvent:
|
|
Out->data.ctlRepeat.controlID = SWAP16(In[4]);
|
|
Out->data.ctlRepeat.pControl = (ControlType*)ReadSwap32(In+5);
|
|
Out->data.ctlRepeat.time = ReadSwap32(In+7);
|
|
Out->data.ctlRepeat.value = SWAP16(In[9]);
|
|
break;
|
|
|
|
//custom
|
|
case ctlSelectEvent:
|
|
Out->data.ctlSelect.controlID = SWAP16(In[4]);
|
|
Out->data.ctlSelect.pControl = (ControlType*)ReadSwap32(In+5);
|
|
Out->data.ctlSelect.on = ((uint8_t*)In)[14];
|
|
Out->data.ctlSelect.reserved1 = ((uint8_t*)In)[15];
|
|
Out->data.ctlSelect.value = SWAP16(In[8]);
|
|
break;
|
|
|
|
// 2*32bit
|
|
case winEnterEvent:
|
|
case winExitEvent:
|
|
Out->data.winExit.enterWindow = (WinHandle)SWAP32(((uint32_t*)In)[2]);
|
|
Out->data.winExit.exitWindow = (WinHandle)SWAP32(((uint32_t*)In)[3]);
|
|
break;
|
|
|
|
default:
|
|
memcpy(Out->data.generic.datum,In+4,sizeof(uint16_t)*8);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Event_ARM_To_M68K(const EventType* In,uint16_t* Out)
|
|
{
|
|
Out[0] = SWAP16(In->eType);
|
|
((uint8_t*)Out)[2] = In->penDown;
|
|
((uint8_t*)Out)[3] = In->tapCount;
|
|
Out[2] = SWAP16(In->screenX);
|
|
Out[3] = SWAP16(In->screenY);
|
|
|
|
switch (In->eType)
|
|
{
|
|
// 1*16bit
|
|
case frmLoadEvent:
|
|
case menuEvent:
|
|
Out[4] = SWAP16(In->data.menu.itemID);
|
|
break;
|
|
|
|
// 3*16bit
|
|
case frmUpdateEvent:
|
|
case keyUpEvent:
|
|
case keyDownEvent:
|
|
case keyHoldEvent:
|
|
Out[4] = SWAP16(In->data.keyDown.chr);
|
|
Out[5] = SWAP16(In->data.keyDown.keyCode);
|
|
Out[6] = SWAP16(In->data.keyDown.modifiers);
|
|
break;
|
|
|
|
// 16bit,32bit,16bit
|
|
case lstSelectEvent:
|
|
Out[4] = SWAP16(In->data.lstSelect.listID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.lstSelect.pList);
|
|
Out[7] = SWAP16(In->data.lstSelect.selection);
|
|
break;
|
|
|
|
// 16bit,32bit
|
|
/* case fldChangedEvent:
|
|
Out[4] = SWAP16(In->data.fldChanged.fieldID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.fldChanged.pField);
|
|
break;
|
|
*/
|
|
// 16bit,32bit,16bit,32bit,16bit,16bit
|
|
case popSelectEvent:
|
|
Out[4] = SWAP16(In->data.popSelect.controlID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.popSelect.controlP);
|
|
Out[7] = SWAP16(In->data.popSelect.listID);
|
|
WriteSwap32(Out+8,(uint32_t)In->data.popSelect.listP);
|
|
Out[10] = SWAP16(In->data.popSelect.selection);
|
|
Out[11] = SWAP16(In->data.popSelect.priorSelection);
|
|
break;
|
|
|
|
//custom
|
|
case sclRepeatEvent:
|
|
Out[4] = SWAP16(In->data.sclRepeat.scrollBarID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.sclRepeat.pScrollBar);
|
|
Out[7] = SWAP16(In->data.sclRepeat.value);
|
|
Out[8] = SWAP16(In->data.sclRepeat.newValue);
|
|
WriteSwap32(Out+9,In->data.sclRepeat.time);
|
|
break;
|
|
|
|
//custom
|
|
case ctlRepeatEvent:
|
|
Out[4] = SWAP16(In->data.ctlRepeat.controlID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.ctlRepeat.pControl);
|
|
WriteSwap32(Out+7,In->data.ctlRepeat.time);
|
|
Out[9] = SWAP16(In->data.ctlRepeat.value);
|
|
break;
|
|
|
|
//custom
|
|
case ctlSelectEvent:
|
|
Out[4] = SWAP16(In->data.ctlSelect.controlID);
|
|
WriteSwap32(Out+5,(uint32_t)In->data.ctlSelect.pControl);
|
|
((uint8_t*)Out)[14] = In->data.ctlSelect.on;
|
|
((uint8_t*)Out)[15] = In->data.ctlSelect.reserved1;
|
|
Out[8] = SWAP16(In->data.ctlSelect.value);
|
|
break;
|
|
|
|
// 2*32bit
|
|
case winEnterEvent:
|
|
case winExitEvent:
|
|
((uint32_t*)Out)[2] = SWAP32(In->data.winExit.enterWindow);
|
|
((uint32_t*)Out)[3] = SWAP32(In->data.winExit.exitWindow);
|
|
break;
|
|
|
|
default:
|
|
memcpy(Out+4,In->data.generic.datum,sizeof(uint16_t)*8);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void GadgetTypeInCallback_M68K_To_ARM(const uint16_t* In,FormGadgetTypeInCallback* Out)
|
|
{
|
|
Out->id = SWAP16(In[0]);
|
|
*(UInt16*)&Out->attr = SWAP16(In[1]);
|
|
Out->rect.topLeft.x = SWAP16(In[2]);
|
|
Out->rect.topLeft.y = SWAP16(In[3]);
|
|
Out->rect.extent.x = SWAP16(In[4]);
|
|
Out->rect.extent.y = SWAP16(In[5]);
|
|
Out->data = (const void*)SWAP32(*(const uint32_t*)(In+6));
|
|
Out->handler = (FormGadgetHandlerType*)SWAP32(*(const uint32_t*)(In+8));
|
|
}
|
|
|
|
static void GadgetTypeInCallback_ARM_To_M68K(const FormGadgetTypeInCallback* In,uint16_t* Out)
|
|
{
|
|
Out[0] = SWAP16(In->id);
|
|
Out[1] = SWAP16(*(UInt16*)&In->attr);
|
|
Out[2] = SWAP16(In->rect.topLeft.x);
|
|
Out[3] = SWAP16(In->rect.topLeft.y);
|
|
Out[4] = SWAP16(In->rect.extent.x);
|
|
Out[5] = SWAP16(In->rect.extent.y);
|
|
*(uint32_t*)(Out+6) = SWAP32(In->data);
|
|
*(uint32_t*)(Out+8) = SWAP32(In->handler);
|
|
}
|
|
|
|
static NOINLINE bool_t CmdLaunch(int Code)
|
|
{
|
|
return Code == sysAppLaunchCmdNormalLaunch ||
|
|
Code == sysAppLaunchCmdOpenDB ||
|
|
Code == sysAppLaunchCmdCustomBase;
|
|
}
|
|
|
|
#if defined(_M_IX86)
|
|
|
|
#define NONE 0
|
|
|
|
pcecall PceCall = {NULL};
|
|
|
|
#include <windows.h>
|
|
|
|
DLLEXPORT uint32_t PaceMain86(const void *emulStateP, launch* Launch, Call68KFuncType *call68KFuncP)
|
|
{
|
|
MemPtr Parameters = (MemPtr)((SWAP16(Launch->launchParameters[0])<<16)|(SWAP16(Launch->launchParameters[1])));
|
|
int Code = SWAP16(Launch->launchCode);
|
|
uint32_t Result;
|
|
pcecall Old = PceCall;
|
|
|
|
if (CmdLaunch(Code))
|
|
memcpy(&Peal,Launch,sizeof(launch));
|
|
|
|
PceCall.Func = call68KFuncP;
|
|
PceCall.State = emulStateP;
|
|
|
|
SwapLanchParameters(Code,Parameters,1);
|
|
Result = PilotMain((UInt16)Code,Parameters,SWAP16(Launch->launchFlags));
|
|
SwapLanchParameters(Code,Parameters,0);
|
|
|
|
if (CmdLaunch(Code))
|
|
FreeHandlers();
|
|
|
|
PceCall = Old;
|
|
return Result;
|
|
}
|
|
|
|
void SaveSysRegs(sysregs* p)
|
|
{
|
|
}
|
|
|
|
void LoadSysRegs(sysregs* p)
|
|
{
|
|
}
|
|
|
|
static NOINLINE unsigned long Call68K(unsigned long trapOrFunction,
|
|
const void *argsOnStackP, unsigned long argsSizeAndwantA0)
|
|
{
|
|
pcecall* Call = &PceCall;
|
|
return Call->Func(Call->State,trapOrFunction,argsOnStackP,argsSizeAndwantA0);
|
|
}
|
|
|
|
DLLEXPORT Boolean WrapperEventHandler86(const void *emulStateP, eventhandler* i, Call68KFuncType *call68KFuncP)
|
|
{
|
|
Boolean Result;
|
|
EventType EventARM;
|
|
uint16_t* EventM68K = (uint16_t*) SWAP32(i->Event);
|
|
pcecall Old = PceCall;
|
|
PceCall.Func = call68KFuncP;
|
|
PceCall.State = emulStateP;
|
|
Event_M68K_To_ARM(EventM68K,&EventARM);
|
|
Result = i->Handler(&EventARM);
|
|
if (!Result && EventARM.eType == frmCloseEvent)
|
|
i->Form = NULL;
|
|
PceCall = Old;
|
|
return Result;
|
|
}
|
|
|
|
DLLEXPORT Boolean WrapperGadgetHandler86(const void *emulStateP, gadgethandler* i, Call68KFuncType *call68KFuncP)
|
|
{
|
|
EventType EventARM;
|
|
Boolean Result;
|
|
FormGadgetTypeInCallback GadgetARM;
|
|
uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
|
|
UInt16 Cmd = SWAP16(i->Cmd);
|
|
uint16_t* EventM68K = (uint16_t*) SWAP32(i->Event);
|
|
pcecall Old = PceCall;
|
|
PceCall.Func = call68KFuncP;
|
|
PceCall.State = emulStateP;
|
|
GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
|
|
if (Cmd == formGadgetHandleEventCmd)
|
|
Event_M68K_To_ARM(EventM68K,&EventARM);
|
|
Result = i->Handler(&GadgetARM,Cmd,&EventARM);
|
|
GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
|
|
if (Cmd == formGadgetDeleteCmd)
|
|
i->Form = NULL;
|
|
PceCall = Old;
|
|
return Result;
|
|
}
|
|
|
|
#elif defined(ARM)
|
|
|
|
#define NONE
|
|
|
|
void SaveSysRegs(sysregs* p)
|
|
{
|
|
p->SysReg = PceCall.SysReg;
|
|
asm volatile(
|
|
"mov %0, r10\n\t"
|
|
: "=&r"(p->GOT) : : "cc");
|
|
}
|
|
|
|
void LoadSysRegs(sysregs* p)
|
|
{
|
|
asm volatile(
|
|
"mov r9,%0\n\t"
|
|
"mov r10,%1\n\t"
|
|
: : "r"(p->SysReg),"r"(p->GOT): "cc");
|
|
}
|
|
|
|
static NOINLINE unsigned long Call68K(unsigned long trapOrFunction,
|
|
const void *argsOnStackP, unsigned long argsSizeAndwantA0)
|
|
{
|
|
pcecall* Call = &PceCall;
|
|
unsigned long Result;
|
|
register void *SysReg asm("r9") = Call->SysReg;
|
|
Result = Call->Func(Call->State,trapOrFunction,argsOnStackP,argsSizeAndwantA0);
|
|
Call->SysReg = SysReg;
|
|
return Result;
|
|
}
|
|
|
|
static NOINLINE void SafeMemCpy(void* d,const void* s,int n)
|
|
{
|
|
uint8_t* d8 = (uint8_t*)d;
|
|
const uint8_t* s8= (const uint8_t*)s;
|
|
for (;n>0;--n,++d8,++s8)
|
|
*d8 = *s8;
|
|
}
|
|
|
|
#ifdef STACKCHECK
|
|
static void NOINLINE StackCheck(char* p)
|
|
{
|
|
int i;
|
|
for (i=0;i<STACKSIZE;++i)
|
|
if (p[i] != 0x55)
|
|
break;
|
|
if (i < 4096)
|
|
{
|
|
char s[64];
|
|
sprintf(s,"Possible stack overflow %d/%d. ",i,STACKSIZE);
|
|
FrmCustomAlert(WarningOKAlert, s, "Please contact developer!", " ");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
uint32_t PaceMain(launch* Launch)
|
|
{
|
|
MemPtr Parameters = (MemPtr)((SWAP16(Launch->launchParameters[0])<<16)|(SWAP16(Launch->launchParameters[1])));
|
|
int Code = SWAP16(Launch->launchCode);
|
|
void* Old = NULL;
|
|
char* Stack = NULL;
|
|
uint32_t Result;
|
|
|
|
if (CmdLaunch(Code))
|
|
{
|
|
SafeMemCpy(&Peal,Launch,sizeof(launch));
|
|
Stack = MemGluePtrNew(STACKSIZE);
|
|
if (!Stack)
|
|
return errNone;
|
|
memset(Stack,0x55,STACKSIZE);
|
|
Old = SwapSP(Stack+STACKSIZE);
|
|
}
|
|
|
|
SwapLanchParameters(Code,Parameters,1);
|
|
Result = PilotMain(Code,Parameters,SWAP16(Launch->launchFlags));
|
|
SwapLanchParameters(Code,Parameters,0);
|
|
|
|
if (Stack)
|
|
{
|
|
SwapSP(Old);
|
|
#ifdef STACKCHECK
|
|
StackCheck(Stack);
|
|
#endif
|
|
MemPtrFree(Stack);
|
|
FreeHandlers();
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
static Boolean WrapperEventHandler(eventhandler* i)
|
|
{
|
|
Boolean Result;
|
|
EventType EventARM;
|
|
const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
|
|
Event_M68K_To_ARM(EventM68K,&EventARM);
|
|
Result = i->Handler(&EventARM);
|
|
if (!Result && EventARM.eType == frmCloseEvent)
|
|
i->Form = NULL;
|
|
return Result;
|
|
}
|
|
|
|
static Boolean WrapperGadgetHandler(gadgethandler* i)
|
|
{
|
|
EventType EventARM;
|
|
Boolean Result;
|
|
FormGadgetTypeInCallback GadgetARM;
|
|
uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
|
|
UInt16 Cmd = SWAP16(i->Cmd);
|
|
const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
|
|
GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
|
|
if (Cmd == formGadgetHandleEventCmd)
|
|
Event_M68K_To_ARM(EventM68K,&EventARM);
|
|
Result = i->Handler(&GadgetARM,Cmd,&EventARM);
|
|
GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
|
|
if (Cmd == formGadgetDeleteCmd)
|
|
i->Form = NULL;
|
|
return Result;
|
|
}
|
|
|
|
#else
|
|
#error Not supported platform
|
|
#endif
|
|
|
|
typedef struct emustate
|
|
{
|
|
uint32_t instr;
|
|
uint32_t regD[8];
|
|
uint32_t regA[8];
|
|
uint32_t regPC;
|
|
|
|
} emustate;
|
|
|
|
#define PACE_PARAM _v
|
|
|
|
#define PACE_BEGIN(declare) NOINLINE declare { uint16_t PACE_PARAM[] = {
|
|
#define PACE_BEGINEVENT(declare) NOINLINE declare { uint16_t ev[12]; uint16_t PACE_PARAM[] = {
|
|
#define PACE_BEGINEX(declare,name) NOINLINE declare { uint16_t name[] = {
|
|
#define PACE_VAR(name) }; uint16_t name[] = {
|
|
|
|
#define PACE_ADD8(name) (uint8_t)name,
|
|
#define PACE_ADD16(name) SWAP16(name),
|
|
#define PACE_ADD32(name) SWAP16(((uint32_t)(name))>>16),SWAP16(name),
|
|
|
|
#define PACE_DATA16(name) *name = SWAP16(*name);
|
|
#define PACE_DATA32(name) *name = SWAP32(*name);
|
|
#define PACE_CDATA16(name) if (name) *name = SWAP16(*name);
|
|
#define PACE_CDATA32(name) if (name) *name = SWAP32(*name);
|
|
#define PACE_SEL(sel) ((emustate*)PceCall.State)->regD[2] = sel;
|
|
|
|
#define PACE_END(Trap,PreProcess,PostProcess) }; PreProcess; \
|
|
Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
|
|
PostProcess; }
|
|
|
|
#define PACE_ENDVOID(Trap,PreProcess,PostProcess) 0}; PreProcess; \
|
|
Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
|
|
PostProcess; }
|
|
|
|
#define PACE_END8(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
|
|
PostProcess; return (uint8_t)ret; }
|
|
|
|
#define PACE_END8VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
|
|
PostProcess; return (uint8_t)ret; }
|
|
|
|
#define PACE_END16(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
|
|
PostProcess; return (uint16_t)ret; }
|
|
|
|
#define PACE_END16VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
|
|
PostProcess; return (uint16_t)ret; }
|
|
|
|
#define PACE_END32(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); \
|
|
PostProcess; return ret; }
|
|
|
|
#define PACE_END32VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); \
|
|
PostProcess; return ret; }
|
|
|
|
#define PACE_ENDPTR(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)|kPceNativeWantA0); \
|
|
PostProcess; return (void*)ret; }
|
|
|
|
#define PACE_ENDPTRVOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; \
|
|
ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0|kPceNativeWantA0); \
|
|
PostProcess; return (void*)ret; }
|
|
|
|
static NOINLINE void SwapBlock32(void* Ptr,int n)
|
|
{
|
|
if (Ptr)
|
|
{
|
|
int i;
|
|
char* p = (char*)Ptr;
|
|
for (i=0;i<n;++i,p+=4)
|
|
PACE_DATA32((uint32_t*)p);
|
|
}
|
|
}
|
|
|
|
static NOINLINE void SwapStruct(void* Ptr,...)
|
|
{
|
|
if (Ptr)
|
|
{
|
|
int Size;
|
|
char* p = (char*)Ptr;
|
|
va_list Args;
|
|
va_start(Args,Ptr);
|
|
while ((Size = va_arg(Args,int))!=0)
|
|
{
|
|
if (Size == 4)
|
|
PACE_DATA32((uint32_t*)p)
|
|
else
|
|
if (Size == 2)
|
|
PACE_DATA16((uint16_t*)p)
|
|
p += Size;
|
|
}
|
|
va_end(Args);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
PACE_BEGIN(Int32 GetOEMSleepMode())
|
|
PACE_END32VOID(sysTrapOEMDispatch2,PACE_SEL(263),NONE)
|
|
|
|
PACE_BEGIN(Err SetOEMSleepMode(Int32 Mode))
|
|
PACE_ADD32(Mode)
|
|
PACE_END16(sysTrapOEMDispatch2,PACE_SEL(264),NONE)
|
|
|
|
PACE_BEGIN(UInt16 SysGetOrientation())
|
|
PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinSysGetOrientation),NONE)
|
|
|
|
PACE_BEGIN(Err WinGetPixelRGB(Coord x, Coord y, RGBColorType* rgbP))
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_ADD32(rgbP)
|
|
PACE_END16(sysTrapWinGetPixelRGB,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinSetForeColorRGB(const RGBColorType* newRgbP, RGBColorType* prevRgbP))
|
|
PACE_ADD32(newRgbP)
|
|
PACE_ADD32(prevRgbP)
|
|
PACE_END(sysTrapWinSetForeColorRGB,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinPaintPixel(Coord x, Coord y))
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_END(sysTrapWinPaintPixel,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinDrawPixel(Coord x, Coord y))
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_END(sysTrapWinDrawPixel,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmSetFocus(FormType *formP, UInt16 fieldIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(fieldIndex)
|
|
PACE_END(sysTrapFrmSetFocus,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmSetTitle (FormType *formP, Char *newTitle))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD32(newTitle)
|
|
PACE_END(sysTrapFrmSetTitle,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormObjectKind FrmGetObjectType(const FormType *formP, UInt16 objIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_END8(sysTrapFrmGetObjectType,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormLabelType *FrmNewLabel (FormType **formPP, UInt16 ID, const Char *textP,
|
|
Coord x, Coord y, FontID font))
|
|
PACE_ADD32(formPP)
|
|
PACE_ADD16(ID)
|
|
PACE_ADD32(textP)
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_ADD8(font)
|
|
PACE_ENDPTR(sysTrapFrmNewLabel,PACE_CDATA32((UInt32*)formPP),PACE_CDATA32((UInt32*)formPP))
|
|
|
|
PACE_BEGIN(FormType *FrmNewForm(UInt16 formID, const Char *titleStrP,
|
|
Coord x, Coord y, Coord width, Coord height, Boolean modal,
|
|
UInt16 defaultButton, UInt16 helpRscID, UInt16 menuRscID))
|
|
PACE_ADD16(formID)
|
|
PACE_ADD32(titleStrP)
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_ADD16(width)
|
|
PACE_ADD16(height)
|
|
PACE_ADD8(modal)
|
|
PACE_ADD16(defaultButton)
|
|
PACE_ADD16(helpRscID)
|
|
PACE_ADD16(menuRscID)
|
|
PACE_ENDPTR(sysTrapFrmNewForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmCloseAllForms())
|
|
PACE_ENDVOID(sysTrapFrmCloseAllForms,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmGetObjectId (const FormType *formP, UInt16 objIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_END16(sysTrapFrmGetObjectId,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmGetNumberOfObjects(const FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END16(sysTrapFrmGetNumberOfObjects,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmGetActiveFormID())
|
|
PACE_END16VOID(sysTrapFrmGetActiveFormID,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmGotoForm (UInt16 formId))
|
|
PACE_ADD16(formId)
|
|
PACE_END(sysTrapFrmGotoForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(void CtlSetUsable (ControlType *controlP, Boolean usable))
|
|
PACE_ADD32(controlP)
|
|
PACE_ADD8(usable)
|
|
PACE_END(sysTrapCtlSetUsable,NONE,NONE)
|
|
|
|
PACE_BEGIN(Int16 CtlGetValue (const ControlType *controlP))
|
|
PACE_ADD32(controlP)
|
|
PACE_END16(sysTrapCtlGetValue,NONE,NONE)
|
|
|
|
PACE_BEGIN(void CtlSetValue (ControlType *controlP, Int16 newValue))
|
|
PACE_ADD32(controlP)
|
|
PACE_ADD16(newValue)
|
|
PACE_END(sysTrapCtlSetValue,NONE,NONE)
|
|
|
|
PACE_BEGIN(void CtlSetLabel (ControlType *controlP, const Char *newLabel))
|
|
PACE_ADD32(controlP)
|
|
PACE_ADD32(newLabel)
|
|
PACE_END(sysTrapCtlSetLabel,NONE,NONE)
|
|
|
|
PACE_BEGIN(void EvtEnableGraffiti(Boolean enable))
|
|
PACE_ADD8(enable)
|
|
PACE_END(sysTrapEvtEnableGraffiti,NONE,NONE);
|
|
|
|
PACE_BEGIN(Err EvtResetAutoOffTimer())
|
|
PACE_END16VOID(sysTrapEvtResetAutoOffTimer,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormType *FrmGetFirstForm())
|
|
PACE_ENDPTRVOID(sysTrapFrmGetFirstForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(void *FrmGetObjectPtr (const FormType *formP, UInt16 objIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_ENDPTR(sysTrapFrmGetObjectPtr,NONE,NONE)
|
|
|
|
#if defined(_M_IX86)
|
|
// simulator freezes many times. bypassing...
|
|
Boolean EvtEventAvail() { return 1; }
|
|
#else
|
|
PACE_BEGIN(Boolean EvtEventAvail())
|
|
PACE_END8VOID(sysTrapEvtEventAvail,NONE,NONE)
|
|
#endif
|
|
|
|
PACE_BEGIN(void EvtGetPen(Int16 *pScreenX, Int16 *pScreenY, Boolean *pPenDown))
|
|
PACE_ADD32(pScreenX)
|
|
PACE_ADD32(pScreenY)
|
|
PACE_ADD32(pPenDown)
|
|
PACE_END(sysTrapEvtGetPen,NONE,PACE_DATA16(pScreenX) PACE_DATA16(pScreenY))
|
|
|
|
PACE_BEGIN(Boolean EvtSysEventAvail(Boolean ignorePenUps))
|
|
PACE_ADD8(ignorePenUps)
|
|
PACE_END8(sysTrapEvtSysEventAvail,NONE,NONE)
|
|
|
|
PACE_BEGINEVENT(void EvtAddUniqueEventToQueue(const EventType *eventP, UInt32 id,Boolean inPlace))
|
|
PACE_ADD32(&ev)
|
|
PACE_ADD32(id)
|
|
PACE_ADD8(inPlace)
|
|
PACE_END(sysTrapEvtAddUniqueEventToQueue,Event_ARM_To_M68K(eventP,ev),NONE)
|
|
|
|
PACE_BEGINEVENT(void EvtGetEvent(EventType *event, Int32 timeout))
|
|
PACE_ADD32(&ev)
|
|
PACE_ADD32(timeout)
|
|
PACE_END(sysTrapEvtGetEvent,NONE,Event_M68K_To_ARM(ev,event))
|
|
|
|
PACE_BEGIN(UInt16 FrmGetObjectIndex (const FormType *formP, UInt16 objID))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objID)
|
|
PACE_END16(sysTrapFrmGetObjectIndex,NONE,NONE)
|
|
|
|
PACE_BEGIN(void CtlSetSliderValues(ControlType *ctlP, const UInt16 *minValueP, const UInt16 *maxValueP,
|
|
const UInt16 *pageSizeP, const UInt16 *valueP))
|
|
PACE_ADD32(ctlP)
|
|
PACE_ADD32(minValueP)
|
|
PACE_ADD32(maxValueP)
|
|
PACE_ADD32(pageSizeP)
|
|
PACE_ADD32(valueP)
|
|
PACE_END(sysTrapCtlSetSliderValues,PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP),
|
|
PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP))
|
|
// possible problem overriding const input
|
|
|
|
PACE_BEGIN(WinHandle WinSetDrawWindow(WinHandle winHandle))
|
|
PACE_ADD32(winHandle)
|
|
PACE_ENDPTR(sysTrapWinSetDrawWindow,NONE,NONE)
|
|
|
|
PACE_BEGIN(WinHandle WinGetDrawWindow())
|
|
PACE_ENDPTRVOID(sysTrapWinGetDrawWindow,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinDrawLine (Coord x1, Coord y1, Coord x2, Coord y2))
|
|
PACE_ADD16(x1)
|
|
PACE_ADD16(y1)
|
|
PACE_ADD16(x2)
|
|
PACE_ADD16(y2)
|
|
PACE_END(sysTrapWinDrawLine,NONE,NONE)
|
|
|
|
PACE_BEGIN(IndexedColorType UIColorGetTableEntryIndex(UIColorTableEntries which))
|
|
PACE_ADD8(which)
|
|
PACE_END8(sysTrapUIColorGetTableEntryIndex,NONE,NONE)
|
|
|
|
PACE_BEGIN(IndexedColorType WinSetForeColor (IndexedColorType foreColor))
|
|
PACE_ADD8(foreColor)
|
|
PACE_END8(sysTrapWinSetForeColor,NONE,NONE)
|
|
|
|
PACE_BEGIN(IndexedColorType WinSetBackColor (IndexedColorType backColor))
|
|
PACE_ADD8(backColor)
|
|
PACE_END8(sysTrapWinSetBackColor,NONE,NONE)
|
|
|
|
PACE_BEGIN(IndexedColorType WinSetTextColor (IndexedColorType textColor))
|
|
PACE_ADD8(textColor)
|
|
PACE_END8(sysTrapWinSetTextColor,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmDoDialog (FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END16(sysTrapFrmDoDialog,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmGetFormId (const FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END16(sysTrapFrmGetFormId,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmPopupForm (UInt16 formId))
|
|
PACE_ADD16(formId)
|
|
PACE_END(sysTrapFrmPopupForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmDrawForm (FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END(sysTrapFrmDrawForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmEraseForm (FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END(sysTrapFrmEraseForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(Boolean MenuHideItem(UInt16 id))
|
|
PACE_ADD16(id)
|
|
PACE_END8(sysTrapMenuHideItem,NONE,NONE)
|
|
|
|
PACE_BEGINEVENT(Boolean MenuHandleEvent(MenuBarType *menuP, EventType *event, UInt16 *error))
|
|
PACE_ADD32(menuP)
|
|
PACE_ADD32(&ev)
|
|
PACE_ADD32(error)
|
|
PACE_END8(sysTrapMenuHandleEvent,Event_ARM_To_M68K(event,ev),PACE_DATA16(error))
|
|
|
|
PACE_BEGIN(Err SysNotifyRegister(UInt16 cardNo, LocalID dbID, UInt32 notifyType,
|
|
SysNotifyProcPtr callbackP, Int8 priority, void *userDataP))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_ADD32(notifyType)
|
|
PACE_ADD32(callbackP)
|
|
PACE_ADD8(priority)
|
|
PACE_ADD32(userDataP)
|
|
PACE_END16(sysTrapSysNotifyRegister,NONE,NONE)
|
|
|
|
PACE_BEGIN(Boolean FrmVisible(const FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END8(sysTrapFrmVisible,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmSetActiveForm(FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END(sysTrapFrmSetActiveForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormType* FrmInitForm(UInt16 rscID))
|
|
PACE_ADD16(rscID)
|
|
PACE_ENDPTR(sysTrapFrmInitForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(WinHandle FrmGetWindowHandle(const FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_ENDPTR(sysTrapFrmGetWindowHandle,NONE,NONE);
|
|
|
|
PACE_BEGIN(Err SysNotifyUnregister(UInt16 cardNo, LocalID dbID, UInt32 notifyType, Int8 priority))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_ADD32(notifyType)
|
|
PACE_ADD8(priority)
|
|
PACE_END16(sysTrapSysNotifyUnregister,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SysCurAppDatabase(UInt16 *cardNoP, LocalID *dbIDP))
|
|
PACE_ADD32(cardNoP)
|
|
PACE_ADD32(dbIDP)
|
|
PACE_END16(sysTrapSysCurAppDatabase,NONE,PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
|
|
|
|
PACE_BEGIN(Err WinSetConstraintsSize(WinHandle winH, Coord minH, Coord prefH, Coord maxH,
|
|
Coord minW, Coord prefW, Coord maxW))
|
|
PACE_ADD32(winH)
|
|
PACE_ADD16(minH)
|
|
PACE_ADD16(prefH)
|
|
PACE_ADD16(maxH)
|
|
PACE_ADD16(minW)
|
|
PACE_ADD16(prefW)
|
|
PACE_ADD16(maxW)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinWinSetConstraintsSize),NONE)
|
|
|
|
PACE_BEGIN(Err SysSetOrientation(UInt16 orientation))
|
|
PACE_ADD16(orientation)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinSysSetOrientation),NONE)
|
|
|
|
PACE_BEGIN(UInt16 PINGetInputAreaState())
|
|
PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinPINGetInputAreaState),NONE)
|
|
|
|
PACE_BEGIN(Err PINSetInputTriggerState(UInt16 state))
|
|
PACE_ADD16(state)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinPINSetInputTriggerState),NONE)
|
|
|
|
PACE_BEGIN(Err FrmSetDIAPolicyAttr (FormPtr formP, UInt16 diaPolicy))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(diaPolicy)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinFrmSetDIAPolicyAttr),NONE)
|
|
|
|
PACE_BEGIN(Err PINSetInputAreaState(UInt16 state))
|
|
PACE_ADD16(state)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinPINSetInputAreaState),NONE)
|
|
|
|
PACE_BEGIN(Err SysSetOrientationTriggerState(UInt16 triggerState))
|
|
PACE_ADD16(triggerState)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinSysSetOrientationTriggerState),NONE)
|
|
|
|
PACE_BEGIN(Err StatGetAttribute(UInt16 selector, UInt32* dataP))
|
|
PACE_ADD16(selector)
|
|
PACE_ADD32(dataP)
|
|
PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinStatGetAttribute),PACE_DATA32(dataP))
|
|
|
|
PACE_BEGIN(Err StatHide())
|
|
PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinStatHide),NONE)
|
|
|
|
PACE_BEGIN(Err StatShow())
|
|
PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinStatShow),NONE)
|
|
|
|
PACE_BEGIN(UInt16 SysSetAutoOffTime(UInt16 seconds))
|
|
PACE_ADD16(seconds)
|
|
PACE_END16(sysTrapSysSetAutoOffTime,NONE,NONE);
|
|
|
|
PACE_BEGIN(Err SysTaskDelay(Int32 delay))
|
|
PACE_ADD32(delay)
|
|
PACE_END16(sysTrapSysTaskDelay,NONE,NONE);
|
|
|
|
PACE_BEGIN(UInt16 SysTicksPerSecond())
|
|
PACE_END16VOID(sysTrapSysTicksPerSecond,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 TimGetTicks())
|
|
PACE_END32VOID(sysTrapTimGetTicks,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemPtr MemPtrNew(UInt32 n))
|
|
PACE_ADD32(n)
|
|
PACE_ENDPTR(sysTrapMemPtrNew,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemChunkFree(MemPtr p))
|
|
PACE_ADD32(p)
|
|
PACE_END16(sysTrapMemChunkFree,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 MemPtrSize(MemPtr p))
|
|
PACE_ADD32(p)
|
|
PACE_END32(sysTrapMemPtrSize,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemPtrResize(MemPtr p,UInt32 n))
|
|
PACE_ADD32(p)
|
|
PACE_ADD32(n)
|
|
PACE_END16(sysTrapMemPtrResize,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemHeapFreeBytes(UInt16 heapID,UInt32* freeP,UInt32* maxP))
|
|
PACE_ADD16(heapID)
|
|
PACE_ADD32(freeP)
|
|
PACE_ADD32(maxP)
|
|
PACE_END16(sysTrapMemHeapFreeBytes,NONE,PACE_DATA32(freeP) PACE_DATA32(maxP))
|
|
|
|
PACE_BEGIN(UInt16 MemHeapID(UInt16 cardNo, UInt16 heapIndex))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD16(heapIndex)
|
|
PACE_END16(sysTrapMemHeapID,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemHeapCheck(UInt16 heapID))
|
|
PACE_ADD16(heapID)
|
|
PACE_END16(sysTrapMemHeapCheck,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 PrefGetPreference(SystemPreferencesChoice choice))
|
|
PACE_ADD8(choice)
|
|
PACE_END32(sysTrapPrefGetPreference,NONE,NONE)
|
|
|
|
PACE_BEGIN(Int16 PrefGetAppPreferences (UInt32 creator, UInt16 id, void *prefs,
|
|
UInt16 *prefsSize, Boolean saved))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(id)
|
|
PACE_ADD32(prefs)
|
|
PACE_ADD32(prefsSize)
|
|
PACE_ADD8(saved)
|
|
PACE_END16(sysTrapPrefGetAppPreferences,PACE_DATA16(prefsSize),PACE_DATA16(prefsSize))
|
|
|
|
PACE_BEGIN(void PrefSetAppPreferences (UInt32 creator, UInt16 id, Int16 version, const void *prefs,
|
|
UInt16 prefsSize, Boolean saved))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(id)
|
|
PACE_ADD16(version)
|
|
PACE_ADD32(prefs)
|
|
PACE_ADD16(prefsSize)
|
|
PACE_ADD8(saved)
|
|
PACE_END(sysTrapPrefSetAppPreferences,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 FrmCustomAlert(UInt16 alertId,const Char *s1,const Char *s2,const Char *s3))
|
|
PACE_ADD16(alertId)
|
|
PACE_ADD32(s1)
|
|
PACE_ADD32(s2)
|
|
PACE_ADD32(s3)
|
|
PACE_END16(sysTrapFrmCustomAlert,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmGetObjectBounds (const FormType *formP, UInt16 objIndex,RectangleType *rP))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_ADD32(rP)
|
|
PACE_END(sysTrapFrmGetObjectBounds,NONE,SwapStruct(rP,2,2,2,2,0))
|
|
|
|
PACE_BEGIN(void WinGetDisplayExtent (Coord *extentX, Coord *extentY))
|
|
PACE_ADD32(extentX)
|
|
PACE_ADD32(extentY)
|
|
PACE_END(sysTrapWinGetDisplayExtent,NONE,PACE_DATA16(extentX) PACE_DATA16(extentY))
|
|
|
|
PACE_BEGIN(void WinGetBounds(WinHandle winH, RectangleType *rP))
|
|
PACE_ADD32(winH)
|
|
PACE_ADD32(rP)
|
|
PACE_END(sysTrapWinGetBounds,NONE,SwapStruct(rP,2,2,2,2,0))
|
|
|
|
PACE_BEGINEX(void WinSetBounds (WinHandle winHandle, const RectangleType *rP),r)
|
|
PACE_ADD16(rP->topLeft.x)
|
|
PACE_ADD16(rP->topLeft.y)
|
|
PACE_ADD16(rP->extent.x)
|
|
PACE_ADD16(rP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD32(winHandle)
|
|
PACE_ADD32(r)
|
|
PACE_END(sysTrapWinSetBounds,NONE,NONE)
|
|
|
|
PACE_BEGINEX(void FrmSetObjectBounds (FormType *formP, UInt16 objIndex,const RectangleType *bounds),r)
|
|
PACE_ADD16(bounds->topLeft.x)
|
|
PACE_ADD16(bounds->topLeft.y)
|
|
PACE_ADD16(bounds->extent.x)
|
|
PACE_ADD16(bounds->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_ADD32(r)
|
|
PACE_END(sysTrapFrmSetObjectBounds,NONE,NONE)
|
|
|
|
PACE_BEGINEX(void WinDrawRectangle (const RectangleType *rP, UInt16 cornerDiam),r)
|
|
PACE_ADD16(rP->topLeft.x)
|
|
PACE_ADD16(rP->topLeft.y)
|
|
PACE_ADD16(rP->extent.x)
|
|
PACE_ADD16(rP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD32(r)
|
|
PACE_ADD16(cornerDiam)
|
|
PACE_END(sysTrapWinDrawRectangle,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinDrawBitmap (BitmapPtr bitmapP, Coord x, Coord y))
|
|
PACE_ADD32(bitmapP)
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_END(sysTrapWinDrawBitmap,NONE,NONE)
|
|
|
|
PACE_BEGINEX(void WinEraseRectangle(const RectangleType *rP, UInt16 cornerDiam),r)
|
|
PACE_ADD16(rP->topLeft.x)
|
|
PACE_ADD16(rP->topLeft.y)
|
|
PACE_ADD16(rP->extent.x)
|
|
PACE_ADD16(rP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD32(r)
|
|
PACE_ADD16(cornerDiam)
|
|
PACE_END(sysTrapWinEraseRectangle,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinDrawChars(const Char *chars, Int16 len, Coord x, Coord y))
|
|
PACE_ADD32(chars)
|
|
PACE_ADD16(len)
|
|
PACE_ADD16(x)
|
|
PACE_ADD16(y)
|
|
PACE_END(sysTrapWinDrawChars,NONE,NONE)
|
|
|
|
PACE_BEGIN(SysAppInfoPtr SysGetAppInfo(SysAppInfoPtr *uiAppPP, SysAppInfoPtr* actionCodeAppPP))
|
|
PACE_ADD32(uiAppPP)
|
|
PACE_ADD32(actionCodeAppPP)
|
|
PACE_ENDPTR(sysTrapSysGetAppInfo,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemPtr MemChunkNew(UInt16 heapID, UInt32 size, UInt16 attr))
|
|
PACE_ADD16(heapID)
|
|
PACE_ADD32(size)
|
|
PACE_ADD16(attr)
|
|
PACE_ENDPTR(sysTrapMemChunkNew,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err VFSVolumeEnumerate(UInt16 *volRefNumP, UInt32 *volIteratorP))
|
|
PACE_ADD32(volRefNumP)
|
|
PACE_ADD32(volIteratorP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeEnumerate) PACE_DATA32(volIteratorP),PACE_DATA16(volRefNumP) PACE_DATA32(volIteratorP))
|
|
|
|
PACE_BEGIN(Err VFSVolumeGetLabel(UInt16 volRefNum, Char *labelP, UInt16 bufLen))
|
|
PACE_ADD16(volRefNum)
|
|
PACE_ADD32(labelP)
|
|
PACE_ADD16(bufLen)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeGetLabel),NONE)
|
|
|
|
PACE_BEGIN(Err VFSVolumeInfo(UInt16 volRefNum, VolumeInfoType *volInfoP))
|
|
PACE_ADD16(volRefNum)
|
|
PACE_ADD32(volInfoP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeInfo),SwapStruct(volInfoP,4,4,4,4,2,2,4,4,0))
|
|
|
|
PACE_BEGIN(Err FtrPtrFree(UInt32 creator, UInt16 featureNum))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(featureNum)
|
|
PACE_END16(sysTrapFtrPtrFree,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err FtrGet(UInt32 creator, UInt16 featureNum, UInt32 *valueP))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(featureNum)
|
|
PACE_ADD32(valueP)
|
|
PACE_END16(sysTrapFtrGet,NONE,PACE_DATA32(valueP))
|
|
|
|
PACE_BEGIN(Err FtrSet(UInt32 creator, UInt16 featureNum, UInt32 newValue))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(featureNum)
|
|
PACE_ADD32(newValue)
|
|
PACE_END16(sysTrapFtrSet,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err FtrPtrNew(UInt32 creator, UInt16 featureNum, UInt32 size,void **newPtrP))
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(featureNum)
|
|
PACE_ADD32(size)
|
|
PACE_ADD32(newPtrP)
|
|
PACE_END16(sysTrapFtrPtrNew,NONE,PACE_DATA32((UInt32*)newPtrP))
|
|
|
|
PACE_BEGIN(Err DmWrite(void *recordP, UInt32 offset, const void *srcP, UInt32 bytes))
|
|
PACE_ADD32(recordP)
|
|
PACE_ADD32(offset)
|
|
PACE_ADD32(srcP)
|
|
PACE_ADD32(bytes)
|
|
PACE_END16(sysTrapDmWrite,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemHandle DmGetResource(DmResType type, DmResID resID))
|
|
PACE_ADD32(type)
|
|
PACE_ADD16(resID)
|
|
PACE_ENDPTR(sysTrapDmGetResource,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err DmReleaseResource(MemHandle resourceH))
|
|
PACE_ADD32(resourceH)
|
|
PACE_END16(sysTrapDmReleaseResource,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 MemHandleSize(MemHandle h))
|
|
PACE_ADD32(h)
|
|
PACE_END32(sysTrapMemHandleSize,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemPtr MemHandleLock(MemHandle h))
|
|
PACE_ADD32(h)
|
|
PACE_ENDPTR(sysTrapMemHandleLock,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemHandleUnlock(MemHandle h))
|
|
PACE_ADD32(h)
|
|
PACE_END16(sysTrapMemHandleUnlock,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemPtrUnlock(MemPtr h))
|
|
PACE_ADD32(h)
|
|
PACE_END16(sysTrapMemPtrUnlock,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err DmGetNextDatabaseByTypeCreator(Boolean newSearch, DmSearchStatePtr stateInfoP,
|
|
UInt32 type, UInt32 creator, Boolean onlyLatestVers,
|
|
UInt16 *cardNoP, LocalID *dbIDP))
|
|
PACE_ADD8(newSearch)
|
|
PACE_ADD32(stateInfoP)
|
|
PACE_ADD32(type)
|
|
PACE_ADD32(creator)
|
|
PACE_ADD8(onlyLatestVers)
|
|
PACE_ADD32(cardNoP)
|
|
PACE_ADD32(dbIDP)
|
|
PACE_END16(sysTrapDmGetNextDatabaseByTypeCreator,PACE_DATA32(dbIDP),PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
|
|
|
|
PACE_BEGIN(Err DmDatabaseSize(UInt16 cardNo, LocalID dbID, UInt32 *numRecordsP,
|
|
UInt32 *totalBytesP, UInt32 *dataBytesP))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_ADD32(numRecordsP)
|
|
PACE_ADD32(totalBytesP)
|
|
PACE_ADD32(dataBytesP)
|
|
PACE_END16(sysTrapDmDatabaseSize,NONE,
|
|
PACE_CDATA32(numRecordsP)
|
|
PACE_CDATA32(totalBytesP)
|
|
PACE_CDATA32(dataBytesP))
|
|
|
|
PACE_BEGIN(DmOpenRef DmOpenDatabaseByTypeCreator(UInt32 type, UInt32 creator, UInt16 mode))
|
|
PACE_ADD32(type)
|
|
PACE_ADD32(creator)
|
|
PACE_ADD16(mode)
|
|
PACE_ENDPTR(sysTrapDmOpenDatabaseByTypeCreator,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err DmCloseDatabase(DmOpenRef dbP))
|
|
PACE_ADD32(dbP)
|
|
PACE_END16(sysTrapDmCloseDatabase,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err DmDeleteDatabase(UInt16 cardNo, LocalID dbID))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_END16(sysTrapDmDeleteDatabase,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err DmSetDatabaseInfo(UInt16 cardNo, LocalID dbID, const Char *nameP,
|
|
UInt16 *attributesP, UInt16 *versionP, UInt32 *crDateP,
|
|
UInt32 * modDateP, UInt32 *bckUpDateP,
|
|
UInt32 * modNumP, LocalID *appInfoIDP,
|
|
LocalID *sortInfoIDP, UInt32 *typeP,
|
|
UInt32 *creatorP))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_ADD32(nameP)
|
|
PACE_ADD32(attributesP)
|
|
PACE_ADD32(versionP)
|
|
PACE_ADD32(crDateP)
|
|
PACE_ADD32(modDateP)
|
|
PACE_ADD32(bckUpDateP)
|
|
PACE_ADD32(modNumP)
|
|
PACE_ADD32(appInfoIDP)
|
|
PACE_ADD32(sortInfoIDP)
|
|
PACE_ADD32(typeP)
|
|
PACE_ADD32(creatorP)
|
|
PACE_END16(sysTrapDmSetDatabaseInfo,
|
|
PACE_CDATA16(attributesP)
|
|
PACE_CDATA16(versionP)
|
|
PACE_CDATA32(crDateP)
|
|
PACE_CDATA32(modDateP)
|
|
PACE_CDATA32(bckUpDateP)
|
|
PACE_CDATA32(modNumP)
|
|
PACE_CDATA32(appInfoIDP)
|
|
PACE_CDATA32(sortInfoIDP)
|
|
PACE_CDATA32(typeP)
|
|
PACE_CDATA32(creatorP),
|
|
|
|
PACE_CDATA16(attributesP)
|
|
PACE_CDATA16(versionP)
|
|
PACE_CDATA32(crDateP)
|
|
PACE_CDATA32(modDateP)
|
|
PACE_CDATA32(bckUpDateP)
|
|
PACE_CDATA32(modNumP)
|
|
PACE_CDATA32(appInfoIDP)
|
|
PACE_CDATA32(sortInfoIDP)
|
|
PACE_CDATA32(typeP)
|
|
PACE_CDATA32(creatorP))
|
|
|
|
PACE_BEGIN(Err DmDatabaseInfo(UInt16 cardNo, LocalID dbID, Char *nameP,
|
|
UInt16 *attributesP, UInt16 *versionP, UInt32 *crDateP,
|
|
UInt32 *modDateP, UInt32 *bckUpDateP,
|
|
UInt32 *modNumP, LocalID *appInfoIDP,
|
|
LocalID *sortInfoIDP, UInt32 *typeP,
|
|
UInt32 *creatorP))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(dbID)
|
|
PACE_ADD32(nameP)
|
|
PACE_ADD32(attributesP)
|
|
PACE_ADD32(versionP)
|
|
PACE_ADD32(crDateP)
|
|
PACE_ADD32(modDateP)
|
|
PACE_ADD32(bckUpDateP)
|
|
PACE_ADD32(modNumP)
|
|
PACE_ADD32(appInfoIDP)
|
|
PACE_ADD32(sortInfoIDP)
|
|
PACE_ADD32(typeP)
|
|
PACE_ADD32(creatorP)
|
|
PACE_END16(sysTrapDmDatabaseInfo,NONE,
|
|
PACE_CDATA16(attributesP)
|
|
PACE_CDATA16(versionP)
|
|
PACE_CDATA32(crDateP)
|
|
PACE_CDATA32(modDateP)
|
|
PACE_CDATA32(bckUpDateP)
|
|
PACE_CDATA32(modNumP)
|
|
PACE_CDATA32(appInfoIDP)
|
|
PACE_CDATA32(sortInfoIDP)
|
|
PACE_CDATA32(typeP)
|
|
PACE_CDATA32(creatorP))
|
|
|
|
PACE_BEGIN(FileHand FileOpen(UInt16 cardNo, const Char * nameP, UInt32 type, UInt32 creator,
|
|
UInt32 openMode, Err *errP))
|
|
PACE_ADD16(cardNo)
|
|
PACE_ADD32(nameP)
|
|
PACE_ADD32(type)
|
|
PACE_ADD32(creator)
|
|
PACE_ADD32(openMode)
|
|
PACE_ADD32(errP)
|
|
PACE_ENDPTR(sysTrapFileOpen,NONE,PACE_CDATA16(errP))
|
|
|
|
PACE_BEGIN(Err FileClose(FileHand stream))
|
|
PACE_ADD32(stream)
|
|
PACE_END16(sysTrapFileClose,NONE,NONE)
|
|
|
|
PACE_BEGIN(Int32 FileReadLow(FileHand stream, void *baseP, Int32 offset, Boolean dataStoreBased, Int32 objSize,
|
|
Int32 numObj, Err *errP))
|
|
PACE_ADD32(stream)
|
|
PACE_ADD32(baseP)
|
|
PACE_ADD32(offset)
|
|
PACE_ADD8(dataStoreBased)
|
|
PACE_ADD32(objSize)
|
|
PACE_ADD32(numObj)
|
|
PACE_ADD32(errP)
|
|
PACE_END32(sysTrapFileReadLow,NONE,PACE_CDATA16(errP))
|
|
|
|
PACE_BEGIN(Err FileSeek(FileHand stream, Int32 offset, FileOriginEnum origin))
|
|
PACE_ADD32(stream)
|
|
PACE_ADD32(offset)
|
|
PACE_ADD8(origin)
|
|
PACE_END16(sysTrapFileSeek,NONE,NONE)
|
|
|
|
PACE_BEGIN(Int32 FileTell(FileHand stream, Int32 *fileSizeP, Err *errP))
|
|
PACE_ADD32(stream)
|
|
PACE_ADD32(fileSizeP)
|
|
PACE_ADD32(errP)
|
|
PACE_END32(sysTrapFileTell,NONE,PACE_CDATA32(fileSizeP) PACE_CDATA16(errP))
|
|
|
|
PACE_BEGIN(void WinGetClip(RectangleType *rP))
|
|
PACE_ADD32(rP)
|
|
PACE_END(sysTrapWinGetClip,NONE,SwapStruct(rP,2,2,2,2,0))
|
|
|
|
PACE_BEGINEX(void WinSetClip (const RectangleType *rP),r)
|
|
PACE_ADD16(rP->topLeft.x)
|
|
PACE_ADD16(rP->topLeft.y)
|
|
PACE_ADD16(rP->extent.x)
|
|
PACE_ADD16(rP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD32(r)
|
|
PACE_END(sysTrapWinSetClip,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinPushDrawState())
|
|
PACE_ENDVOID(sysTrapWinPushDrawState,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinPopDrawState())
|
|
PACE_ENDVOID(sysTrapWinPopDrawState,NONE,NONE)
|
|
|
|
PACE_BEGIN(void SclSetScrollBar (ScrollBarType *bar, Int16 value, Int16 min, Int16 max, Int16 pageSize))
|
|
PACE_ADD32(bar)
|
|
PACE_ADD16(value)
|
|
PACE_ADD16(min)
|
|
PACE_ADD16(max)
|
|
PACE_ADD16(pageSize)
|
|
PACE_END(sysTrapSclSetScrollBar,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt16 WinSetCoordinateSystem(UInt16 coordSys))
|
|
PACE_ADD16(coordSys)
|
|
PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinSetCoordinateSystem),NONE)
|
|
|
|
PACE_BEGIN(Coord WinScaleCoord(Coord coord, Boolean ceiling))
|
|
PACE_ADD16(coord)
|
|
PACE_ADD8(ceiling)
|
|
PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinScaleCoord),NONE)
|
|
|
|
PACE_BEGIN(UInt16 WinGetCoordinateSystem())
|
|
PACE_END16VOID(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinGetCoordinateSystem),NONE)
|
|
|
|
PACE_BEGIN(Err WinScreenGetAttribute(WinScreenAttrType selector, UInt32* attrP))
|
|
PACE_ADD8(selector)
|
|
PACE_ADD32(attrP)
|
|
PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinScreenGetAttribute),PACE_DATA32(attrP))
|
|
|
|
PACE_BEGIN(Err WinScreenMode(WinScreenModeOperation operation,
|
|
UInt32 *widthP,
|
|
UInt32 *heightP,
|
|
UInt32 *depthP,
|
|
Boolean *enableColorP))
|
|
PACE_ADD8(operation)
|
|
PACE_ADD32(widthP)
|
|
PACE_ADD32(heightP)
|
|
PACE_ADD32(depthP)
|
|
PACE_ADD32(enableColorP)
|
|
PACE_END16(sysTrapWinScreenMode,PACE_CDATA32(widthP) PACE_CDATA32(heightP) PACE_CDATA32(depthP),
|
|
PACE_CDATA32(widthP) PACE_CDATA32(heightP) PACE_CDATA32(depthP))
|
|
|
|
PACE_BEGIN(Err WinPalette(UInt8 operation, Int16 startIndex,
|
|
UInt16 paletteEntries, RGBColorType *tableP))
|
|
PACE_ADD8(operation)
|
|
PACE_ADD16(startIndex)
|
|
PACE_ADD16(paletteEntries)
|
|
PACE_ADD32(tableP)
|
|
PACE_END16(sysTrapWinPalette,NONE,NONE)
|
|
|
|
PACE_BEGIN(WinHandle WinGetDisplayWindow())
|
|
PACE_ENDPTRVOID(sysTrapWinGetDisplayWindow,NONE,NONE)
|
|
|
|
PACE_BEGIN(WinHandle WinGetActiveWindow())
|
|
PACE_ENDPTRVOID(sysTrapWinGetActiveWindow,NONE,NONE)
|
|
|
|
PACE_BEGIN(BitmapType *WinGetBitmap(WinHandle winHandle))
|
|
PACE_ADD32(winHandle)
|
|
PACE_ENDPTR(sysTrapWinGetBitmap,NONE,NONE)
|
|
|
|
PACE_BEGIN(void BmpGetDimensions(const BitmapType * bitmapP,Coord *widthP,Coord *heightP,UInt16 *rowBytesP))
|
|
PACE_ADD32(bitmapP)
|
|
PACE_ADD32(widthP)
|
|
PACE_ADD32(heightP)
|
|
PACE_ADD32(rowBytesP)
|
|
PACE_END(sysTrapBmpGetDimensions,NONE,PACE_CDATA16(widthP) PACE_CDATA16(heightP) PACE_CDATA16(rowBytesP))
|
|
|
|
PACE_BEGIN(void* BmpGetBits(BitmapType * bitmapP))
|
|
PACE_ADD32(bitmapP)
|
|
PACE_ENDPTR(sysTrapBmpGetBits,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinSetBackColorRGB(const RGBColorType* newRgbP, RGBColorType* prevRgbP))
|
|
PACE_ADD32(newRgbP)
|
|
PACE_ADD32(prevRgbP)
|
|
PACE_END(sysTrapWinSetBackColorRGB,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err VFSRegisterDefaultDirectory(const Char *fileTypeStr, UInt32 mediaType,
|
|
const Char *pathStr))
|
|
PACE_ADD32(fileTypeStr)
|
|
PACE_ADD32(mediaType)
|
|
PACE_ADD32(pathStr)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapRegisterDefaultDirectory),NONE)
|
|
|
|
PACE_BEGIN(Err VFSGetDefaultDirectory(UInt16 volRefNum, const Char *fileTypeStr,Char *pathStr, UInt16 *bufLenP))
|
|
PACE_ADD16(volRefNum)
|
|
PACE_ADD32(fileTypeStr)
|
|
PACE_ADD32(pathStr)
|
|
PACE_ADD32(bufLenP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapGetDefaultDirectory) PACE_DATA16(bufLenP),PACE_DATA16(bufLenP));
|
|
|
|
PACE_BEGIN(Err VFSImportDatabaseFromFile(UInt16 volRefNum, const Char *pathNameP, UInt16 *cardNoP, LocalID *dbIDP))
|
|
PACE_ADD16(volRefNum)
|
|
PACE_ADD32(pathNameP)
|
|
PACE_ADD32(cardNoP)
|
|
PACE_ADD32(dbIDP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapImportDatabaseFromFile),PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
|
|
|
|
PACE_BEGIN(Err VFSFileOpen(UInt16 volRefNum, const Char *pathNameP, UInt16 openMode, FileRef *fileRefP))
|
|
PACE_ADD16(volRefNum)
|
|
PACE_ADD32(pathNameP)
|
|
PACE_ADD16(openMode)
|
|
PACE_ADD32(fileRefP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileOpen),PACE_DATA32(fileRefP))
|
|
|
|
PACE_BEGIN(Err VFSFileClose(FileRef fileRef))
|
|
PACE_ADD32(fileRef)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileClose),NONE)
|
|
|
|
PACE_BEGIN(Err VFSFileSize(FileRef fileRef,UInt32 *fileSizeP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(fileSizeP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileSize),PACE_DATA32(fileSizeP))
|
|
|
|
PACE_BEGIN(Err VFSFileGetDate(FileRef fileRef, UInt16 whichDate, UInt32 *dateP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD16(whichDate)
|
|
PACE_ADD32(dateP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileGetDate),PACE_DATA32(dateP))
|
|
|
|
PACE_BEGIN(Err VFSDirEntryEnumerate(FileRef dirRef,UInt32 *dirEntryIteratorP, FileInfoType *infoP))
|
|
PACE_ADD32(dirRef)
|
|
PACE_ADD32(dirEntryIteratorP)
|
|
PACE_ADD32(infoP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapDirEntryEnumerate)
|
|
PACE_DATA32(dirEntryIteratorP)
|
|
SwapStruct(infoP,4,4,2,0),
|
|
PACE_DATA32(dirEntryIteratorP)
|
|
SwapStruct(infoP,4,4,2,0))
|
|
|
|
PACE_BEGIN(Err VFSFileGetAttributes(FileRef fileRef, UInt32 *attributesP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(attributesP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileGetAttributes),PACE_DATA32(attributesP))
|
|
|
|
PACE_BEGIN(Err VFSFileReadData(FileRef fileRef, UInt32 numBytes, void *bufBaseP, UInt32 offset, UInt32 *numBytesReadP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(numBytes)
|
|
PACE_ADD32(bufBaseP)
|
|
PACE_ADD32(offset)
|
|
PACE_ADD32(numBytesReadP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileReadData),PACE_CDATA32(numBytesReadP))
|
|
|
|
PACE_BEGIN(Err VFSFileRead(FileRef fileRef, UInt32 numBytes, void *bufP, UInt32 *numBytesReadP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(numBytes)
|
|
PACE_ADD32(bufP)
|
|
PACE_ADD32(numBytesReadP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileRead),PACE_CDATA32(numBytesReadP))
|
|
|
|
PACE_BEGIN(Err VFSFileWrite(FileRef fileRef, UInt32 numBytes, const void *dataP, UInt32 *numBytesWrittenP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(numBytes)
|
|
PACE_ADD32(dataP)
|
|
PACE_ADD32(numBytesWrittenP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileWrite),PACE_DATA32(numBytesWrittenP))
|
|
|
|
PACE_BEGIN(Err VFSFileSeek(FileRef fileRef, FileOrigin origin, Int32 offset))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD16(origin)
|
|
PACE_ADD32(offset)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileSeek),NONE)
|
|
|
|
PACE_BEGIN(Err VFSFileTell(FileRef fileRef,UInt32 *filePosP))
|
|
PACE_ADD32(fileRef)
|
|
PACE_ADD32(filePosP)
|
|
PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileTell),PACE_DATA32(filePosP))
|
|
|
|
PACE_BEGIN(UInt32 PceNativeCall(NativeFuncType *nativeFuncP, void *userDataP))
|
|
PACE_ADD32(nativeFuncP)
|
|
PACE_ADD32(userDataP)
|
|
PACE_END32(sysTrapPceNativeCall,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt8 *WinScreenLock(WinLockInitType initMode))
|
|
PACE_ADD8(initMode)
|
|
PACE_ENDPTR(sysTrapWinScreenLock,NONE,NONE)
|
|
|
|
PACE_BEGIN(void WinScreenUnlock())
|
|
PACE_ENDVOID(sysTrapWinScreenUnlock,NONE,NONE)
|
|
|
|
PACE_BEGIN(void LstSetHeight (ListType *listP, Int16 visibleItems))
|
|
PACE_ADD32(listP)
|
|
PACE_ADD16(visibleItems)
|
|
PACE_END(sysTrapLstSetHeight,NONE,NONE);
|
|
|
|
PACE_BEGIN(void LstSetListChoices (ListType *listP, Char **itemsText, Int16 numItems))
|
|
PACE_ADD32(listP)
|
|
PACE_ADD32(itemsText)
|
|
PACE_ADD16(numItems)
|
|
PACE_END(sysTrapLstSetListChoices,SwapBlock32(itemsText,numItems),NONE)
|
|
|
|
PACE_BEGIN(void LstSetSelection(ListType *listP, Int16 itemNum))
|
|
PACE_ADD32(listP)
|
|
PACE_ADD16(itemNum)
|
|
PACE_END(sysTrapLstSetSelection,NONE,NONE)
|
|
|
|
PACE_BEGIN(Char* LstGetSelectionText(const ListType *listP, Int16 itemNum))
|
|
PACE_ADD32(listP)
|
|
PACE_ADD16(itemNum)
|
|
PACE_ENDPTR(sysTrapLstGetSelectionText,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemHandle MemHandleNew(UInt32 size))
|
|
PACE_ADD32(size)
|
|
PACE_ENDPTR(sysTrapMemHandleNew,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err MemHandleFree(MemHandle h))
|
|
PACE_ADD32(h)
|
|
PACE_END16(sysTrapMemHandleFree,NONE,NONE)
|
|
|
|
PACE_BEGIN(Char* FldGetTextPtr(const FieldType *fldP))
|
|
PACE_ADD32(fldP)
|
|
PACE_ENDPTR(sysTrapFldGetTextPtr,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FldSetTextHandle(FieldType *fldP, MemHandle textHandle))
|
|
PACE_ADD32(fldP)
|
|
PACE_ADD32(textHandle)
|
|
PACE_END(sysTrapFldSetTextHandle,NONE,NONE)
|
|
|
|
PACE_BEGIN(MemHandle FldGetTextHandle(const FieldType *fldP))
|
|
PACE_ADD32(fldP)
|
|
PACE_ENDPTR(sysTrapFldGetTextHandle,NONE,NONE)
|
|
|
|
PACE_BEGIN(void SndPlaySystemSound(SndSysBeepType beepID))
|
|
PACE_ADD8(beepID)
|
|
PACE_END(sysTrapSndPlaySystemSound,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamCreate(SndStreamRef *channel,SndStreamMode mode,UInt32 samplerate,
|
|
SndSampleType type,SndStreamWidth width,SndStreamBufferCallback func,
|
|
void *userdata,UInt32 buffsize,Boolean armNative))
|
|
PACE_ADD32(channel)
|
|
PACE_ADD8(mode)
|
|
PACE_ADD32(samplerate)
|
|
PACE_ADD16(type)
|
|
PACE_ADD8(width)
|
|
PACE_ADD32(func)
|
|
PACE_ADD32(userdata)
|
|
PACE_ADD32(buffsize)
|
|
PACE_ADD8(armNative)
|
|
PACE_END16(sysTrapSndStreamCreate,NONE,PACE_DATA32(channel))
|
|
|
|
PACE_BEGIN(Err SndStreamDelete(SndStreamRef channel))
|
|
PACE_ADD32(channel)
|
|
PACE_END16(sysTrapSndStreamDelete,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamStart(SndStreamRef channel))
|
|
PACE_ADD32(channel)
|
|
PACE_END16(sysTrapSndStreamStart,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamPause(SndStreamRef channel, Boolean pause))
|
|
PACE_ADD32(channel)
|
|
PACE_ADD8(pause)
|
|
PACE_END16(sysTrapSndStreamPause,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamStop(SndStreamRef channel))
|
|
PACE_ADD32(channel)
|
|
PACE_END16(sysTrapSndStreamStop,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamSetPan(SndStreamRef channel, Int32 panposition))
|
|
PACE_ADD32(channel)
|
|
PACE_ADD32(panposition)
|
|
PACE_END16(sysTrapSndStreamSetPan,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamSetVolume(SndStreamRef channel, Int32 volume))
|
|
PACE_ADD32(channel)
|
|
PACE_ADD32(volume)
|
|
PACE_END16(sysTrapSndStreamSetVolume,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SndStreamGetVolume(SndStreamRef channel, Int32 *volume))
|
|
PACE_ADD32(channel)
|
|
PACE_ADD32(volume)
|
|
PACE_END16(sysTrapSndStreamGetVolume,NONE,PACE_DATA32(volume))
|
|
|
|
PACE_BEGINEVENT(Boolean SysHandleEvent(EventPtr eventP))
|
|
PACE_ADD32(&ev)
|
|
PACE_END8(sysTrapSysHandleEvent,Event_ARM_To_M68K(eventP,ev),NONE)
|
|
|
|
PACE_BEGIN(void CtlDrawControl (ControlType *controlP))
|
|
PACE_ADD32(controlP)
|
|
PACE_END(sysTrapCtlDrawControl,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmCopyLabel (FormType *formP, UInt16 labelID,const Char *newLabel))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(labelID)
|
|
PACE_ADD32(newLabel)
|
|
PACE_END(sysTrapFrmCopyLabel,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FldDrawField (FieldType *fldP))
|
|
PACE_ADD32(fldP)
|
|
PACE_END(sysTrapFldDrawField,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FldSetTextPtr (FieldType *fldP, Char *textP))
|
|
PACE_ADD32(fldP)
|
|
PACE_ADD32(textP)
|
|
PACE_END(sysTrapFldSetTextPtr,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormType *FrmGetFormPtr(UInt16 formId))
|
|
PACE_ADD16(formId)
|
|
PACE_ENDPTR(sysTrapFrmGetFormPtr,NONE,NONE)
|
|
|
|
PACE_BEGIN(FormType* FrmGetActiveForm())
|
|
PACE_ENDPTRVOID(sysTrapFrmGetActiveForm,NONE,NONE)
|
|
|
|
PACE_BEGINEVENT(Boolean FrmHandleEvent(FormType *formP, EventType *eventP))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD32(&ev)
|
|
PACE_END8(sysTrapFrmHandleEvent,Event_ARM_To_M68K(eventP,ev),NONE)
|
|
|
|
PACE_BEGIN(void FrmHideObject(FormType *formP, UInt16 objIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_END(sysTrapFrmHideObject,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmShowObject (FormType *formP, UInt16 objIndex))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_END(sysTrapFrmShowObject,NONE,NONE)
|
|
|
|
PACE_BEGINEVENT(static Boolean _FrmDispatchEvent(EventType *eventP))
|
|
PACE_ADD32(&ev)
|
|
PACE_END8(sysTrapFrmDispatchEvent,Event_ARM_To_M68K(eventP,ev),NONE)
|
|
|
|
PACE_BEGIN(static void _FrmSetGadgetHandler(FormType *formP, UInt16 objIndex,FormGadgetHandlerType *attrP))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objIndex)
|
|
PACE_ADD32(attrP)
|
|
PACE_END(sysTrapFrmSetGadgetHandler,NONE,NONE)
|
|
|
|
PACE_BEGIN(static void _FrmSetEventHandler(FormType *formP,FormEventHandlerType *handler))
|
|
PACE_ADD32(formP)
|
|
PACE_ADD32(handler)
|
|
PACE_END(sysTrapFrmSetEventHandler,NONE,NONE)
|
|
|
|
PACE_BEGIN(static void _FrmDeleteForm(FormType *formP))
|
|
PACE_ADD32(formP)
|
|
PACE_END(sysTrapFrmDeleteForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(static void _FrmReturnToForm(UInt16 formId))
|
|
PACE_ADD16(formId)
|
|
PACE_END(sysTrapFrmReturnToForm,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err EvtEnqueueKey(WChar ascii, UInt16 keycode, UInt16 modifiers))
|
|
PACE_ADD16(ascii)
|
|
PACE_ADD16(keycode)
|
|
PACE_ADD16(modifiers)
|
|
PACE_END16(sysTrapEvtEnqueueKey,NONE,NONE)
|
|
|
|
PACE_BEGIN(FontID FntSetFont(FontID font))
|
|
PACE_ADD8(font)
|
|
PACE_END8(sysTrapFntSetFont,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 KeyCurrentState())
|
|
PACE_END32VOID(sysTrapKeyCurrentState,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 TimGetSeconds(void))
|
|
PACE_END32VOID(sysTrapTimGetSeconds,NONE,NONE)
|
|
|
|
PACE_BEGIN(void TimSecondsToDateTime(UInt32 seconds, DateTimeType *dateTimeP))
|
|
PACE_ADD32(seconds)
|
|
PACE_ADD32(dateTimeP)
|
|
PACE_END(sysTrapTimSecondsToDateTime,NONE,SwapStruct(dateTimeP,2,2,2,2,2,2,2,0))
|
|
|
|
/*PACE_BEGIN(Err KeyRates(Boolean set, UInt16 *initDelayP, UInt16 *periodP,
|
|
UInt16 *doubleTapDelayP, Boolean *queueAheadP))
|
|
PACE_ADD8(set)
|
|
PACE_ADD32(initDelayP)
|
|
PACE_ADD32(periodP)
|
|
PACE_ADD32(doubleTapDelayP)
|
|
PACE_ADD32(queueAheadP)
|
|
PACE_END16(sysTrapKeyRates,PACE_DATA16(initDelayP) PACE_DATA16(periodP) PACE_DATA16(doubleTapDelayP),
|
|
PACE_DATA16(initDelayP) PACE_DATA16(periodP) PACE_DATA16(doubleTapDelayP))
|
|
*/
|
|
|
|
PACE_BEGIN(Err SysLibOpen(UInt16 refNum))
|
|
PACE_ADD16(refNum)
|
|
PACE_END16(sysLibTrapOpen,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err SysLibClose(UInt16 refNum))
|
|
PACE_ADD16(refNum)
|
|
PACE_END16(sysLibTrapClose,NONE,NONE)
|
|
|
|
PACE_BEGIN(UInt32 RotationMgrGetLibAPIVersion(UInt16 refNum))
|
|
PACE_ADD16(refNum)
|
|
PACE_END32((sysLibTrapCustom+0),NONE,NONE)
|
|
|
|
PACE_BEGIN(Err RotationMgrAttributeGet(UInt16 refNum, UInt32 attribute, UInt32 *valueP))
|
|
PACE_ADD16(refNum)
|
|
PACE_ADD32(attribute)
|
|
PACE_ADD32(valueP)
|
|
PACE_END16((sysLibTrapCustom+5),NONE,PACE_DATA32(valueP));
|
|
|
|
PACE_BEGIN(UInt16 SysBatteryInfo(Boolean set, UInt16 *warnThresholdP, UInt16 *criticalThresholdP,
|
|
Int16 *maxTicksP, SysBatteryKind* kindP, Boolean *pluggedIn, UInt8 *percentP))
|
|
PACE_ADD8(set)
|
|
PACE_ADD32(warnThresholdP)
|
|
PACE_ADD32(criticalThresholdP)
|
|
PACE_ADD32(maxTicksP)
|
|
PACE_ADD32(kindP)
|
|
PACE_ADD32(pluggedIn)
|
|
PACE_ADD32(percentP)
|
|
PACE_END16(sysTrapSysBatteryInfo,NONE,PACE_CDATA16(warnThresholdP) PACE_CDATA16(criticalThresholdP) PACE_CDATA16(maxTicksP))
|
|
|
|
#ifdef HAVE_PALMONE_SDK
|
|
|
|
PACE_BEGIN(Err HsNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP,
|
|
Int16* extraInfoP, RectangleType* boundsInsideRingP,
|
|
HsNavFocusRingStyleEnum* ringStyleP))
|
|
PACE_ADD16(hsSelNavGetFocusRingInfo)
|
|
PACE_ADD32(formP)
|
|
PACE_ADD32(objectIDP)
|
|
PACE_ADD32(extraInfoP)
|
|
PACE_ADD32(boundsInsideRingP)
|
|
PACE_ADD32(ringStyleP)
|
|
PACE_END16(sysTrapOEMDispatch, NONE, PACE_CDATA16(objectIDP) PACE_CDATA16(extraInfoP) PACE_CDATA16(ringStyleP) SwapStruct(boundsInsideRingP,2,2,2,2,0))
|
|
|
|
PACE_BEGINEX(Err HsNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
|
|
RectangleType* boundsInsideRingP,
|
|
HsNavFocusRingStyleEnum ringStyle, Boolean forceRestore),r)
|
|
PACE_ADD16(boundsInsideRingP->topLeft.x)
|
|
PACE_ADD16(boundsInsideRingP->topLeft.y)
|
|
PACE_ADD16(boundsInsideRingP->extent.x)
|
|
PACE_ADD16(boundsInsideRingP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD16(hsSelNavDrawFocusRing)
|
|
PACE_ADD16(objectID)
|
|
PACE_ADD16(extraInfo)
|
|
PACE_ADD32(r)
|
|
PACE_ADD16(ringStyle)
|
|
PACE_ADD8(forceRestore)
|
|
PACE_END16(sysTrapOEMDispatch,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err HsNavRemoveFocusRing (FormType* formP))
|
|
PACE_ADD16(hsSelNavRemoveFocusRing)
|
|
PACE_ADD32(formP)
|
|
PACE_END16(sysTrapOEMDispatch,NONE,NONE)
|
|
|
|
PACE_BEGIN(void HsNavObjectTakeFocus (const FormType* formP, UInt16 objID))
|
|
PACE_ADD16(hsSelNavObjectTakeFocus)
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objID)
|
|
PACE_END(sysTrapOEMDispatch,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err HsLightCircumstance(Boolean add, UInt16 circumstance))
|
|
PACE_ADD16(hsSelLightCircumstance)
|
|
PACE_ADD8(add)
|
|
PACE_ADD16(circumstance)
|
|
PACE_END16(sysTrapOEMDispatch, NONE, NONE)
|
|
|
|
PACE_BEGIN(UInt16 HsCurrentLightCircumstance())
|
|
PACE_ADD16(hsGetCurrentLightCircumstance)
|
|
PACE_END16(sysTrapOEMDispatch, NONE, NONE)
|
|
|
|
PACE_BEGIN(Err HsAttrGet(UInt16 attr, UInt32 param, UInt32* valueP))
|
|
PACE_ADD16(hsSelAttrGet)
|
|
PACE_ADD16(attr)
|
|
PACE_ADD32(param)
|
|
PACE_ADD32(valueP)
|
|
PACE_END16(sysTrapOEMDispatch, NONE, PACE_DATA32(valueP))
|
|
|
|
PACE_BEGIN(Err HsAttrSet(UInt16 attr, UInt32 param, UInt32* valueP))
|
|
PACE_ADD16(hsSelAttrSet)
|
|
PACE_ADD16(attr)
|
|
PACE_ADD32(param)
|
|
PACE_ADD32(valueP)
|
|
PACE_END16(sysTrapOEMDispatch, PACE_DATA32(valueP), PACE_DATA32(valueP))
|
|
|
|
PACE_BEGIN(Err HWUBlinkLED(UInt16 refnum, Boolean b))
|
|
PACE_ADD16(refnum)
|
|
PACE_ADD8(b)
|
|
PACE_END16((sysLibTrapCustom+0),NONE,NONE)
|
|
|
|
PACE_BEGIN(Err HWUSetBlinkRate(UInt16 refnum, UInt16 rate))
|
|
PACE_ADD16(refnum)
|
|
PACE_ADD16(rate)
|
|
PACE_END16((sysLibTrapCustom+1),NONE,NONE)
|
|
|
|
PACE_BEGIN(Err HWUEnableDisplay(UInt16 refnum, Boolean on))
|
|
PACE_ADD16(refnum)
|
|
PACE_ADD8(on)
|
|
PACE_END16((sysLibTrapCustom+2),NONE,NONE)
|
|
|
|
PACE_BEGIN(Boolean HWUGetDisplayState(UInt16 refnum))
|
|
PACE_ADD16(refnum)
|
|
PACE_END8((sysLibTrapCustom+3),NONE,NONE)
|
|
|
|
PACE_BEGIN(void *DexGetDisplayAddress(UInt16 refnum))
|
|
PACE_ADD16(refnum)
|
|
PACE_ENDPTR((sysLibTrapCustom+4),NONE,NONE)
|
|
|
|
PACE_BEGIN(void DexGetDisplayDimensions(UInt16 refnum, Coord *width, Coord *height, UInt16 *rowBytes))
|
|
PACE_ADD16(refnum)
|
|
PACE_ADD32(width)
|
|
PACE_ADD32(height)
|
|
PACE_ADD32(rowBytes)
|
|
PACE_END((sysLibTrapCustom+5),NONE,PACE_CDATA16(width) PACE_CDATA16(height) PACE_CDATA16(rowBytes))
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SONY_SDK
|
|
|
|
PACE_BEGIN(UInt32 VskGetAPIVersion(UInt16 refNum))
|
|
PACE_ADD16(refNum)
|
|
PACE_END32((sysLibTrapCustom+3),NONE,NONE)
|
|
|
|
PACE_BEGIN(Err VskSetState(UInt16 refNum, UInt16 stateType, UInt16 state))
|
|
PACE_ADD16(refNum)
|
|
PACE_ADD16(stateType)
|
|
PACE_ADD16(state)
|
|
PACE_END16((sysLibTrapCustom+6),NONE,NONE)
|
|
|
|
PACE_BEGIN(Err VskGetState(UInt16 refNum, UInt16 stateType, UInt16 *stateP))
|
|
PACE_ADD16(refNum)
|
|
PACE_ADD16(stateType)
|
|
PACE_ADD32(stateP)
|
|
PACE_END16((sysLibTrapCustom+7),NONE,PACE_DATA16(stateP))
|
|
|
|
#endif
|
|
|
|
PACE_BEGIN(Err SysLibLoad(UInt32 libType, UInt32 libCreator, UInt16 *refNumP))
|
|
PACE_ADD32(libType)
|
|
PACE_ADD32(libCreator)
|
|
PACE_ADD32(refNumP)
|
|
PACE_END16(sysTrapSysLibLoad,NONE,PACE_DATA16(refNumP))
|
|
|
|
PACE_BEGIN(Err SysLibFind(const Char *nameP, UInt16 *refNumP))
|
|
PACE_ADD32(nameP)
|
|
PACE_ADD32(refNumP)
|
|
PACE_END16(sysTrapSysLibFind,NONE,PACE_DATA16(refNumP))
|
|
|
|
NOINLINE MemPtr MemGluePtrNew(UInt32 Size)
|
|
{
|
|
MemPtr p = MemPtrNew(Size);
|
|
if (!p)
|
|
{
|
|
SysAppInfoPtr appInfoP;
|
|
UInt16 OwnerID = SysGetAppInfo(&appInfoP,&appInfoP)->memOwnerID;
|
|
p = MemChunkNew(0, Size,(UInt16)(OwnerID | memNewChunkFlagNonMovable | memNewChunkFlagAllowLarge));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
NOINLINE FormEventHandlerType* FrmGetEventHandler(FormType *Form)
|
|
{
|
|
eventhandler *i,*j;
|
|
for (i=EventHandler,j=NULL;i;j=i,i=i->Next)
|
|
if (i->Form == Form)
|
|
{
|
|
if (j)
|
|
{
|
|
// move ahead for faster search next time
|
|
j->Next = i->Next;
|
|
i->Next = EventHandler;
|
|
EventHandler = i;
|
|
}
|
|
return i->Handler;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
Boolean FrmDispatchEvent(EventType *eventP)
|
|
{
|
|
// avoid using m68k wrapper for some common events (which are sent to the active form)
|
|
|
|
if (eventP->eType == keyHoldEvent || eventP->eType == keyDownEvent ||
|
|
eventP->eType == keyUpEvent || eventP->eType == nilEvent ||
|
|
eventP->eType == penDownEvent || eventP->eType == penMoveEvent ||
|
|
eventP->eType == penUpEvent)
|
|
{
|
|
FormType *Form = FrmGetActiveForm();
|
|
FormEventHandlerType* Handler = FrmGetEventHandler(Form);
|
|
if (Handler)
|
|
{
|
|
// call ARM event handler
|
|
if (Handler(eventP))
|
|
return 1;
|
|
// call system event handler
|
|
return FrmHandleEvent(Form,eventP);
|
|
}
|
|
}
|
|
|
|
return _FrmDispatchEvent(eventP);
|
|
}
|
|
|
|
static void SetCodePtr(uint8_t* p,void* Ptr)
|
|
{
|
|
p[0] = (uint8_t)(((uint32_t)Ptr) >> 24);
|
|
p[1] = (uint8_t)(((uint32_t)Ptr) >> 16);
|
|
p[2] = (uint8_t)(((uint32_t)Ptr) >> 8);
|
|
p[3] = (uint8_t)(((uint32_t)Ptr) >> 0);
|
|
}
|
|
|
|
static void RemoveHandler(FormType *Form)
|
|
{
|
|
eventhandler* i;
|
|
for (i=EventHandler;i;i=i->Next)
|
|
if (i->Form == Form)
|
|
i->Form = NULL;
|
|
}
|
|
|
|
void FrmDeleteForm( FormType *formP )
|
|
{
|
|
_FrmDeleteForm(formP);
|
|
RemoveHandler(formP);
|
|
}
|
|
|
|
void FrmReturnToForm( UInt16 formId )
|
|
{
|
|
FormType* Form = FrmGetActiveForm();
|
|
_FrmReturnToForm(formId);
|
|
RemoveHandler(Form);
|
|
}
|
|
|
|
void* m68kCallBack(m68kcallback p,NativeFuncType* Func)
|
|
{
|
|
static const uint8_t Code[24] =
|
|
{ 0x4E,0x56,0x00,0x00, // link a6,#0
|
|
0x48,0x6E,0x00,0x08, // pea 8(a6)
|
|
0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l #$ARM,-(sp)
|
|
0x4E,0x4F, // trap #$F
|
|
0xA4,0x5A, // dc.w $A45A
|
|
0x70,0x00, // moveq #0,d0
|
|
0x4E,0x5E, // unlk a6
|
|
0x4E,0x75 }; // rts
|
|
|
|
memcpy(p,Code,sizeof(m68kcallback));
|
|
SetCodePtr((uint8_t*)p+10,(void*)(uint32_t)Func);
|
|
return p;
|
|
}
|
|
|
|
void FrmSetGadgetHandler(FormType *formP, UInt16 objIndex,FormGadgetHandlerType *attrP)
|
|
{
|
|
gadgethandler* i;
|
|
gadgethandler* Free = NULL;
|
|
for (i=GadgetHandler;i;i=i->Next)
|
|
{
|
|
if (i->Form == formP && i->Index == objIndex)
|
|
break;
|
|
if (!i->Form)
|
|
Free = i;
|
|
}
|
|
if (!i)
|
|
{
|
|
if (Free)
|
|
i = Free;
|
|
else
|
|
{
|
|
i = MemGluePtrNew(sizeof(gadgethandler));
|
|
i->Next = GadgetHandler;
|
|
GadgetHandler = i;
|
|
}
|
|
}
|
|
|
|
if (i)
|
|
{
|
|
static const uint8_t Code[68] =
|
|
{ 0x4E,0x56,0x00,0x00, // link a6,#0
|
|
0x30,0x2E,0x00,0x0C, // move.w $C(a6),d0
|
|
0x22,0x2E,0x00,0x0E, // move.l $E(a6),d1
|
|
0x23,0xEE,0x00,0x08,0x00,0x00,0x00,0x00, // move.l 8(a6),($Gadget).l
|
|
0x33,0xC0,0x00,0x00,0x00,0x00, // move.w d0,($Cmd).l
|
|
0x23,0xC1,0x00,0x00,0x00,0x00, // move.l d1,($Event).l
|
|
0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l #This,-(sp)
|
|
0x2F,0x39,0x00,0x00,0x00,0x00, // move.l (Wrapper).l,-(sp)
|
|
0x2F,0x39,0x00,0x00,0x00,0x00, // move.l (Module).l,-(sp)
|
|
0x20,0x79,0x00,0x00,0x00,0x00, // movea.l (PealCall).l,a0
|
|
0x4E,0x90, // jsr (a0)
|
|
0x02,0x80,0x00,0x00,0x00,0xFF, // andi.l #$FF,d0
|
|
0x4E,0x5E, // unlk a6
|
|
0x4E,0x75 }; // rts
|
|
|
|
#if defined(_M_IX86)
|
|
const tchar_t* Name = T("tcpmp.dll\0WrapperGadgetHandler86");
|
|
i->Wrapper = SWAP32(Name);
|
|
#else
|
|
i->Wrapper = SWAP32(WrapperGadgetHandler);
|
|
#endif
|
|
i->Form = formP;
|
|
i->Index = objIndex;
|
|
i->Handler = attrP;
|
|
i->Module = Peal.Module;
|
|
i->PealCall = Peal.PealCall;
|
|
|
|
memcpy(i->Code,Code,sizeof(Code));
|
|
SetCodePtr(i->Code+16,&i->Gadget);
|
|
SetCodePtr(i->Code+22,&i->Cmd);
|
|
SetCodePtr(i->Code+28,&i->Event);
|
|
SetCodePtr(i->Code+34,i);
|
|
SetCodePtr(i->Code+40,&i->Wrapper);
|
|
SetCodePtr(i->Code+46,&i->Module);
|
|
SetCodePtr(i->Code+52,&i->PealCall);
|
|
|
|
_FrmSetGadgetHandler(formP,objIndex,(FormGadgetHandlerType*)i->Code);
|
|
}
|
|
}
|
|
|
|
void FrmSetEventHandler(FormType *formP,FormEventHandlerType *handler)
|
|
{
|
|
eventhandler* i;
|
|
eventhandler* Free = NULL;
|
|
for (i=EventHandler;i;i=i->Next)
|
|
{
|
|
if (i->Form == formP)
|
|
break;
|
|
if (!i->Form)
|
|
Free = i;
|
|
}
|
|
if (!i)
|
|
{
|
|
if (Free)
|
|
i = Free;
|
|
else
|
|
{
|
|
i = MemGluePtrNew(sizeof(eventhandler));
|
|
i->Next = EventHandler;
|
|
EventHandler = i;
|
|
}
|
|
}
|
|
|
|
if (i)
|
|
{
|
|
static const uint8_t Code[48] =
|
|
{ 0x4E,0x56,0x00,0x00, // link a6,#0
|
|
0x23,0xEE,0x00,0x08,0x00,0x00,0x00,0x00, // move.l arg_0(a6),(Event).l
|
|
0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l #This,-(sp)
|
|
0x2F,0x39,0x00,0x00,0x00,0x00, // move.l (Wrapper).l,-(sp)
|
|
0x2F,0x39,0x00,0x00,0x00,0x00, // move.l (Module).l,-(sp)
|
|
0x20,0x79,0x00,0x00,0x00,0x00, // movea.l (PealCall).l,a0
|
|
0x4E,0x90, // jsr (a0)
|
|
0x4E,0x5E, // unlk a6
|
|
0x02,0x80,0x00,0x00,0x00,0xFF, // andi.l #$FF,d0
|
|
0x4E,0x75 }; // rts
|
|
|
|
#if defined(_M_IX86)
|
|
const tchar_t* Name = T("tcpmp.dll\0WrapperEventHandler86");
|
|
i->Wrapper = SWAP32(Name);
|
|
#else
|
|
i->Wrapper = SWAP32(WrapperEventHandler);
|
|
#endif
|
|
i->Form = formP;
|
|
i->Handler = handler;
|
|
i->Module = Peal.Module;
|
|
i->PealCall = Peal.PealCall;
|
|
i->Event = NULL;
|
|
|
|
memcpy(i->Code,Code,sizeof(Code));
|
|
SetCodePtr(i->Code+8,&i->Event);
|
|
SetCodePtr(i->Code+14,i);
|
|
SetCodePtr(i->Code+20,&i->Wrapper);
|
|
SetCodePtr(i->Code+26,&i->Module);
|
|
SetCodePtr(i->Code+32,&i->PealCall);
|
|
|
|
_FrmSetEventHandler(formP,(FormEventHandlerType*)i->Code);
|
|
}
|
|
}
|
|
|
|
void* PealLoadModule(uint16_t FtrId,Boolean Mem,Boolean OnlyFtr,Boolean MemSema)
|
|
{
|
|
uint16_t Param[4] = {SWAP16(FtrId),(uint8_t)Mem,(uint8_t)OnlyFtr,(uint8_t)MemSema};
|
|
return (void*)Call68K(SWAP32(Peal.LoadModule),&Param,sizeof(Param)|kPceNativeWantA0);
|
|
}
|
|
|
|
PACE_BEGIN(void* PealGetSymbol(void* Module,const tchar_t* Name))
|
|
PACE_ADD32(Module)
|
|
PACE_ADD32(Name)
|
|
}; return (void*)Call68K(SWAP32(Peal.GetSymbol),PACE_PARAM,sizeof(PACE_PARAM)|kPceNativeWantA0);
|
|
}
|
|
|
|
PACE_BEGIN(void PealFreeModule(void* Module))
|
|
PACE_ADD32(Module)
|
|
}; Call68K(SWAP32(Peal.FreeModule),PACE_PARAM,sizeof(PACE_PARAM));
|
|
}
|
|
|
|
Err FrmGlueNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP,
|
|
Int16* extraInfoP, RectangleType* boundsInsideRingP,
|
|
FrmNavFocusRingStyleEnum* ringStyleP)
|
|
{
|
|
UInt32 ver;
|
|
if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
|
|
return FrmNavGetFocusRingInfo(formP,objectIDP,extraInfoP,boundsInsideRingP,ringStyleP);
|
|
#ifdef HAVE_PALMONE_SDK
|
|
else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
|
|
return HsNavGetFocusRingInfo(formP,objectIDP,extraInfoP,boundsInsideRingP,ringStyleP);
|
|
#endif
|
|
return uilibErrObjectFocusModeOff;
|
|
}
|
|
|
|
Err FrmGlueNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
|
|
RectangleType* boundsInsideRingP,
|
|
FrmNavFocusRingStyleEnum ringStyle, Boolean forceRestore)
|
|
{
|
|
UInt32 ver;
|
|
if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
|
|
return FrmNavDrawFocusRing(formP,objectID,extraInfo,boundsInsideRingP,ringStyle,forceRestore);
|
|
#ifdef HAVE_PALMONE_SDK
|
|
else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
|
|
return HsNavDrawFocusRing(formP,objectID,extraInfo,boundsInsideRingP,ringStyle,forceRestore);
|
|
#endif
|
|
return uilibErrObjectFocusModeOff;
|
|
}
|
|
|
|
Err FrmGlueNavRemoveFocusRing (FormType* formP)
|
|
{
|
|
UInt32 ver;
|
|
if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
|
|
return FrmNavRemoveFocusRing(formP);
|
|
#ifdef HAVE_PALMONE_SDK
|
|
else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
|
|
return HsNavRemoveFocusRing(formP);
|
|
#endif
|
|
return uilibErrObjectFocusModeOff;
|
|
}
|
|
|
|
void FrmGlueNavObjectTakeFocus(FormType* formP, UInt16 objID)
|
|
{
|
|
UInt32 ver;
|
|
if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
|
|
FrmNavObjectTakeFocus(formP,objID);
|
|
#ifdef HAVE_PALMONE_SDK
|
|
else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
|
|
HsNavObjectTakeFocus(formP,objID);
|
|
#endif
|
|
}
|
|
|
|
Boolean FrmGlueNavIsSupported(void)
|
|
{
|
|
UInt32 ver;
|
|
if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
|
|
return 1;
|
|
#ifdef HAVE_PALMONE_SDK
|
|
if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
|
|
return 1;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
PACE_BEGIN(Err FrmNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP,
|
|
Int16* extraInfoP, RectangleType* boundsInsideRingP,
|
|
FrmNavFocusRingStyleEnum* ringStyleP))
|
|
PACE_ADD16(NavSelectorFrmNavGetFocusRingInfo)
|
|
PACE_ADD32(formP)
|
|
PACE_ADD32(objectIDP)
|
|
PACE_ADD32(extraInfoP)
|
|
PACE_ADD32(boundsInsideRingP)
|
|
PACE_ADD32(ringStyleP)
|
|
PACE_END16(sysTrapNavSelector, NONE, PACE_CDATA16(objectIDP) PACE_CDATA16(extraInfoP) PACE_CDATA16(ringStyleP) SwapStruct(boundsInsideRingP,2,2,2,2,0))
|
|
|
|
PACE_BEGINEX(Err FrmNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
|
|
RectangleType* boundsInsideRingP,
|
|
FrmNavFocusRingStyleEnum ringStyle, Boolean forceRestore),r)
|
|
PACE_ADD16(boundsInsideRingP->topLeft.x)
|
|
PACE_ADD16(boundsInsideRingP->topLeft.y)
|
|
PACE_ADD16(boundsInsideRingP->extent.x)
|
|
PACE_ADD16(boundsInsideRingP->extent.y)
|
|
PACE_VAR(PACE_PARAM)
|
|
PACE_ADD16(NavSelectorFrmNavDrawFocusRing)
|
|
PACE_ADD16(objectID)
|
|
PACE_ADD16(extraInfo)
|
|
PACE_ADD32(r)
|
|
PACE_ADD16(ringStyle)
|
|
PACE_ADD8(forceRestore)
|
|
PACE_END16(sysTrapNavSelector,NONE,NONE)
|
|
|
|
PACE_BEGIN(Err FrmNavRemoveFocusRing (FormType* formP))
|
|
PACE_ADD16(NavSelectorFrmNavRemoveFocusRing)
|
|
PACE_ADD32(formP)
|
|
PACE_END16(sysTrapNavSelector,NONE,NONE)
|
|
|
|
PACE_BEGIN(void FrmNavObjectTakeFocus (const FormType* formP, UInt16 objID))
|
|
PACE_ADD16(NavSelectorFrmNavObjectTakeFocus)
|
|
PACE_ADD32(formP)
|
|
PACE_ADD16(objID)
|
|
PACE_END(sysTrapNavSelector,NONE,NONE)
|
|
|
|
#endif
|