开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
pace.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：68k
源码类别：

Windows CE

开发平台：

C/C++

pace.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: pace.c 531 2006-01-04 12:56:13Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #if defined(TARGET_PALMOS)
  28. #include "pace.h"
  29. #include "peal/arm/pealstub.h"
  31. //tremor uses lot of alloca()
  32. #define STACKSIZE 0x8000
  33. //#define STACKCHECK
  35. #ifdef HAVE_PALMONE_SDK
  36. #define NO_HSEXT_TRAPS
  37. #include <68K/System/HardwareUtils68K.h>
  38. #include <Common/System/HsNavCommon.h>
  39. #include <68K/System/HsExt.h>
  40. #endif
  42. typedef struct launch
  43. {
  44. UInt32 PealCall; //BE
  45. UInt32 Module; //BE
  46. UInt32 LoadModule; //BE
  47. UInt32 FreeModule; //BE
  48. UInt32 GetSymbol; //BE
  50. UInt16 launchParameters[2];
  51. UInt16 launchCode;
  52. UInt16 launchFlags;
  54. } launch;
  56. typedef struct gadgethandler
  57. {
  58. uint8_t Code[68];
  59. struct gadgethandler* Next;
  61. FormGadgetTypeInCallback* Gadget; //BE
  62. uint16_t* Event; //BE
  63. UInt16 Cmd; //BE
  64. UInt32 Module; //BE
  65. UInt32 PealCall; //BE
  66. UInt32 Wrapper; //BE
  68. FormType* Form;
  69. int Index;
  70. FormGadgetHandlerType* Handler; 
  72. } gadgethandler;
  74. typedef struct eventhandler
  75. {
  76. uint8_t Code[48];
  77. struct eventhandler* Next;
  79. uint16_t* Event; //BE
  80. UInt32 Module; //BE
  81. UInt32 PealCall; //BE
  82. UInt32 Wrapper; //BE
  84. FormType* Form;
  85. FormEventHandlerType *Handler;
  87. } eventhandler;
  89. static gadgethandler* GadgetHandler = NULL;
  90. static eventhandler* EventHandler = NULL;
  91. static launch Peal = {0};
  93. static NOINLINE void FreeHandlers()
  94. {
  95. gadgethandler* j;
  96. eventhandler* i;
  97. while ((i=EventHandler)!=NULL)
  98. {
  99. EventHandler = i->Next;
  100. MemPtrFree(i);
  101. }
  102. while ((j=GadgetHandler)!=NULL)
  103. {
  104. GadgetHandler = j->Next;
  105. MemPtrFree(j);
  106. }
  107. }
  109. static NOINLINE void SwapLanchParameters(int launchCode,void* launchParameters,bool_t From)
  110. {
  111. if (launchCode == sysAppLaunchCmdCustomBase)
  112. {
  113. vfspath* p = (vfspath*)launchParameters;
  114. p->volRefNum = SWAP16(p->volRefNum);
  115. }
  117. if (launchCode == sysAppLaunchCmdOpenDB)
  118. {
  119. UInt16 tmp;
  120. SysAppLaunchCmdOpenDBType2* p = (SysAppLaunchCmdOpenDBType2*)launchParameters;
  121. p->cardNo = SWAP16(p->cardNo);
  122. tmp = p->dbID[0];
  123. p->dbID[0] = SWAP16(p->dbID[1]);
  124. p->dbID[1] = SWAP16(tmp);
  125. }
  127. if (launchCode == sysAppLaunchCmdNotify)
  128. {
  129. SysNotifyParamType* p = (SysNotifyParamType*)launchParameters;
  130. UInt32 Type = p->notifyType;
  131. void* Details = p->notifyDetailsP;
  133. p->notifyType = SWAP32(p->notifyType);
  134. p->broadcaster = SWAP32(p->broadcaster);
  135. p->notifyDetailsP = (void*)SWAP32(p->notifyDetailsP);
  136. p->userDataP = (void*)SWAP32(p->userDataP);
  138. if (From)
  139. {
  140. Type = p->notifyType;
  141. Details = p->notifyDetailsP;
  142. }
  144. if (Type == sysNotifySleepRequestEvent)
  145. {
  146. SleepEventParamType* i = (SleepEventParamType*)Details;
  147. i->reason = SWAP16(i->reason);
  148. i->deferSleep = SWAP16(i->deferSleep);
  149. }
  150. }
  151. }
  153. static INLINE uint32_t ReadSwap32(const void* p)
  154. {
  155. return 
  156. (((const uint8_t*)p)[0] << 24)|
  157. (((const uint8_t*)p)[1] << 16)|
  158. (((const uint8_t*)p)[2] << 8)|
  159. (((const uint8_t*)p)[3] << 0);
  160. }
  162. static INLINE void WriteSwap32(void* p,uint32_t i)
  163. {
  164. ((uint8_t*)p)[0] = ((uint8_t*)&i)[3];
  165. ((uint8_t*)p)[1] = ((uint8_t*)&i)[2];
  166. ((uint8_t*)p)[2] = ((uint8_t*)&i)[1];
  167. ((uint8_t*)p)[3] = ((uint8_t*)&i)[0];
  168. }
  170. void Event_M68K_To_ARM(const uint16_t* In,EventType* Out)
  171. {
  172. Out->eType = SWAP16(In[0]);
  173. Out->penDown = ((uint8_t*)In)[2];
  174. Out->tapCount = ((uint8_t*)In)[3];
  175. Out->screenX = SWAP16(In[2]);
  176. Out->screenY = SWAP16(In[3]);
  178. switch (Out->eType)
  179. {
  180. // 1*16bit
  181. case frmLoadEvent:
  182. case menuEvent:
  183. Out->data.menu.itemID = SWAP16(In[4]);
  184. break;
  186. // 3*16bit
  187. case frmUpdateEvent:
  188. case keyUpEvent:
  189. case keyDownEvent:
  190. case keyHoldEvent:
  191. Out->data.keyDown.chr = SWAP16(In[4]);
  192. Out->data.keyDown.keyCode = SWAP16(In[5]);
  193. Out->data.keyDown.modifiers = SWAP16(In[6]);
  194. break;
  196. // 16bit,32bit
  197. /* case fldChangedEvent:
  198. Out->data.fldChanged.fieldID = SWAP16(In[4]);
  199. Out->data.fldChanged.pField = (FieldType*)ReadSwap32(In+5);
  200. break;
  201. */
  202. // 16bit,32bit,16bit,32bit,16bit,16bit
  203. case popSelectEvent:
  204. Out->data.popSelect.controlID = SWAP16(In[4]);
  205. Out->data.popSelect.controlP = (ControlType*)ReadSwap32(In+5);
  206. Out->data.popSelect.listID = SWAP16(In[7]);
  207. Out->data.popSelect.listP = (ListType*)SWAP32(*(uint32_t*)(In+8));
  208. Out->data.popSelect.selection = SWAP16(In[10]);
  209. Out->data.popSelect.priorSelection = SWAP16(In[11]);
  210. break;
  212. // 16bit,32bit,16bit
  213. case lstSelectEvent:
  214. Out->data.lstSelect.listID = SWAP16(In[4]);
  215. Out->data.lstSelect.pList = (ListType*)ReadSwap32(In+5);
  216. Out->data.lstSelect.selection = SWAP16(In[7]);
  217. break;
  219. //custom
  220. case sclRepeatEvent:
  221. Out->data.sclRepeat.scrollBarID = SWAP16(In[4]);
  222. Out->data.sclRepeat.pScrollBar = (ScrollBarType*)ReadSwap32(In+5);
  223. Out->data.sclRepeat.value = SWAP16(In[7]);
  224. Out->data.sclRepeat.newValue = SWAP16(In[8]);
  225. Out->data.sclRepeat.time = ReadSwap32(In+9);
  226. break;
  228. //custom
  229. case ctlRepeatEvent:
  230. Out->data.ctlRepeat.controlID = SWAP16(In[4]);
  231. Out->data.ctlRepeat.pControl = (ControlType*)ReadSwap32(In+5);
  232. Out->data.ctlRepeat.time = ReadSwap32(In+7);
  233. Out->data.ctlRepeat.value = SWAP16(In[9]);
  234. break;
  236. //custom
  237. case ctlSelectEvent: 
  238. Out->data.ctlSelect.controlID = SWAP16(In[4]);
  239. Out->data.ctlSelect.pControl = (ControlType*)ReadSwap32(In+5);
  240. Out->data.ctlSelect.on = ((uint8_t*)In)[14];
  241. Out->data.ctlSelect.reserved1 = ((uint8_t*)In)[15];
  242. Out->data.ctlSelect.value = SWAP16(In[8]);
  243. break;
  245. // 2*32bit
  246. case winEnterEvent:
  247. case winExitEvent:
  248. Out->data.winExit.enterWindow = (WinHandle)SWAP32(((uint32_t*)In)[2]);
  249. Out->data.winExit.exitWindow = (WinHandle)SWAP32(((uint32_t*)In)[3]);
  250. break;
  252. default:
  253. memcpy(Out->data.generic.datum,In+4,sizeof(uint16_t)*8);
  254. break;
  255. }
  256. }
  258. void Event_ARM_To_M68K(const EventType* In,uint16_t* Out)
  259. {
  260. Out[0] = SWAP16(In->eType);
  261. ((uint8_t*)Out)[2] = In->penDown;
  262. ((uint8_t*)Out)[3] = In->tapCount;
  263. Out[2] = SWAP16(In->screenX);
  264. Out[3] = SWAP16(In->screenY);
  266. switch (In->eType)
  267. {
  268. // 1*16bit
  269. case frmLoadEvent:
  270. case menuEvent:
  271. Out[4] = SWAP16(In->data.menu.itemID);
  272. break;
  274. // 3*16bit
  275. case frmUpdateEvent:
  276. case keyUpEvent:
  277. case keyDownEvent:
  278. case keyHoldEvent:
  279. Out[4] = SWAP16(In->data.keyDown.chr);
  280. Out[5] = SWAP16(In->data.keyDown.keyCode);
  281. Out[6] = SWAP16(In->data.keyDown.modifiers);
  282. break;
  284. // 16bit,32bit,16bit
  285. case lstSelectEvent:
  286. Out[4] = SWAP16(In->data.lstSelect.listID);
  287. WriteSwap32(Out+5,(uint32_t)In->data.lstSelect.pList);
  288. Out[7] = SWAP16(In->data.lstSelect.selection);
  289. break;
  291. // 16bit,32bit
  292. /* case fldChangedEvent:
  293. Out[4] = SWAP16(In->data.fldChanged.fieldID);
  294. WriteSwap32(Out+5,(uint32_t)In->data.fldChanged.pField);
  295. break;
  296. */
  297. // 16bit,32bit,16bit,32bit,16bit,16bit
  298. case popSelectEvent:
  299. Out[4] = SWAP16(In->data.popSelect.controlID);
  300. WriteSwap32(Out+5,(uint32_t)In->data.popSelect.controlP);
  301. Out[7] = SWAP16(In->data.popSelect.listID);
  302. WriteSwap32(Out+8,(uint32_t)In->data.popSelect.listP);
  303. Out[10] = SWAP16(In->data.popSelect.selection);
  304. Out[11] = SWAP16(In->data.popSelect.priorSelection);
  305. break;
  307. //custom
  308. case sclRepeatEvent:
  309. Out[4] = SWAP16(In->data.sclRepeat.scrollBarID);
  310. WriteSwap32(Out+5,(uint32_t)In->data.sclRepeat.pScrollBar);
  311. Out[7] = SWAP16(In->data.sclRepeat.value);
  312. Out[8] = SWAP16(In->data.sclRepeat.newValue);
  313. WriteSwap32(Out+9,In->data.sclRepeat.time);
  314. break;
  316. //custom
  317. case ctlRepeatEvent:
  318. Out[4] = SWAP16(In->data.ctlRepeat.controlID);
  319. WriteSwap32(Out+5,(uint32_t)In->data.ctlRepeat.pControl);
  320. WriteSwap32(Out+7,In->data.ctlRepeat.time);
  321. Out[9] = SWAP16(In->data.ctlRepeat.value);
  322. break;
  324. //custom
  325. case ctlSelectEvent: 
  326. Out[4] = SWAP16(In->data.ctlSelect.controlID);
  327. WriteSwap32(Out+5,(uint32_t)In->data.ctlSelect.pControl);
  328. ((uint8_t*)Out)[14] = In->data.ctlSelect.on;
  329. ((uint8_t*)Out)[15] = In->data.ctlSelect.reserved1;
  330. Out[8] = SWAP16(In->data.ctlSelect.value);
  331. break;
  333. // 2*32bit
  334. case winEnterEvent:
  335. case winExitEvent:
  336. ((uint32_t*)Out)[2] = SWAP32(In->data.winExit.enterWindow);
  337. ((uint32_t*)Out)[3] = SWAP32(In->data.winExit.exitWindow);
  338. break;
  340. default:
  341. memcpy(Out+4,In->data.generic.datum,sizeof(uint16_t)*8);
  342. break;
  343. }
  344. }
  347. static void GadgetTypeInCallback_M68K_To_ARM(const uint16_t* In,FormGadgetTypeInCallback* Out)
  348. {
  349. Out->id = SWAP16(In[0]);
  350. *(UInt16*)&Out->attr = SWAP16(In[1]);
  351. Out->rect.topLeft.x = SWAP16(In[2]);
  352. Out->rect.topLeft.y = SWAP16(In[3]);
  353. Out->rect.extent.x = SWAP16(In[4]);
  354. Out->rect.extent.y = SWAP16(In[5]);
  355. Out->data = (const void*)SWAP32(*(const uint32_t*)(In+6));
  356. Out->handler = (FormGadgetHandlerType*)SWAP32(*(const uint32_t*)(In+8));
  357. }
  359. static void GadgetTypeInCallback_ARM_To_M68K(const FormGadgetTypeInCallback* In,uint16_t* Out)
  360. {
  361. Out[0] = SWAP16(In->id);
  362. Out[1] = SWAP16(*(UInt16*)&In->attr);
  363. Out[2] = SWAP16(In->rect.topLeft.x);
  364. Out[3] = SWAP16(In->rect.topLeft.y);
  365. Out[4] = SWAP16(In->rect.extent.x);
  366. Out[5] = SWAP16(In->rect.extent.y);
  367. *(uint32_t*)(Out+6) = SWAP32(In->data);
  368. *(uint32_t*)(Out+8) = SWAP32(In->handler);
  369. }
  371. static NOINLINE bool_t CmdLaunch(int Code)
  372. {
  373. return Code == sysAppLaunchCmdNormalLaunch ||
  374. Code == sysAppLaunchCmdOpenDB ||
  375. Code == sysAppLaunchCmdCustomBase;
  376. }
  378. #if defined(_M_IX86)
  380. #define NONE 0
  382. pcecall PceCall = {NULL};
  384. #include <windows.h>
  386. DLLEXPORT uint32_t PaceMain86(const void *emulStateP, launch* Launch, Call68KFuncType *call68KFuncP)
  387. {
  388. MemPtr Parameters = (MemPtr)((SWAP16(Launch->launchParameters[0])<<16)|(SWAP16(Launch->launchParameters[1])));
  389. int Code = SWAP16(Launch->launchCode);
  390. uint32_t Result; 
  391. pcecall Old = PceCall;
  393. if (CmdLaunch(Code))
  394. memcpy(&Peal,Launch,sizeof(launch));
  396. PceCall.Func = call68KFuncP;
  397. PceCall.State = emulStateP;
  399. SwapLanchParameters(Code,Parameters,1);
  400. Result = PilotMain((UInt16)Code,Parameters,SWAP16(Launch->launchFlags));
  401. SwapLanchParameters(Code,Parameters,0);
  403. if (CmdLaunch(Code))
  404. FreeHandlers();
  406. PceCall = Old;
  407. return Result;
  408. }
  410. void SaveSysRegs(sysregs* p)
  411. {
  412. }
  414. void LoadSysRegs(sysregs* p)
  415. {
  416. }
  418. static NOINLINE unsigned long Call68K(unsigned long trapOrFunction,
  419. const void *argsOnStackP, unsigned long argsSizeAndwantA0)
  420. {
  421. pcecall* Call = &PceCall;
  422. return Call->Func(Call->State,trapOrFunction,argsOnStackP,argsSizeAndwantA0);
  423. }
  425. DLLEXPORT Boolean WrapperEventHandler86(const void *emulStateP, eventhandler* i, Call68KFuncType *call68KFuncP)
  426. {
  427. Boolean Result;
  428. EventType EventARM;
  429. uint16_t* EventM68K = (uint16_t*) SWAP32(i->Event);
  430. pcecall Old = PceCall;
  431. PceCall.Func = call68KFuncP;
  432. PceCall.State = emulStateP;
  433. Event_M68K_To_ARM(EventM68K,&EventARM);
  434. Result = i->Handler(&EventARM);
  435. if (!Result && EventARM.eType == frmCloseEvent)
  436. i->Form = NULL;
  437. PceCall = Old;
  438. return Result;
  439. }
  441. DLLEXPORT Boolean WrapperGadgetHandler86(const void *emulStateP, gadgethandler* i, Call68KFuncType *call68KFuncP)
  442. {
  443. EventType EventARM;
  444. Boolean Result;
  445. FormGadgetTypeInCallback GadgetARM;
  446. uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
  447. UInt16 Cmd = SWAP16(i->Cmd);
  448. uint16_t* EventM68K = (uint16_t*) SWAP32(i->Event);
  449. pcecall Old = PceCall;
  450. PceCall.Func = call68KFuncP;
  451. PceCall.State = emulStateP;
  452. GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
  453. if (Cmd == formGadgetHandleEventCmd)
  454. Event_M68K_To_ARM(EventM68K,&EventARM);
  455. Result = i->Handler(&GadgetARM,Cmd,&EventARM);
  456. GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
  457. if (Cmd == formGadgetDeleteCmd)
  458. i->Form = NULL;
  459. PceCall = Old;
  460. return Result;
  461. }
  463. #elif defined(ARM)
  465. #define NONE
  467. void SaveSysRegs(sysregs* p)
  468. {
  469. p->SysReg = PceCall.SysReg;
  470. asm volatile(
  471. "mov %0, r10nt"
  472. : "=&r"(p->GOT) : : "cc");
  473. }
  475. void LoadSysRegs(sysregs* p)
  476. {
  477. asm volatile(
  478. "mov r9,%0nt"
  479. "mov r10,%1nt"
  480. : : "r"(p->SysReg),"r"(p->GOT): "cc");
  481. }
  483. static NOINLINE unsigned long Call68K(unsigned long trapOrFunction,
  484.   const void *argsOnStackP, unsigned long argsSizeAndwantA0)
  485. {
  486. pcecall* Call = &PceCall;
  487. unsigned long Result;
  488. register void *SysReg asm("r9") = Call->SysReg;
  489. Result = Call->Func(Call->State,trapOrFunction,argsOnStackP,argsSizeAndwantA0);
  490. Call->SysReg = SysReg;
  491. return Result;
  492. }
  494. static NOINLINE void SafeMemCpy(void* d,const void* s,int n)
  495. {
  496. uint8_t* d8 = (uint8_t*)d;
  497. const uint8_t* s8= (const uint8_t*)s;
  498. for (;n>0;--n,++d8,++s8)
  499. *d8 = *s8;
  500. }
  502. #ifdef STACKCHECK
  503. static void NOINLINE StackCheck(char* p)
  504. {
  505. int i;
  506. for (i=0;i<STACKSIZE;++i)
  507. if (p[i] != 0x55)
  508. break;
  509. if (i < 4096)
  510. {
  511. char s[64];
  512. sprintf(s,"Possible stack overflow %d/%d. ",i,STACKSIZE);
  513. FrmCustomAlert(WarningOKAlert, s, "Please contact developer!", " ");
  514. }
  515. }
  516. #endif
  518. uint32_t PaceMain(launch* Launch)
  519. {
  520. MemPtr Parameters = (MemPtr)((SWAP16(Launch->launchParameters[0])<<16)|(SWAP16(Launch->launchParameters[1])));
  521. int Code = SWAP16(Launch->launchCode);
  522. void* Old = NULL;
  523. char* Stack = NULL;
  524. uint32_t Result; 
  526. if (CmdLaunch(Code))
  527. {
  528. SafeMemCpy(&Peal,Launch,sizeof(launch));
  529. Stack = MemGluePtrNew(STACKSIZE);
  530. if (!Stack)
  531. return errNone;
  532. memset(Stack,0x55,STACKSIZE);
  533. Old = SwapSP(Stack+STACKSIZE);
  534. }
  536. SwapLanchParameters(Code,Parameters,1);
  537. Result = PilotMain(Code,Parameters,SWAP16(Launch->launchFlags));
  538. SwapLanchParameters(Code,Parameters,0);
  540. if (Stack)
  541. {
  542. SwapSP(Old);
  543. #ifdef STACKCHECK
  544. StackCheck(Stack);
  545. #endif
  546. MemPtrFree(Stack);
  547. FreeHandlers();
  548. }
  550. return Result;
  551. }
  553. static Boolean WrapperEventHandler(eventhandler* i)
  554. {
  555. Boolean Result;
  556. EventType EventARM;
  557. const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
  558. Event_M68K_To_ARM(EventM68K,&EventARM);
  559. Result = i->Handler(&EventARM);
  560. if (!Result && EventARM.eType == frmCloseEvent)
  561. i->Form = NULL;
  562. return Result;
  563. }
  565. static Boolean WrapperGadgetHandler(gadgethandler* i)
  566. {
  567. EventType EventARM;
  568. Boolean Result;
  569. FormGadgetTypeInCallback GadgetARM;
  570. uint16_t* Gadget = (uint16_t*) SWAP32(i->Gadget);
  571. UInt16 Cmd = SWAP16(i->Cmd);
  572. const uint16_t* EventM68K = (const uint16_t*) SWAP32(i->Event);
  573. GadgetTypeInCallback_M68K_To_ARM(Gadget,&GadgetARM);
  574. if (Cmd == formGadgetHandleEventCmd)
  575. Event_M68K_To_ARM(EventM68K,&EventARM);
  576. Result = i->Handler(&GadgetARM,Cmd,&EventARM);
  577. GadgetTypeInCallback_ARM_To_M68K(&GadgetARM,Gadget);
  578. if (Cmd == formGadgetDeleteCmd)
  579. i->Form = NULL;
  580. return Result;
  581. }
  583. #else
  584. #error Not supported platform
  585. #endif
  587. typedef struct emustate
  588. {
  589. uint32_t instr;
  590. uint32_t regD[8];
  591. uint32_t regA[8];
  592. uint32_t regPC;
  594. } emustate;
  596. #define PACE_PARAM _v
  598. #define PACE_BEGIN(declare) NOINLINE declare { uint16_t PACE_PARAM[] = {
  599. #define PACE_BEGINEVENT(declare) NOINLINE declare { uint16_t ev[12]; uint16_t PACE_PARAM[] = {
  600. #define PACE_BEGINEX(declare,name) NOINLINE declare { uint16_t name[] = {
  601. #define PACE_VAR(name) }; uint16_t name[] = {
  603. #define PACE_ADD8(name)  (uint8_t)name,
  604. #define PACE_ADD16(name)  SWAP16(name),
  605. #define PACE_ADD32(name) SWAP16(((uint32_t)(name))>>16),SWAP16(name),
  607. #define PACE_DATA16(name) *name = SWAP16(*name);
  608. #define PACE_DATA32(name) *name = SWAP32(*name);
  609. #define PACE_CDATA16(name) if (name) *name = SWAP16(*name);
  610. #define PACE_CDATA32(name) if (name) *name = SWAP32(*name);
  611. #define PACE_SEL(sel) ((emustate*)PceCall.State)->regD[2] = sel;
  613. #define PACE_END(Trap,PreProcess,PostProcess) }; PreProcess; 
  614.     Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); 
  615. PostProcess; }
  617. #define PACE_ENDVOID(Trap,PreProcess,PostProcess) 0}; PreProcess; 
  618.     Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); 
  619. PostProcess; }
  621. #define PACE_END8(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; 
  622. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); 
  623. PostProcess; return (uint8_t)ret; }
  625. #define PACE_END8VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; 
  626. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); 
  627. PostProcess; return (uint8_t)ret; }
  629. #define PACE_END16(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; 
  630. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); 
  631. PostProcess; return (uint16_t)ret; }
  633. #define PACE_END16VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; 
  634. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); 
  635. PostProcess; return (uint16_t)ret; }
  637. #define PACE_END32(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; 
  638. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)); 
  639. PostProcess; return ret; }
  641. #define PACE_END32VOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; 
  642. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0); 
  643. PostProcess; return ret; }
  645. #define PACE_ENDPTR(Trap,PreProcess,PostProcess) }; uint32_t ret; PreProcess; 
  646. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,sizeof(PACE_PARAM)|kPceNativeWantA0); 
  647. PostProcess; return (void*)ret; }
  649. #define PACE_ENDPTRVOID(Trap,PreProcess,PostProcess) 0}; uint32_t ret; PreProcess; 
  650. ret = Call68K(PceNativeTrapNo(Trap),PACE_PARAM,0|kPceNativeWantA0); 
  651. PostProcess; return (void*)ret; }
  653. static NOINLINE void SwapBlock32(void* Ptr,int n)
  654. {
  655. if (Ptr)
  656. {
  657. int i;
  658. char* p = (char*)Ptr;
  659. for (i=0;i<n;++i,p+=4)
  660. PACE_DATA32((uint32_t*)p);
  661. }
  662. }
  664. static NOINLINE void SwapStruct(void* Ptr,...)
  665. {
  666. if (Ptr)
  667. {
  668. int Size;
  669. char* p = (char*)Ptr;
  670. va_list Args;
  671. va_start(Args,Ptr);
  672. while ((Size = va_arg(Args,int))!=0)
  673. {
  674. if (Size == 4)
  675. PACE_DATA32((uint32_t*)p)
  676. else
  677. if (Size == 2)
  678. PACE_DATA16((uint16_t*)p)
  679. p += Size;
  680. }
  681. va_end(Args);
  682. }
  683. }
  685. //---------------------------------------------------------------------
  687. PACE_BEGIN(Int32 GetOEMSleepMode())
  688. PACE_END32VOID(sysTrapOEMDispatch2,PACE_SEL(263),NONE)
  690. PACE_BEGIN(Err SetOEMSleepMode(Int32 Mode))
  691. PACE_ADD32(Mode)
  692. PACE_END16(sysTrapOEMDispatch2,PACE_SEL(264),NONE)
  694. PACE_BEGIN(UInt16 SysGetOrientation())
  695. PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinSysGetOrientation),NONE)
  697. PACE_BEGIN(Err WinGetPixelRGB(Coord x, Coord y, RGBColorType* rgbP))
  698. PACE_ADD16(x)
  699. PACE_ADD16(y)
  700. PACE_ADD32(rgbP)
  701. PACE_END16(sysTrapWinGetPixelRGB,NONE,NONE)
  703. PACE_BEGIN(void WinSetForeColorRGB(const RGBColorType* newRgbP, RGBColorType* prevRgbP))
  704. PACE_ADD32(newRgbP)
  705. PACE_ADD32(prevRgbP)
  706. PACE_END(sysTrapWinSetForeColorRGB,NONE,NONE)
  708. PACE_BEGIN(void WinPaintPixel(Coord x, Coord y))
  709. PACE_ADD16(x)
  710. PACE_ADD16(y)
  711. PACE_END(sysTrapWinPaintPixel,NONE,NONE)
  713. PACE_BEGIN(void WinDrawPixel(Coord x, Coord y))
  714. PACE_ADD16(x)
  715. PACE_ADD16(y)
  716. PACE_END(sysTrapWinDrawPixel,NONE,NONE)
  718. PACE_BEGIN(void FrmSetFocus(FormType *formP, UInt16 fieldIndex))
  719. PACE_ADD32(formP)
  720. PACE_ADD16(fieldIndex)
  721. PACE_END(sysTrapFrmSetFocus,NONE,NONE)
  723. PACE_BEGIN(void FrmSetTitle (FormType *formP, Char *newTitle))
  724. PACE_ADD32(formP)
  725. PACE_ADD32(newTitle)
  726. PACE_END(sysTrapFrmSetTitle,NONE,NONE)
  728. PACE_BEGIN(FormObjectKind FrmGetObjectType(const FormType *formP, UInt16 objIndex))
  729. PACE_ADD32(formP)
  730. PACE_ADD16(objIndex)
  731. PACE_END8(sysTrapFrmGetObjectType,NONE,NONE)
  733. PACE_BEGIN(FormLabelType *FrmNewLabel (FormType **formPP, UInt16 ID, const Char *textP,
  734. Coord x, Coord y, FontID font))
  735. PACE_ADD32(formPP)
  736. PACE_ADD16(ID)
  737. PACE_ADD32(textP)
  738. PACE_ADD16(x)
  739. PACE_ADD16(y)
  740. PACE_ADD8(font)
  741. PACE_ENDPTR(sysTrapFrmNewLabel,PACE_CDATA32((UInt32*)formPP),PACE_CDATA32((UInt32*)formPP))
  743. PACE_BEGIN(FormType *FrmNewForm(UInt16 formID, const Char *titleStrP,
  744. Coord x, Coord y, Coord width, Coord height, Boolean modal,
  745. UInt16 defaultButton, UInt16 helpRscID, UInt16 menuRscID))
  746. PACE_ADD16(formID)
  747. PACE_ADD32(titleStrP)
  748. PACE_ADD16(x)
  749. PACE_ADD16(y)
  750. PACE_ADD16(width)
  751. PACE_ADD16(height)
  752. PACE_ADD8(modal)
  753. PACE_ADD16(defaultButton)
  754. PACE_ADD16(helpRscID)
  755. PACE_ADD16(menuRscID)
  756. PACE_ENDPTR(sysTrapFrmNewForm,NONE,NONE)
  758. PACE_BEGIN(void FrmCloseAllForms())
  759. PACE_ENDVOID(sysTrapFrmCloseAllForms,NONE,NONE)
  761. PACE_BEGIN(UInt16 FrmGetObjectId (const FormType *formP, UInt16 objIndex))
  762. PACE_ADD32(formP)
  763. PACE_ADD16(objIndex)
  764. PACE_END16(sysTrapFrmGetObjectId,NONE,NONE)
  766. PACE_BEGIN(UInt16 FrmGetNumberOfObjects(const FormType *formP))
  767. PACE_ADD32(formP)
  768. PACE_END16(sysTrapFrmGetNumberOfObjects,NONE,NONE)
  770. PACE_BEGIN(UInt16 FrmGetActiveFormID())
  771. PACE_END16VOID(sysTrapFrmGetActiveFormID,NONE,NONE)
  773. PACE_BEGIN(void FrmGotoForm (UInt16 formId))
  774. PACE_ADD16(formId)
  775. PACE_END(sysTrapFrmGotoForm,NONE,NONE)
  777. PACE_BEGIN(void CtlSetUsable (ControlType *controlP, Boolean usable))
  778. PACE_ADD32(controlP)
  779. PACE_ADD8(usable)
  780. PACE_END(sysTrapCtlSetUsable,NONE,NONE)
  782. PACE_BEGIN(Int16 CtlGetValue (const ControlType *controlP))
  783. PACE_ADD32(controlP)
  784. PACE_END16(sysTrapCtlGetValue,NONE,NONE)
  786. PACE_BEGIN(void CtlSetValue (ControlType *controlP, Int16 newValue))
  787. PACE_ADD32(controlP)
  788. PACE_ADD16(newValue)
  789. PACE_END(sysTrapCtlSetValue,NONE,NONE)
  791. PACE_BEGIN(void CtlSetLabel (ControlType *controlP, const Char *newLabel))
  792. PACE_ADD32(controlP)
  793. PACE_ADD32(newLabel)
  794. PACE_END(sysTrapCtlSetLabel,NONE,NONE)
  796. PACE_BEGIN(void EvtEnableGraffiti(Boolean enable))
  797. PACE_ADD8(enable)
  798. PACE_END(sysTrapEvtEnableGraffiti,NONE,NONE);
  800. PACE_BEGIN(Err EvtResetAutoOffTimer())
  801. PACE_END16VOID(sysTrapEvtResetAutoOffTimer,NONE,NONE)
  803. PACE_BEGIN(FormType *FrmGetFirstForm())
  804. PACE_ENDPTRVOID(sysTrapFrmGetFirstForm,NONE,NONE)
  806. PACE_BEGIN(void *FrmGetObjectPtr (const FormType *formP, UInt16 objIndex))
  807. PACE_ADD32(formP)
  808. PACE_ADD16(objIndex)
  809. PACE_ENDPTR(sysTrapFrmGetObjectPtr,NONE,NONE)
  811. #if defined(_M_IX86)
  812. // simulator freezes many times. bypassing...
  813. Boolean EvtEventAvail() { return 1; }
  814. #else
  815. PACE_BEGIN(Boolean EvtEventAvail())
  816. PACE_END8VOID(sysTrapEvtEventAvail,NONE,NONE)
  817. #endif
  819. PACE_BEGIN(void EvtGetPen(Int16 *pScreenX, Int16 *pScreenY, Boolean *pPenDown))
  820. PACE_ADD32(pScreenX)
  821. PACE_ADD32(pScreenY)
  822. PACE_ADD32(pPenDown)
  823. PACE_END(sysTrapEvtGetPen,NONE,PACE_DATA16(pScreenX) PACE_DATA16(pScreenY))
  825. PACE_BEGIN(Boolean EvtSysEventAvail(Boolean ignorePenUps))
  826. PACE_ADD8(ignorePenUps)
  827. PACE_END8(sysTrapEvtSysEventAvail,NONE,NONE)
  829. PACE_BEGINEVENT(void EvtAddUniqueEventToQueue(const EventType *eventP, UInt32 id,Boolean inPlace))
  830. PACE_ADD32(&ev)
  831. PACE_ADD32(id)
  832. PACE_ADD8(inPlace)
  833. PACE_END(sysTrapEvtAddUniqueEventToQueue,Event_ARM_To_M68K(eventP,ev),NONE)
  835. PACE_BEGINEVENT(void EvtGetEvent(EventType *event, Int32 timeout))
  836. PACE_ADD32(&ev)
  837. PACE_ADD32(timeout)
  838. PACE_END(sysTrapEvtGetEvent,NONE,Event_M68K_To_ARM(ev,event))
  840. PACE_BEGIN(UInt16 FrmGetObjectIndex (const FormType *formP, UInt16 objID))
  841. PACE_ADD32(formP)
  842. PACE_ADD16(objID)
  843. PACE_END16(sysTrapFrmGetObjectIndex,NONE,NONE)
  845. PACE_BEGIN(void CtlSetSliderValues(ControlType *ctlP, const UInt16 *minValueP, const UInt16 *maxValueP,
  846.    const UInt16 *pageSizeP, const UInt16 *valueP))
  847. PACE_ADD32(ctlP)
  848. PACE_ADD32(minValueP)
  849. PACE_ADD32(maxValueP)
  850. PACE_ADD32(pageSizeP)
  851. PACE_ADD32(valueP)
  852. PACE_END(sysTrapCtlSetSliderValues,PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP),
  853.    PACE_CDATA16((UInt16*)minValueP) PACE_CDATA16((UInt16*)maxValueP) PACE_CDATA16((UInt16*)pageSizeP) PACE_CDATA16((UInt16*)valueP))
  854.    // possible problem overriding const input
  856. PACE_BEGIN(WinHandle WinSetDrawWindow(WinHandle winHandle))
  857. PACE_ADD32(winHandle)
  858. PACE_ENDPTR(sysTrapWinSetDrawWindow,NONE,NONE)
  860. PACE_BEGIN(WinHandle WinGetDrawWindow())
  861. PACE_ENDPTRVOID(sysTrapWinGetDrawWindow,NONE,NONE)
  863. PACE_BEGIN(void WinDrawLine (Coord x1, Coord y1, Coord x2, Coord y2))
  864. PACE_ADD16(x1)
  865. PACE_ADD16(y1)
  866. PACE_ADD16(x2)
  867. PACE_ADD16(y2)
  868. PACE_END(sysTrapWinDrawLine,NONE,NONE)
  870. PACE_BEGIN(IndexedColorType UIColorGetTableEntryIndex(UIColorTableEntries which))
  871. PACE_ADD8(which)
  872. PACE_END8(sysTrapUIColorGetTableEntryIndex,NONE,NONE)
  874. PACE_BEGIN(IndexedColorType WinSetForeColor (IndexedColorType foreColor))
  875. PACE_ADD8(foreColor)
  876. PACE_END8(sysTrapWinSetForeColor,NONE,NONE)
  878. PACE_BEGIN(IndexedColorType WinSetBackColor (IndexedColorType backColor))
  879. PACE_ADD8(backColor)
  880. PACE_END8(sysTrapWinSetBackColor,NONE,NONE)
  882. PACE_BEGIN(IndexedColorType WinSetTextColor (IndexedColorType textColor))
  883. PACE_ADD8(textColor)
  884. PACE_END8(sysTrapWinSetTextColor,NONE,NONE)
  886. PACE_BEGIN(UInt16 FrmDoDialog (FormType *formP))
  887. PACE_ADD32(formP)
  888. PACE_END16(sysTrapFrmDoDialog,NONE,NONE)
  890. PACE_BEGIN(UInt16 FrmGetFormId (const FormType *formP))
  891. PACE_ADD32(formP)
  892. PACE_END16(sysTrapFrmGetFormId,NONE,NONE)
  894. PACE_BEGIN(void FrmPopupForm (UInt16 formId))
  895. PACE_ADD16(formId)
  896. PACE_END(sysTrapFrmPopupForm,NONE,NONE)
  898. PACE_BEGIN(void FrmDrawForm (FormType *formP))
  899. PACE_ADD32(formP)
  900. PACE_END(sysTrapFrmDrawForm,NONE,NONE)
  902. PACE_BEGIN(void FrmEraseForm (FormType *formP))
  903. PACE_ADD32(formP)
  904. PACE_END(sysTrapFrmEraseForm,NONE,NONE)
  906. PACE_BEGIN(Boolean MenuHideItem(UInt16 id))
  907. PACE_ADD16(id)
  908. PACE_END8(sysTrapMenuHideItem,NONE,NONE)
  910. PACE_BEGINEVENT(Boolean MenuHandleEvent(MenuBarType *menuP, EventType *event, UInt16 *error))
  911. PACE_ADD32(menuP)
  912. PACE_ADD32(&ev)
  913. PACE_ADD32(error)
  914. PACE_END8(sysTrapMenuHandleEvent,Event_ARM_To_M68K(event,ev),PACE_DATA16(error))
  916. PACE_BEGIN(Err SysNotifyRegister(UInt16 cardNo, LocalID dbID, UInt32 notifyType, 
  917.  SysNotifyProcPtr callbackP, Int8 priority, void *userDataP))
  918. PACE_ADD16(cardNo)
  919. PACE_ADD32(dbID)
  920. PACE_ADD32(notifyType)
  921. PACE_ADD32(callbackP)
  922. PACE_ADD8(priority)
  923. PACE_ADD32(userDataP)
  924. PACE_END16(sysTrapSysNotifyRegister,NONE,NONE)
  926. PACE_BEGIN(Boolean FrmVisible(const FormType *formP))
  927. PACE_ADD32(formP)
  928. PACE_END8(sysTrapFrmVisible,NONE,NONE)
  930. PACE_BEGIN(void FrmSetActiveForm(FormType *formP))
  931. PACE_ADD32(formP)
  932. PACE_END(sysTrapFrmSetActiveForm,NONE,NONE)
  934. PACE_BEGIN(FormType* FrmInitForm(UInt16 rscID))
  935. PACE_ADD16(rscID)
  936. PACE_ENDPTR(sysTrapFrmInitForm,NONE,NONE)
  938. PACE_BEGIN(WinHandle FrmGetWindowHandle(const FormType *formP))
  939. PACE_ADD32(formP)
  940. PACE_ENDPTR(sysTrapFrmGetWindowHandle,NONE,NONE);
  942. PACE_BEGIN(Err SysNotifyUnregister(UInt16 cardNo, LocalID dbID, UInt32 notifyType, Int8 priority))
  943. PACE_ADD16(cardNo)
  944. PACE_ADD32(dbID)
  945. PACE_ADD32(notifyType)
  946. PACE_ADD8(priority)
  947. PACE_END16(sysTrapSysNotifyUnregister,NONE,NONE)
  949. PACE_BEGIN(Err SysCurAppDatabase(UInt16 *cardNoP, LocalID *dbIDP))
  950. PACE_ADD32(cardNoP)
  951. PACE_ADD32(dbIDP)
  952. PACE_END16(sysTrapSysCurAppDatabase,NONE,PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
  954. PACE_BEGIN(Err WinSetConstraintsSize(WinHandle winH, Coord minH, Coord prefH, Coord maxH,
  955. Coord minW, Coord prefW, Coord maxW))
  956. PACE_ADD32(winH)
  957. PACE_ADD16(minH)
  958. PACE_ADD16(prefH)
  959. PACE_ADD16(maxH)
  960. PACE_ADD16(minW)
  961. PACE_ADD16(prefW)
  962. PACE_ADD16(maxW)
  963. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinWinSetConstraintsSize),NONE)
  965. PACE_BEGIN(Err SysSetOrientation(UInt16 orientation))
  966. PACE_ADD16(orientation)
  967. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinSysSetOrientation),NONE)
  969. PACE_BEGIN(UInt16 PINGetInputAreaState())
  970. PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinPINGetInputAreaState),NONE)
  972. PACE_BEGIN(Err PINSetInputTriggerState(UInt16 state))
  973. PACE_ADD16(state)
  974. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinPINSetInputTriggerState),NONE)
  976. PACE_BEGIN(Err FrmSetDIAPolicyAttr (FormPtr formP, UInt16 diaPolicy))
  977. PACE_ADD32(formP)
  978. PACE_ADD16(diaPolicy)
  979. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinFrmSetDIAPolicyAttr),NONE)
  981. PACE_BEGIN(Err PINSetInputAreaState(UInt16 state))
  982. PACE_ADD16(state)
  983. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinPINSetInputAreaState),NONE)
  985. PACE_BEGIN(Err SysSetOrientationTriggerState(UInt16 triggerState))
  986. PACE_ADD16(triggerState)
  987. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinSysSetOrientationTriggerState),NONE)
  989. PACE_BEGIN(Err StatGetAttribute(UInt16 selector, UInt32* dataP))
  990. PACE_ADD16(selector)
  991. PACE_ADD32(dataP)
  992. PACE_END16(sysTrapPinsDispatch,PACE_SEL(pinStatGetAttribute),PACE_DATA32(dataP))
  994. PACE_BEGIN(Err StatHide())
  995. PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinStatHide),NONE)
  997. PACE_BEGIN(Err StatShow())
  998. PACE_END16VOID(sysTrapPinsDispatch,PACE_SEL(pinStatShow),NONE)
  1000. PACE_BEGIN(UInt16 SysSetAutoOffTime(UInt16 seconds))
  1001. PACE_ADD16(seconds)
  1002. PACE_END16(sysTrapSysSetAutoOffTime,NONE,NONE);
  1004. PACE_BEGIN(Err SysTaskDelay(Int32 delay))
  1005. PACE_ADD32(delay)
  1006. PACE_END16(sysTrapSysTaskDelay,NONE,NONE);
  1008. PACE_BEGIN(UInt16 SysTicksPerSecond())
  1009. PACE_END16VOID(sysTrapSysTicksPerSecond,NONE,NONE)
  1011. PACE_BEGIN(UInt32 TimGetTicks())
  1012. PACE_END32VOID(sysTrapTimGetTicks,NONE,NONE)
  1014. PACE_BEGIN(MemPtr MemPtrNew(UInt32 n))
  1015. PACE_ADD32(n)
  1016. PACE_ENDPTR(sysTrapMemPtrNew,NONE,NONE)
  1018. PACE_BEGIN(Err MemChunkFree(MemPtr p))
  1019. PACE_ADD32(p)
  1020. PACE_END16(sysTrapMemChunkFree,NONE,NONE)
  1022. PACE_BEGIN(UInt32 MemPtrSize(MemPtr p))
  1023. PACE_ADD32(p)
  1024. PACE_END32(sysTrapMemPtrSize,NONE,NONE)
  1026. PACE_BEGIN(Err MemPtrResize(MemPtr p,UInt32 n))
  1027. PACE_ADD32(p)
  1028. PACE_ADD32(n)
  1029. PACE_END16(sysTrapMemPtrResize,NONE,NONE)
  1031. PACE_BEGIN(Err MemHeapFreeBytes(UInt16 heapID,UInt32* freeP,UInt32* maxP))
  1032. PACE_ADD16(heapID)
  1033. PACE_ADD32(freeP)
  1034. PACE_ADD32(maxP)
  1035. PACE_END16(sysTrapMemHeapFreeBytes,NONE,PACE_DATA32(freeP) PACE_DATA32(maxP))
  1037. PACE_BEGIN(UInt16 MemHeapID(UInt16 cardNo, UInt16 heapIndex))
  1038. PACE_ADD16(cardNo)
  1039. PACE_ADD16(heapIndex)
  1040. PACE_END16(sysTrapMemHeapID,NONE,NONE)
  1042. PACE_BEGIN(Err MemHeapCheck(UInt16 heapID))
  1043. PACE_ADD16(heapID)
  1044. PACE_END16(sysTrapMemHeapCheck,NONE,NONE)
  1046. PACE_BEGIN(UInt32 PrefGetPreference(SystemPreferencesChoice choice))
  1047. PACE_ADD8(choice)
  1048. PACE_END32(sysTrapPrefGetPreference,NONE,NONE)
  1050. PACE_BEGIN(Int16 PrefGetAppPreferences (UInt32 creator, UInt16 id, void *prefs, 
  1051. UInt16 *prefsSize, Boolean saved))
  1052. PACE_ADD32(creator)
  1053. PACE_ADD16(id)
  1054. PACE_ADD32(prefs)
  1055. PACE_ADD32(prefsSize)
  1056. PACE_ADD8(saved)
  1057. PACE_END16(sysTrapPrefGetAppPreferences,PACE_DATA16(prefsSize),PACE_DATA16(prefsSize))
  1059. PACE_BEGIN(void PrefSetAppPreferences (UInt32 creator, UInt16 id, Int16 version, const void *prefs, 
  1060. UInt16 prefsSize, Boolean saved))
  1061. PACE_ADD32(creator)
  1062. PACE_ADD16(id)
  1063. PACE_ADD16(version)
  1064. PACE_ADD32(prefs)
  1065. PACE_ADD16(prefsSize)
  1066. PACE_ADD8(saved)
  1067. PACE_END(sysTrapPrefSetAppPreferences,NONE,NONE)
  1069. PACE_BEGIN(UInt16 FrmCustomAlert(UInt16 alertId,const Char *s1,const Char *s2,const Char *s3))
  1070. PACE_ADD16(alertId)
  1071. PACE_ADD32(s1)
  1072. PACE_ADD32(s2)
  1073. PACE_ADD32(s3)
  1074. PACE_END16(sysTrapFrmCustomAlert,NONE,NONE)
  1076. PACE_BEGIN(void FrmGetObjectBounds (const FormType *formP, UInt16 objIndex,RectangleType *rP))
  1077. PACE_ADD32(formP)
  1078. PACE_ADD16(objIndex)
  1079. PACE_ADD32(rP)
  1080. PACE_END(sysTrapFrmGetObjectBounds,NONE,SwapStruct(rP,2,2,2,2,0))
  1082. PACE_BEGIN(void WinGetDisplayExtent (Coord *extentX, Coord *extentY))
  1083. PACE_ADD32(extentX)
  1084. PACE_ADD32(extentY)
  1085. PACE_END(sysTrapWinGetDisplayExtent,NONE,PACE_DATA16(extentX) PACE_DATA16(extentY))
  1087. PACE_BEGIN(void WinGetBounds(WinHandle winH, RectangleType *rP))
  1088. PACE_ADD32(winH)
  1089. PACE_ADD32(rP)
  1090. PACE_END(sysTrapWinGetBounds,NONE,SwapStruct(rP,2,2,2,2,0))
  1092. PACE_BEGINEX(void WinSetBounds (WinHandle winHandle, const RectangleType *rP),r)
  1093. PACE_ADD16(rP->topLeft.x)
  1094. PACE_ADD16(rP->topLeft.y)
  1095. PACE_ADD16(rP->extent.x)
  1096. PACE_ADD16(rP->extent.y)
  1097. PACE_VAR(PACE_PARAM)
  1098. PACE_ADD32(winHandle)
  1099. PACE_ADD32(r)
  1100. PACE_END(sysTrapWinSetBounds,NONE,NONE)
  1102. PACE_BEGINEX(void FrmSetObjectBounds (FormType *formP, UInt16 objIndex,const RectangleType *bounds),r)
  1103. PACE_ADD16(bounds->topLeft.x)
  1104. PACE_ADD16(bounds->topLeft.y)
  1105. PACE_ADD16(bounds->extent.x)
  1106. PACE_ADD16(bounds->extent.y)
  1107. PACE_VAR(PACE_PARAM)
  1108. PACE_ADD32(formP)
  1109. PACE_ADD16(objIndex)
  1110. PACE_ADD32(r)
  1111. PACE_END(sysTrapFrmSetObjectBounds,NONE,NONE)
  1113. PACE_BEGINEX(void WinDrawRectangle (const RectangleType *rP, UInt16 cornerDiam),r)
  1114. PACE_ADD16(rP->topLeft.x)
  1115. PACE_ADD16(rP->topLeft.y)
  1116. PACE_ADD16(rP->extent.x)
  1117. PACE_ADD16(rP->extent.y)
  1118. PACE_VAR(PACE_PARAM)
  1119. PACE_ADD32(r)
  1120. PACE_ADD16(cornerDiam)
  1121. PACE_END(sysTrapWinDrawRectangle,NONE,NONE)
  1123. PACE_BEGIN(void WinDrawBitmap (BitmapPtr bitmapP, Coord x, Coord y))
  1124. PACE_ADD32(bitmapP)
  1125. PACE_ADD16(x)
  1126. PACE_ADD16(y)
  1127. PACE_END(sysTrapWinDrawBitmap,NONE,NONE)
  1129. PACE_BEGINEX(void WinEraseRectangle(const RectangleType *rP, UInt16 cornerDiam),r)
  1130. PACE_ADD16(rP->topLeft.x)
  1131. PACE_ADD16(rP->topLeft.y)
  1132. PACE_ADD16(rP->extent.x)
  1133. PACE_ADD16(rP->extent.y)
  1134. PACE_VAR(PACE_PARAM)
  1135. PACE_ADD32(r)
  1136. PACE_ADD16(cornerDiam)
  1137. PACE_END(sysTrapWinEraseRectangle,NONE,NONE)
  1139. PACE_BEGIN(void WinDrawChars(const Char *chars, Int16 len, Coord x, Coord y))
  1140. PACE_ADD32(chars)
  1141. PACE_ADD16(len)
  1142. PACE_ADD16(x)
  1143. PACE_ADD16(y)
  1144. PACE_END(sysTrapWinDrawChars,NONE,NONE)
  1146. PACE_BEGIN(SysAppInfoPtr SysGetAppInfo(SysAppInfoPtr *uiAppPP, SysAppInfoPtr* actionCodeAppPP))
  1147. PACE_ADD32(uiAppPP)
  1148. PACE_ADD32(actionCodeAppPP)
  1149. PACE_ENDPTR(sysTrapSysGetAppInfo,NONE,NONE) 
  1151. PACE_BEGIN(MemPtr MemChunkNew(UInt16 heapID, UInt32 size, UInt16 attr))
  1152. PACE_ADD16(heapID)
  1153. PACE_ADD32(size)
  1154. PACE_ADD16(attr)
  1155. PACE_ENDPTR(sysTrapMemChunkNew,NONE,NONE)
  1157. PACE_BEGIN(Err VFSVolumeEnumerate(UInt16 *volRefNumP, UInt32 *volIteratorP))
  1158. PACE_ADD32(volRefNumP)
  1159. PACE_ADD32(volIteratorP)
  1160. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeEnumerate) PACE_DATA32(volIteratorP),PACE_DATA16(volRefNumP) PACE_DATA32(volIteratorP))
  1162. PACE_BEGIN(Err VFSVolumeGetLabel(UInt16 volRefNum, Char *labelP, UInt16 bufLen))
  1163. PACE_ADD16(volRefNum)
  1164. PACE_ADD32(labelP)
  1165. PACE_ADD16(bufLen)
  1166. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeGetLabel),NONE)
  1168. PACE_BEGIN(Err VFSVolumeInfo(UInt16 volRefNum, VolumeInfoType *volInfoP))
  1169. PACE_ADD16(volRefNum)
  1170. PACE_ADD32(volInfoP)
  1171. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapVolumeInfo),SwapStruct(volInfoP,4,4,4,4,2,2,4,4,0))
  1173. PACE_BEGIN(Err FtrPtrFree(UInt32 creator, UInt16 featureNum))
  1174. PACE_ADD32(creator)
  1175. PACE_ADD16(featureNum)
  1176. PACE_END16(sysTrapFtrPtrFree,NONE,NONE)
  1178. PACE_BEGIN(Err FtrGet(UInt32 creator, UInt16 featureNum, UInt32 *valueP))
  1179. PACE_ADD32(creator)
  1180. PACE_ADD16(featureNum)
  1181. PACE_ADD32(valueP)
  1182. PACE_END16(sysTrapFtrGet,NONE,PACE_DATA32(valueP))
  1184. PACE_BEGIN(Err FtrSet(UInt32 creator, UInt16 featureNum, UInt32 newValue))
  1185. PACE_ADD32(creator)
  1186. PACE_ADD16(featureNum)
  1187. PACE_ADD32(newValue)
  1188. PACE_END16(sysTrapFtrSet,NONE,NONE)
  1190. PACE_BEGIN(Err FtrPtrNew(UInt32 creator, UInt16 featureNum, UInt32 size,void **newPtrP))
  1191. PACE_ADD32(creator)
  1192. PACE_ADD16(featureNum)
  1193. PACE_ADD32(size)
  1194. PACE_ADD32(newPtrP)
  1195. PACE_END16(sysTrapFtrPtrNew,NONE,PACE_DATA32((UInt32*)newPtrP))
  1197. PACE_BEGIN(Err DmWrite(void *recordP, UInt32 offset, const void *srcP, UInt32 bytes))
  1198. PACE_ADD32(recordP)
  1199. PACE_ADD32(offset)
  1200. PACE_ADD32(srcP)
  1201. PACE_ADD32(bytes)
  1202. PACE_END16(sysTrapDmWrite,NONE,NONE)
  1204. PACE_BEGIN(MemHandle DmGetResource(DmResType type, DmResID resID))
  1205. PACE_ADD32(type)
  1206. PACE_ADD16(resID)
  1207. PACE_ENDPTR(sysTrapDmGetResource,NONE,NONE)
  1209. PACE_BEGIN(Err DmReleaseResource(MemHandle resourceH))
  1210. PACE_ADD32(resourceH)
  1211. PACE_END16(sysTrapDmReleaseResource,NONE,NONE)
  1213. PACE_BEGIN(UInt32 MemHandleSize(MemHandle h))
  1214. PACE_ADD32(h)
  1215. PACE_END32(sysTrapMemHandleSize,NONE,NONE)
  1217. PACE_BEGIN(MemPtr MemHandleLock(MemHandle h))
  1218. PACE_ADD32(h)
  1219. PACE_ENDPTR(sysTrapMemHandleLock,NONE,NONE)
  1221. PACE_BEGIN(Err MemHandleUnlock(MemHandle h))
  1222. PACE_ADD32(h)
  1223. PACE_END16(sysTrapMemHandleUnlock,NONE,NONE)
  1225. PACE_BEGIN(Err MemPtrUnlock(MemPtr h))
  1226. PACE_ADD32(h)
  1227. PACE_END16(sysTrapMemPtrUnlock,NONE,NONE)
  1229. PACE_BEGIN(Err DmGetNextDatabaseByTypeCreator(Boolean newSearch, DmSearchStatePtr stateInfoP,
  1230.   UInt32 type, UInt32 creator, Boolean onlyLatestVers, 
  1231.   UInt16 *cardNoP, LocalID *dbIDP))
  1232. PACE_ADD8(newSearch)
  1233. PACE_ADD32(stateInfoP)
  1234. PACE_ADD32(type)
  1235. PACE_ADD32(creator)
  1236. PACE_ADD8(onlyLatestVers)
  1237. PACE_ADD32(cardNoP)
  1238. PACE_ADD32(dbIDP)
  1239. PACE_END16(sysTrapDmGetNextDatabaseByTypeCreator,PACE_DATA32(dbIDP),PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
  1241. PACE_BEGIN(Err DmDatabaseSize(UInt16 cardNo, LocalID dbID, UInt32 *numRecordsP,
  1242. UInt32 *totalBytesP, UInt32 *dataBytesP))
  1243. PACE_ADD16(cardNo)
  1244. PACE_ADD32(dbID)
  1245. PACE_ADD32(numRecordsP)
  1246. PACE_ADD32(totalBytesP)
  1247. PACE_ADD32(dataBytesP)
  1248. PACE_END16(sysTrapDmDatabaseSize,NONE,
  1249.    PACE_CDATA32(numRecordsP)
  1250.    PACE_CDATA32(totalBytesP)
  1251.    PACE_CDATA32(dataBytesP))
  1253. PACE_BEGIN(DmOpenRef DmOpenDatabaseByTypeCreator(UInt32 type, UInt32 creator, UInt16 mode))
  1254. PACE_ADD32(type)
  1255. PACE_ADD32(creator)
  1256. PACE_ADD16(mode)
  1257. PACE_ENDPTR(sysTrapDmOpenDatabaseByTypeCreator,NONE,NONE)
  1259. PACE_BEGIN(Err DmCloseDatabase(DmOpenRef dbP))
  1260. PACE_ADD32(dbP)
  1261. PACE_END16(sysTrapDmCloseDatabase,NONE,NONE)
  1263. PACE_BEGIN(Err DmDeleteDatabase(UInt16 cardNo, LocalID dbID))
  1264. PACE_ADD16(cardNo)
  1265. PACE_ADD32(dbID)
  1266. PACE_END16(sysTrapDmDeleteDatabase,NONE,NONE)
  1268. PACE_BEGIN(Err DmSetDatabaseInfo(UInt16 cardNo, LocalID dbID, const Char *nameP,
  1269. UInt16 *attributesP, UInt16 *versionP, UInt32 *crDateP,
  1270. UInt32 * modDateP, UInt32 *bckUpDateP,
  1271. UInt32 * modNumP, LocalID *appInfoIDP,
  1272. LocalID *sortInfoIDP, UInt32 *typeP,
  1273. UInt32 *creatorP))
  1274. PACE_ADD16(cardNo)
  1275. PACE_ADD32(dbID)
  1276. PACE_ADD32(nameP)
  1277. PACE_ADD32(attributesP)
  1278. PACE_ADD32(versionP)
  1279. PACE_ADD32(crDateP)
  1280. PACE_ADD32(modDateP)
  1281. PACE_ADD32(bckUpDateP)
  1282. PACE_ADD32(modNumP)
  1283. PACE_ADD32(appInfoIDP)
  1284. PACE_ADD32(sortInfoIDP)
  1285. PACE_ADD32(typeP)
  1286. PACE_ADD32(creatorP)
  1287. PACE_END16(sysTrapDmSetDatabaseInfo,
  1288. PACE_CDATA16(attributesP) 
  1289. PACE_CDATA16(versionP) 
  1290. PACE_CDATA32(crDateP) 
  1291. PACE_CDATA32(modDateP) 
  1292. PACE_CDATA32(bckUpDateP) 
  1293. PACE_CDATA32(modNumP) 
  1294. PACE_CDATA32(appInfoIDP) 
  1295. PACE_CDATA32(sortInfoIDP) 
  1296. PACE_CDATA32(typeP) 
  1297. PACE_CDATA32(creatorP),
  1299. PACE_CDATA16(attributesP) 
  1300. PACE_CDATA16(versionP) 
  1301. PACE_CDATA32(crDateP) 
  1302. PACE_CDATA32(modDateP) 
  1303. PACE_CDATA32(bckUpDateP) 
  1304. PACE_CDATA32(modNumP) 
  1305. PACE_CDATA32(appInfoIDP) 
  1306. PACE_CDATA32(sortInfoIDP) 
  1307. PACE_CDATA32(typeP) 
  1308. PACE_CDATA32(creatorP))
  1310. PACE_BEGIN(Err DmDatabaseInfo(UInt16 cardNo, LocalID dbID, Char *nameP,
  1311. UInt16 *attributesP, UInt16 *versionP, UInt32 *crDateP,
  1312. UInt32 *modDateP, UInt32 *bckUpDateP,
  1313. UInt32 *modNumP, LocalID *appInfoIDP,
  1314. LocalID *sortInfoIDP, UInt32 *typeP,
  1315. UInt32 *creatorP))
  1316. PACE_ADD16(cardNo)
  1317. PACE_ADD32(dbID)
  1318. PACE_ADD32(nameP)
  1319. PACE_ADD32(attributesP)
  1320. PACE_ADD32(versionP)
  1321. PACE_ADD32(crDateP)
  1322. PACE_ADD32(modDateP)
  1323. PACE_ADD32(bckUpDateP)
  1324. PACE_ADD32(modNumP)
  1325. PACE_ADD32(appInfoIDP)
  1326. PACE_ADD32(sortInfoIDP)
  1327. PACE_ADD32(typeP)
  1328. PACE_ADD32(creatorP)
  1329. PACE_END16(sysTrapDmDatabaseInfo,NONE,
  1330. PACE_CDATA16(attributesP) 
  1331. PACE_CDATA16(versionP) 
  1332. PACE_CDATA32(crDateP) 
  1333. PACE_CDATA32(modDateP) 
  1334. PACE_CDATA32(bckUpDateP) 
  1335. PACE_CDATA32(modNumP) 
  1336. PACE_CDATA32(appInfoIDP) 
  1337. PACE_CDATA32(sortInfoIDP) 
  1338. PACE_CDATA32(typeP) 
  1339. PACE_CDATA32(creatorP))
  1341. PACE_BEGIN(FileHand FileOpen(UInt16 cardNo, const Char * nameP, UInt32 type, UInt32 creator,
  1342. UInt32 openMode, Err *errP))
  1343. PACE_ADD16(cardNo)
  1344. PACE_ADD32(nameP)
  1345. PACE_ADD32(type)
  1346. PACE_ADD32(creator)
  1347. PACE_ADD32(openMode)
  1348. PACE_ADD32(errP)
  1349. PACE_ENDPTR(sysTrapFileOpen,NONE,PACE_CDATA16(errP))
  1351. PACE_BEGIN(Err FileClose(FileHand stream))
  1352. PACE_ADD32(stream)
  1353. PACE_END16(sysTrapFileClose,NONE,NONE)
  1355. PACE_BEGIN(Int32 FileReadLow(FileHand stream, void *baseP, Int32 offset, Boolean dataStoreBased, Int32 objSize,
  1356. Int32 numObj, Err *errP))
  1357. PACE_ADD32(stream)
  1358. PACE_ADD32(baseP)
  1359. PACE_ADD32(offset)
  1360. PACE_ADD8(dataStoreBased)
  1361. PACE_ADD32(objSize)
  1362. PACE_ADD32(numObj)
  1363. PACE_ADD32(errP)
  1364. PACE_END32(sysTrapFileReadLow,NONE,PACE_CDATA16(errP))
  1366. PACE_BEGIN(Err FileSeek(FileHand stream, Int32 offset, FileOriginEnum origin))
  1367. PACE_ADD32(stream)
  1368. PACE_ADD32(offset)
  1369. PACE_ADD8(origin)
  1370. PACE_END16(sysTrapFileSeek,NONE,NONE)
  1372. PACE_BEGIN(Int32 FileTell(FileHand stream, Int32 *fileSizeP, Err *errP))
  1373. PACE_ADD32(stream)
  1374. PACE_ADD32(fileSizeP)
  1375. PACE_ADD32(errP)
  1376. PACE_END32(sysTrapFileTell,NONE,PACE_CDATA32(fileSizeP) PACE_CDATA16(errP))
  1378. PACE_BEGIN(void WinGetClip(RectangleType *rP))
  1379. PACE_ADD32(rP)
  1380. PACE_END(sysTrapWinGetClip,NONE,SwapStruct(rP,2,2,2,2,0))
  1382. PACE_BEGINEX(void WinSetClip (const RectangleType *rP),r)
  1383. PACE_ADD16(rP->topLeft.x)
  1384. PACE_ADD16(rP->topLeft.y)
  1385. PACE_ADD16(rP->extent.x)
  1386. PACE_ADD16(rP->extent.y)
  1387. PACE_VAR(PACE_PARAM)
  1388. PACE_ADD32(r)
  1389. PACE_END(sysTrapWinSetClip,NONE,NONE)
  1391. PACE_BEGIN(void WinPushDrawState())
  1392. PACE_ENDVOID(sysTrapWinPushDrawState,NONE,NONE)
  1394. PACE_BEGIN(void WinPopDrawState())
  1395. PACE_ENDVOID(sysTrapWinPopDrawState,NONE,NONE)
  1397. PACE_BEGIN(void SclSetScrollBar (ScrollBarType *bar, Int16 value, Int16 min, Int16 max, Int16 pageSize))
  1398. PACE_ADD32(bar)
  1399. PACE_ADD16(value)
  1400. PACE_ADD16(min)
  1401. PACE_ADD16(max)
  1402. PACE_ADD16(pageSize)
  1403. PACE_END(sysTrapSclSetScrollBar,NONE,NONE)
  1405. PACE_BEGIN(UInt16 WinSetCoordinateSystem(UInt16 coordSys))
  1406. PACE_ADD16(coordSys)
  1407. PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinSetCoordinateSystem),NONE)
  1409. PACE_BEGIN(Coord WinScaleCoord(Coord coord, Boolean ceiling))
  1410. PACE_ADD16(coord)
  1411. PACE_ADD8(ceiling)
  1412. PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinScaleCoord),NONE)
  1414. PACE_BEGIN(UInt16 WinGetCoordinateSystem())
  1415. PACE_END16VOID(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinGetCoordinateSystem),NONE)
  1417. PACE_BEGIN(Err WinScreenGetAttribute(WinScreenAttrType selector, UInt32* attrP))
  1418. PACE_ADD8(selector)
  1419. PACE_ADD32(attrP)
  1420. PACE_END16(sysTrapHighDensityDispatch,PACE_SEL(HDSelectorWinScreenGetAttribute),PACE_DATA32(attrP))
  1422. PACE_BEGIN(Err WinScreenMode(WinScreenModeOperation operation, 
  1423. UInt32 *widthP,
  1424. UInt32 *heightP, 
  1425. UInt32 *depthP, 
  1426. Boolean *enableColorP))
  1427. PACE_ADD8(operation)
  1428. PACE_ADD32(widthP)
  1429. PACE_ADD32(heightP)
  1430. PACE_ADD32(depthP)
  1431. PACE_ADD32(enableColorP)
  1432. PACE_END16(sysTrapWinScreenMode,PACE_CDATA32(widthP) PACE_CDATA32(heightP) PACE_CDATA32(depthP),
  1433. PACE_CDATA32(widthP) PACE_CDATA32(heightP) PACE_CDATA32(depthP))
  1435. PACE_BEGIN(Err WinPalette(UInt8 operation, Int16 startIndex, 
  1436.       UInt16 paletteEntries, RGBColorType *tableP))
  1437. PACE_ADD8(operation)
  1438. PACE_ADD16(startIndex)
  1439. PACE_ADD16(paletteEntries)
  1440. PACE_ADD32(tableP)
  1441. PACE_END16(sysTrapWinPalette,NONE,NONE)
  1443. PACE_BEGIN(WinHandle WinGetDisplayWindow())
  1444. PACE_ENDPTRVOID(sysTrapWinGetDisplayWindow,NONE,NONE)
  1446. PACE_BEGIN(WinHandle WinGetActiveWindow())
  1447. PACE_ENDPTRVOID(sysTrapWinGetActiveWindow,NONE,NONE)
  1449. PACE_BEGIN(BitmapType *WinGetBitmap(WinHandle winHandle))
  1450. PACE_ADD32(winHandle)
  1451. PACE_ENDPTR(sysTrapWinGetBitmap,NONE,NONE)
  1453. PACE_BEGIN(void BmpGetDimensions(const BitmapType * bitmapP,Coord *widthP,Coord *heightP,UInt16 *rowBytesP))
  1454. PACE_ADD32(bitmapP)
  1455. PACE_ADD32(widthP)
  1456. PACE_ADD32(heightP)
  1457. PACE_ADD32(rowBytesP)
  1458. PACE_END(sysTrapBmpGetDimensions,NONE,PACE_CDATA16(widthP) PACE_CDATA16(heightP) PACE_CDATA16(rowBytesP))
  1460. PACE_BEGIN(void* BmpGetBits(BitmapType * bitmapP))
  1461. PACE_ADD32(bitmapP)
  1462. PACE_ENDPTR(sysTrapBmpGetBits,NONE,NONE)
  1464. PACE_BEGIN(void WinSetBackColorRGB(const RGBColorType* newRgbP, RGBColorType* prevRgbP))
  1465. PACE_ADD32(newRgbP)
  1466. PACE_ADD32(prevRgbP)
  1467. PACE_END(sysTrapWinSetBackColorRGB,NONE,NONE)
  1469. PACE_BEGIN(Err VFSRegisterDefaultDirectory(const Char *fileTypeStr, UInt32 mediaType, 
  1470. const Char *pathStr))
  1471. PACE_ADD32(fileTypeStr)
  1472. PACE_ADD32(mediaType)
  1473. PACE_ADD32(pathStr)
  1474. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapRegisterDefaultDirectory),NONE)
  1476. PACE_BEGIN(Err VFSGetDefaultDirectory(UInt16 volRefNum, const Char *fileTypeStr,Char *pathStr, UInt16 *bufLenP))
  1477. PACE_ADD16(volRefNum)
  1478. PACE_ADD32(fileTypeStr)
  1479. PACE_ADD32(pathStr)
  1480. PACE_ADD32(bufLenP)
  1481. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapGetDefaultDirectory) PACE_DATA16(bufLenP),PACE_DATA16(bufLenP));
  1483. PACE_BEGIN(Err VFSImportDatabaseFromFile(UInt16 volRefNum, const Char *pathNameP, UInt16 *cardNoP, LocalID *dbIDP))
  1484. PACE_ADD16(volRefNum)
  1485. PACE_ADD32(pathNameP)
  1486. PACE_ADD32(cardNoP)
  1487. PACE_ADD32(dbIDP)
  1488. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapImportDatabaseFromFile),PACE_DATA16(cardNoP) PACE_DATA32(dbIDP))
  1490. PACE_BEGIN(Err VFSFileOpen(UInt16 volRefNum, const Char *pathNameP, UInt16 openMode, FileRef *fileRefP))
  1491. PACE_ADD16(volRefNum)
  1492. PACE_ADD32(pathNameP)
  1493. PACE_ADD16(openMode)
  1494. PACE_ADD32(fileRefP)
  1495. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileOpen),PACE_DATA32(fileRefP))
  1497. PACE_BEGIN(Err VFSFileClose(FileRef fileRef))
  1498. PACE_ADD32(fileRef)
  1499. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileClose),NONE)
  1501. PACE_BEGIN(Err VFSFileSize(FileRef fileRef,UInt32 *fileSizeP))
  1502. PACE_ADD32(fileRef)
  1503. PACE_ADD32(fileSizeP)
  1504. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileSize),PACE_DATA32(fileSizeP))
  1506. PACE_BEGIN(Err VFSFileGetDate(FileRef fileRef, UInt16 whichDate, UInt32 *dateP))
  1507. PACE_ADD32(fileRef)
  1508. PACE_ADD16(whichDate)
  1509. PACE_ADD32(dateP)
  1510. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileGetDate),PACE_DATA32(dateP))
  1512. PACE_BEGIN(Err VFSDirEntryEnumerate(FileRef dirRef,UInt32 *dirEntryIteratorP, FileInfoType *infoP))
  1513. PACE_ADD32(dirRef)
  1514. PACE_ADD32(dirEntryIteratorP)
  1515. PACE_ADD32(infoP)
  1516. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapDirEntryEnumerate) 
  1517.                          PACE_DATA32(dirEntryIteratorP)
  1518.  SwapStruct(infoP,4,4,2,0),
  1519.                          PACE_DATA32(dirEntryIteratorP)
  1520.  SwapStruct(infoP,4,4,2,0))
  1522. PACE_BEGIN(Err VFSFileGetAttributes(FileRef fileRef, UInt32 *attributesP))
  1523. PACE_ADD32(fileRef)
  1524. PACE_ADD32(attributesP)
  1525. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileGetAttributes),PACE_DATA32(attributesP))
  1527. PACE_BEGIN(Err VFSFileReadData(FileRef fileRef, UInt32 numBytes, void *bufBaseP, UInt32 offset, UInt32 *numBytesReadP))
  1528. PACE_ADD32(fileRef)
  1529. PACE_ADD32(numBytes)
  1530. PACE_ADD32(bufBaseP)
  1531. PACE_ADD32(offset)
  1532. PACE_ADD32(numBytesReadP)
  1533. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileReadData),PACE_CDATA32(numBytesReadP))
  1535. PACE_BEGIN(Err VFSFileRead(FileRef fileRef, UInt32 numBytes, void *bufP, UInt32 *numBytesReadP))
  1536. PACE_ADD32(fileRef)
  1537. PACE_ADD32(numBytes)
  1538. PACE_ADD32(bufP)
  1539. PACE_ADD32(numBytesReadP)
  1540. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileRead),PACE_CDATA32(numBytesReadP))
  1542. PACE_BEGIN(Err VFSFileWrite(FileRef fileRef, UInt32 numBytes, const void *dataP, UInt32 *numBytesWrittenP))
  1543. PACE_ADD32(fileRef)
  1544. PACE_ADD32(numBytes)
  1545. PACE_ADD32(dataP)
  1546. PACE_ADD32(numBytesWrittenP)
  1547. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileWrite),PACE_DATA32(numBytesWrittenP))
  1549. PACE_BEGIN(Err VFSFileSeek(FileRef fileRef, FileOrigin origin, Int32 offset))
  1550. PACE_ADD32(fileRef)
  1551. PACE_ADD16(origin)
  1552. PACE_ADD32(offset)
  1553. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileSeek),NONE)
  1555. PACE_BEGIN(Err VFSFileTell(FileRef fileRef,UInt32 *filePosP))
  1556. PACE_ADD32(fileRef)
  1557. PACE_ADD32(filePosP)
  1558. PACE_END16(sysTrapVFSMgr,PACE_SEL(vfsTrapFileTell),PACE_DATA32(filePosP))
  1560. PACE_BEGIN(UInt32 PceNativeCall(NativeFuncType *nativeFuncP, void *userDataP))
  1561. PACE_ADD32(nativeFuncP)
  1562. PACE_ADD32(userDataP)
  1563. PACE_END32(sysTrapPceNativeCall,NONE,NONE)
  1565. PACE_BEGIN(UInt8 *WinScreenLock(WinLockInitType initMode))
  1566. PACE_ADD8(initMode)
  1567. PACE_ENDPTR(sysTrapWinScreenLock,NONE,NONE)
  1569. PACE_BEGIN(void WinScreenUnlock())
  1570. PACE_ENDVOID(sysTrapWinScreenUnlock,NONE,NONE)
  1572. PACE_BEGIN(void LstSetHeight (ListType *listP, Int16 visibleItems))
  1573. PACE_ADD32(listP)
  1574. PACE_ADD16(visibleItems)
  1575. PACE_END(sysTrapLstSetHeight,NONE,NONE);
  1577. PACE_BEGIN(void LstSetListChoices (ListType *listP, Char **itemsText, Int16 numItems))
  1578. PACE_ADD32(listP)
  1579. PACE_ADD32(itemsText)
  1580. PACE_ADD16(numItems)
  1581. PACE_END(sysTrapLstSetListChoices,SwapBlock32(itemsText,numItems),NONE)
  1583. PACE_BEGIN(void LstSetSelection(ListType *listP, Int16 itemNum))
  1584. PACE_ADD32(listP)
  1585. PACE_ADD16(itemNum)
  1586. PACE_END(sysTrapLstSetSelection,NONE,NONE)
  1588. PACE_BEGIN(Char* LstGetSelectionText(const ListType *listP, Int16 itemNum))
  1589. PACE_ADD32(listP)
  1590. PACE_ADD16(itemNum)
  1591. PACE_ENDPTR(sysTrapLstGetSelectionText,NONE,NONE)
  1593. PACE_BEGIN(MemHandle MemHandleNew(UInt32 size))
  1594. PACE_ADD32(size)
  1595. PACE_ENDPTR(sysTrapMemHandleNew,NONE,NONE)
  1597. PACE_BEGIN(Err MemHandleFree(MemHandle h))
  1598. PACE_ADD32(h)
  1599. PACE_END16(sysTrapMemHandleFree,NONE,NONE)
  1601. PACE_BEGIN(Char* FldGetTextPtr(const FieldType *fldP))
  1602. PACE_ADD32(fldP)
  1603. PACE_ENDPTR(sysTrapFldGetTextPtr,NONE,NONE)
  1605. PACE_BEGIN(void FldSetTextHandle(FieldType *fldP, MemHandle textHandle))
  1606. PACE_ADD32(fldP)
  1607. PACE_ADD32(textHandle)
  1608. PACE_END(sysTrapFldSetTextHandle,NONE,NONE)
  1610. PACE_BEGIN(MemHandle FldGetTextHandle(const FieldType *fldP))
  1611. PACE_ADD32(fldP)
  1612. PACE_ENDPTR(sysTrapFldGetTextHandle,NONE,NONE)
  1614. PACE_BEGIN(void SndPlaySystemSound(SndSysBeepType beepID))
  1615. PACE_ADD8(beepID)
  1616. PACE_END(sysTrapSndPlaySystemSound,NONE,NONE)
  1618. PACE_BEGIN(Err SndStreamCreate(SndStreamRef *channel,SndStreamMode mode,UInt32 samplerate,
  1619. SndSampleType type,SndStreamWidth width,SndStreamBufferCallback func,
  1620. void *userdata,UInt32 buffsize,Boolean armNative))
  1621. PACE_ADD32(channel)
  1622. PACE_ADD8(mode)
  1623. PACE_ADD32(samplerate)
  1624. PACE_ADD16(type)
  1625. PACE_ADD8(width)
  1626. PACE_ADD32(func)
  1627. PACE_ADD32(userdata)
  1628. PACE_ADD32(buffsize)
  1629. PACE_ADD8(armNative)
  1630. PACE_END16(sysTrapSndStreamCreate,NONE,PACE_DATA32(channel))
  1632. PACE_BEGIN(Err SndStreamDelete(SndStreamRef channel))
  1633. PACE_ADD32(channel)
  1634. PACE_END16(sysTrapSndStreamDelete,NONE,NONE)
  1636. PACE_BEGIN(Err SndStreamStart(SndStreamRef channel))
  1637. PACE_ADD32(channel)
  1638. PACE_END16(sysTrapSndStreamStart,NONE,NONE)
  1640. PACE_BEGIN(Err SndStreamPause(SndStreamRef channel, Boolean pause))
  1641. PACE_ADD32(channel)
  1642. PACE_ADD8(pause)
  1643. PACE_END16(sysTrapSndStreamPause,NONE,NONE)
  1645. PACE_BEGIN(Err SndStreamStop(SndStreamRef channel))
  1646. PACE_ADD32(channel)
  1647. PACE_END16(sysTrapSndStreamStop,NONE,NONE)
  1649. PACE_BEGIN(Err SndStreamSetPan(SndStreamRef channel, Int32 panposition))
  1650. PACE_ADD32(channel)
  1651. PACE_ADD32(panposition)
  1652. PACE_END16(sysTrapSndStreamSetPan,NONE,NONE)
  1654. PACE_BEGIN(Err SndStreamSetVolume(SndStreamRef channel, Int32 volume))
  1655. PACE_ADD32(channel)
  1656. PACE_ADD32(volume)
  1657. PACE_END16(sysTrapSndStreamSetVolume,NONE,NONE)
  1659. PACE_BEGIN(Err SndStreamGetVolume(SndStreamRef channel, Int32 *volume))
  1660. PACE_ADD32(channel)
  1661. PACE_ADD32(volume)
  1662. PACE_END16(sysTrapSndStreamGetVolume,NONE,PACE_DATA32(volume))
  1664. PACE_BEGINEVENT(Boolean SysHandleEvent(EventPtr eventP))
  1665. PACE_ADD32(&ev)
  1666. PACE_END8(sysTrapSysHandleEvent,Event_ARM_To_M68K(eventP,ev),NONE)
  1668. PACE_BEGIN(void CtlDrawControl (ControlType *controlP))
  1669. PACE_ADD32(controlP)
  1670. PACE_END(sysTrapCtlDrawControl,NONE,NONE)
  1672. PACE_BEGIN(void FrmCopyLabel (FormType *formP, UInt16 labelID,const Char *newLabel))
  1673. PACE_ADD32(formP)
  1674. PACE_ADD16(labelID)
  1675. PACE_ADD32(newLabel)
  1676. PACE_END(sysTrapFrmCopyLabel,NONE,NONE)
  1678. PACE_BEGIN(void FldDrawField (FieldType *fldP))
  1679. PACE_ADD32(fldP)
  1680. PACE_END(sysTrapFldDrawField,NONE,NONE)
  1682. PACE_BEGIN(void FldSetTextPtr (FieldType *fldP, Char *textP))
  1683. PACE_ADD32(fldP)
  1684. PACE_ADD32(textP)
  1685. PACE_END(sysTrapFldSetTextPtr,NONE,NONE)
  1687. PACE_BEGIN(FormType *FrmGetFormPtr(UInt16 formId))
  1688. PACE_ADD16(formId)
  1689. PACE_ENDPTR(sysTrapFrmGetFormPtr,NONE,NONE)
  1691. PACE_BEGIN(FormType* FrmGetActiveForm())
  1692. PACE_ENDPTRVOID(sysTrapFrmGetActiveForm,NONE,NONE)
  1694. PACE_BEGINEVENT(Boolean FrmHandleEvent(FormType *formP, EventType *eventP))
  1695. PACE_ADD32(formP)
  1696. PACE_ADD32(&ev)
  1697. PACE_END8(sysTrapFrmHandleEvent,Event_ARM_To_M68K(eventP,ev),NONE)
  1699. PACE_BEGIN(void FrmHideObject(FormType *formP, UInt16 objIndex))
  1700. PACE_ADD32(formP)
  1701. PACE_ADD16(objIndex)
  1702. PACE_END(sysTrapFrmHideObject,NONE,NONE)
  1704. PACE_BEGIN(void FrmShowObject (FormType *formP, UInt16 objIndex))
  1705. PACE_ADD32(formP)
  1706. PACE_ADD16(objIndex)
  1707. PACE_END(sysTrapFrmShowObject,NONE,NONE)
  1709. PACE_BEGINEVENT(static Boolean _FrmDispatchEvent(EventType *eventP))
  1710. PACE_ADD32(&ev)
  1711. PACE_END8(sysTrapFrmDispatchEvent,Event_ARM_To_M68K(eventP,ev),NONE)
  1713. PACE_BEGIN(static void _FrmSetGadgetHandler(FormType *formP, UInt16 objIndex,FormGadgetHandlerType *attrP))
  1714. PACE_ADD32(formP)
  1715. PACE_ADD16(objIndex)
  1716. PACE_ADD32(attrP)
  1717. PACE_END(sysTrapFrmSetGadgetHandler,NONE,NONE)
  1719. PACE_BEGIN(static void _FrmSetEventHandler(FormType *formP,FormEventHandlerType *handler))
  1720. PACE_ADD32(formP)
  1721. PACE_ADD32(handler)
  1722. PACE_END(sysTrapFrmSetEventHandler,NONE,NONE)
  1724. PACE_BEGIN(static void _FrmDeleteForm(FormType *formP))
  1725. PACE_ADD32(formP)
  1726. PACE_END(sysTrapFrmDeleteForm,NONE,NONE)
  1728. PACE_BEGIN(static void _FrmReturnToForm(UInt16 formId))
  1729. PACE_ADD16(formId)
  1730. PACE_END(sysTrapFrmReturnToForm,NONE,NONE)
  1732. PACE_BEGIN(Err EvtEnqueueKey(WChar ascii, UInt16 keycode, UInt16 modifiers))
  1733. PACE_ADD16(ascii)
  1734. PACE_ADD16(keycode)
  1735. PACE_ADD16(modifiers)
  1736. PACE_END16(sysTrapEvtEnqueueKey,NONE,NONE)
  1738. PACE_BEGIN(FontID FntSetFont(FontID font))
  1739. PACE_ADD8(font)
  1740. PACE_END8(sysTrapFntSetFont,NONE,NONE)
  1742. PACE_BEGIN(UInt32 KeyCurrentState())
  1743. PACE_END32VOID(sysTrapKeyCurrentState,NONE,NONE)
  1745. PACE_BEGIN(UInt32 TimGetSeconds(void))
  1746. PACE_END32VOID(sysTrapTimGetSeconds,NONE,NONE)
  1748. PACE_BEGIN(void TimSecondsToDateTime(UInt32 seconds, DateTimeType *dateTimeP))
  1749. PACE_ADD32(seconds)
  1750. PACE_ADD32(dateTimeP)
  1751. PACE_END(sysTrapTimSecondsToDateTime,NONE,SwapStruct(dateTimeP,2,2,2,2,2,2,2,0))
  1753. /*PACE_BEGIN(Err KeyRates(Boolean set, UInt16 *initDelayP, UInt16 *periodP, 
  1754. UInt16 *doubleTapDelayP, Boolean *queueAheadP))
  1755. PACE_ADD8(set)
  1756. PACE_ADD32(initDelayP)
  1757. PACE_ADD32(periodP)
  1758. PACE_ADD32(doubleTapDelayP)
  1759. PACE_ADD32(queueAheadP)
  1760. PACE_END16(sysTrapKeyRates,PACE_DATA16(initDelayP) PACE_DATA16(periodP) PACE_DATA16(doubleTapDelayP),
  1761.    PACE_DATA16(initDelayP) PACE_DATA16(periodP) PACE_DATA16(doubleTapDelayP))
  1762. */
  1764. PACE_BEGIN(Err SysLibOpen(UInt16 refNum))
  1765. PACE_ADD16(refNum)
  1766. PACE_END16(sysLibTrapOpen,NONE,NONE)
  1768. PACE_BEGIN(Err SysLibClose(UInt16 refNum))
  1769. PACE_ADD16(refNum)
  1770. PACE_END16(sysLibTrapClose,NONE,NONE)
  1772. PACE_BEGIN(UInt32 RotationMgrGetLibAPIVersion(UInt16 refNum))
  1773. PACE_ADD16(refNum)
  1774. PACE_END32((sysLibTrapCustom+0),NONE,NONE)
  1776. PACE_BEGIN(Err RotationMgrAttributeGet(UInt16 refNum, UInt32 attribute, UInt32 *valueP))
  1777. PACE_ADD16(refNum)
  1778. PACE_ADD32(attribute)
  1779. PACE_ADD32(valueP)
  1780. PACE_END16((sysLibTrapCustom+5),NONE,PACE_DATA32(valueP));
  1782. PACE_BEGIN(UInt16 SysBatteryInfo(Boolean set, UInt16 *warnThresholdP, UInt16 *criticalThresholdP,
  1783. Int16 *maxTicksP, SysBatteryKind* kindP, Boolean *pluggedIn, UInt8 *percentP))
  1784. PACE_ADD8(set)
  1785. PACE_ADD32(warnThresholdP)
  1786. PACE_ADD32(criticalThresholdP)
  1787. PACE_ADD32(maxTicksP)
  1788. PACE_ADD32(kindP)
  1789. PACE_ADD32(pluggedIn)
  1790. PACE_ADD32(percentP)
  1791. PACE_END16(sysTrapSysBatteryInfo,NONE,PACE_CDATA16(warnThresholdP) PACE_CDATA16(criticalThresholdP) PACE_CDATA16(maxTicksP))
  1793. #ifdef HAVE_PALMONE_SDK
  1795. PACE_BEGIN(Err HsNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP, 
  1796.    Int16* extraInfoP, RectangleType* boundsInsideRingP,
  1797.    HsNavFocusRingStyleEnum* ringStyleP))
  1798. PACE_ADD16(hsSelNavGetFocusRingInfo)
  1799. PACE_ADD32(formP)
  1800. PACE_ADD32(objectIDP)
  1801. PACE_ADD32(extraInfoP)
  1802. PACE_ADD32(boundsInsideRingP)
  1803. PACE_ADD32(ringStyleP)
  1804. PACE_END16(sysTrapOEMDispatch, NONE, PACE_CDATA16(objectIDP) PACE_CDATA16(extraInfoP) PACE_CDATA16(ringStyleP) SwapStruct(boundsInsideRingP,2,2,2,2,0))
  1806. PACE_BEGINEX(Err HsNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
  1807.     RectangleType* boundsInsideRingP,
  1808. HsNavFocusRingStyleEnum ringStyle, Boolean forceRestore),r)
  1809. PACE_ADD16(boundsInsideRingP->topLeft.x)
  1810. PACE_ADD16(boundsInsideRingP->topLeft.y)
  1811. PACE_ADD16(boundsInsideRingP->extent.x)
  1812. PACE_ADD16(boundsInsideRingP->extent.y)
  1813. PACE_VAR(PACE_PARAM)
  1814. PACE_ADD16(hsSelNavDrawFocusRing)
  1815. PACE_ADD16(objectID)
  1816. PACE_ADD16(extraInfo)
  1817. PACE_ADD32(r)
  1818. PACE_ADD16(ringStyle)
  1819. PACE_ADD8(forceRestore)
  1820. PACE_END16(sysTrapOEMDispatch,NONE,NONE)
  1822. PACE_BEGIN(Err HsNavRemoveFocusRing (FormType* formP))
  1823. PACE_ADD16(hsSelNavRemoveFocusRing)
  1824. PACE_ADD32(formP)
  1825. PACE_END16(sysTrapOEMDispatch,NONE,NONE)
  1827. PACE_BEGIN(void HsNavObjectTakeFocus (const FormType* formP, UInt16 objID))
  1828. PACE_ADD16(hsSelNavObjectTakeFocus)
  1829. PACE_ADD32(formP)
  1830. PACE_ADD16(objID)
  1831. PACE_END(sysTrapOEMDispatch,NONE,NONE)
  1833. PACE_BEGIN(Err HsLightCircumstance(Boolean add, UInt16 circumstance))
  1834. PACE_ADD16(hsSelLightCircumstance)
  1835. PACE_ADD8(add)
  1836. PACE_ADD16(circumstance)
  1837. PACE_END16(sysTrapOEMDispatch, NONE, NONE)
  1839. PACE_BEGIN(UInt16 HsCurrentLightCircumstance())
  1840. PACE_ADD16(hsGetCurrentLightCircumstance)
  1841. PACE_END16(sysTrapOEMDispatch, NONE, NONE)
  1843. PACE_BEGIN(Err HsAttrGet(UInt16 attr, UInt32 param, UInt32* valueP))
  1844. PACE_ADD16(hsSelAttrGet)
  1845. PACE_ADD16(attr)
  1846. PACE_ADD32(param)
  1847. PACE_ADD32(valueP)
  1848. PACE_END16(sysTrapOEMDispatch, NONE, PACE_DATA32(valueP))
  1850. PACE_BEGIN(Err HsAttrSet(UInt16 attr, UInt32 param, UInt32* valueP))
  1851. PACE_ADD16(hsSelAttrSet)
  1852. PACE_ADD16(attr)
  1853. PACE_ADD32(param)
  1854. PACE_ADD32(valueP)
  1855. PACE_END16(sysTrapOEMDispatch, PACE_DATA32(valueP), PACE_DATA32(valueP))
  1857. PACE_BEGIN(Err HWUBlinkLED(UInt16 refnum, Boolean b))
  1858. PACE_ADD16(refnum)
  1859. PACE_ADD8(b)
  1860. PACE_END16((sysLibTrapCustom+0),NONE,NONE)
  1862. PACE_BEGIN(Err HWUSetBlinkRate(UInt16 refnum, UInt16 rate))
  1863. PACE_ADD16(refnum)
  1864. PACE_ADD16(rate)
  1865. PACE_END16((sysLibTrapCustom+1),NONE,NONE)
  1867. PACE_BEGIN(Err HWUEnableDisplay(UInt16 refnum, Boolean on))
  1868. PACE_ADD16(refnum)
  1869. PACE_ADD8(on)
  1870. PACE_END16((sysLibTrapCustom+2),NONE,NONE)
  1872. PACE_BEGIN(Boolean HWUGetDisplayState(UInt16 refnum))
  1873. PACE_ADD16(refnum)
  1874. PACE_END8((sysLibTrapCustom+3),NONE,NONE)
  1876. PACE_BEGIN(void *DexGetDisplayAddress(UInt16 refnum))
  1877. PACE_ADD16(refnum)
  1878. PACE_ENDPTR((sysLibTrapCustom+4),NONE,NONE)
  1880. PACE_BEGIN(void DexGetDisplayDimensions(UInt16 refnum, Coord *width, Coord *height, UInt16 *rowBytes))
  1881. PACE_ADD16(refnum)
  1882. PACE_ADD32(width)
  1883. PACE_ADD32(height)
  1884. PACE_ADD32(rowBytes)
  1885. PACE_END((sysLibTrapCustom+5),NONE,PACE_CDATA16(width) PACE_CDATA16(height) PACE_CDATA16(rowBytes))
  1887. #endif
  1889. #ifdef HAVE_SONY_SDK
  1891. PACE_BEGIN(UInt32 VskGetAPIVersion(UInt16 refNum))
  1892. PACE_ADD16(refNum)
  1893. PACE_END32((sysLibTrapCustom+3),NONE,NONE)
  1895. PACE_BEGIN(Err VskSetState(UInt16 refNum, UInt16 stateType, UInt16 state))
  1896. PACE_ADD16(refNum)
  1897. PACE_ADD16(stateType)
  1898. PACE_ADD16(state)
  1899. PACE_END16((sysLibTrapCustom+6),NONE,NONE)
  1901. PACE_BEGIN(Err VskGetState(UInt16 refNum, UInt16 stateType, UInt16 *stateP))
  1902. PACE_ADD16(refNum)
  1903. PACE_ADD16(stateType)
  1904. PACE_ADD32(stateP)
  1905. PACE_END16((sysLibTrapCustom+7),NONE,PACE_DATA16(stateP))
  1907. #endif
  1909. PACE_BEGIN(Err SysLibLoad(UInt32 libType, UInt32 libCreator, UInt16 *refNumP))
  1910. PACE_ADD32(libType)
  1911. PACE_ADD32(libCreator)
  1912. PACE_ADD32(refNumP)
  1913. PACE_END16(sysTrapSysLibLoad,NONE,PACE_DATA16(refNumP))
  1915. PACE_BEGIN(Err SysLibFind(const Char *nameP, UInt16 *refNumP))
  1916. PACE_ADD32(nameP)
  1917. PACE_ADD32(refNumP)
  1918. PACE_END16(sysTrapSysLibFind,NONE,PACE_DATA16(refNumP))
  1920. NOINLINE MemPtr MemGluePtrNew(UInt32 Size)
  1921. {
  1922. MemPtr p = MemPtrNew(Size);
  1923. if (!p)
  1924. { 
  1925. SysAppInfoPtr appInfoP;
  1926. UInt16 OwnerID = SysGetAppInfo(&appInfoP,&appInfoP)->memOwnerID;
  1927. p = MemChunkNew(0, Size,(UInt16)(OwnerID | memNewChunkFlagNonMovable | memNewChunkFlagAllowLarge));
  1928. }
  1929. return p;
  1930. }
  1932. NOINLINE FormEventHandlerType* FrmGetEventHandler(FormType *Form)
  1933. {
  1934. eventhandler *i,*j;
  1935. for (i=EventHandler,j=NULL;i;j=i,i=i->Next)
  1936. if (i->Form == Form)
  1937. {
  1938. if (j)
  1939. {
  1940. // move ahead for faster search next time
  1941. j->Next = i->Next;
  1942. i->Next = EventHandler;
  1943. EventHandler = i;
  1944. }
  1945. return i->Handler;
  1946. }
  1948. return NULL;
  1949. }
  1951. Boolean FrmDispatchEvent(EventType *eventP)
  1952. {
  1953. // avoid using m68k wrapper for some common events (which are sent to the active form)
  1955. if (eventP->eType == keyHoldEvent || eventP->eType == keyDownEvent || 
  1956. eventP->eType == keyUpEvent || eventP->eType == nilEvent ||
  1957. eventP->eType == penDownEvent || eventP->eType == penMoveEvent ||
  1958. eventP->eType == penUpEvent)
  1959. {
  1960. FormType *Form = FrmGetActiveForm();
  1961. FormEventHandlerType* Handler = FrmGetEventHandler(Form);
  1962. if (Handler)
  1963. {
  1964. // call ARM event handler
  1965. if (Handler(eventP))
  1966. return 1;
  1967. // call system event handler
  1968. return FrmHandleEvent(Form,eventP);
  1969. }
  1970. }
  1972. return _FrmDispatchEvent(eventP);
  1973. }
  1975. static void SetCodePtr(uint8_t* p,void* Ptr)
  1976. {
  1977. p[0] = (uint8_t)(((uint32_t)Ptr) >> 24);
  1978. p[1] = (uint8_t)(((uint32_t)Ptr) >> 16);
  1979. p[2] = (uint8_t)(((uint32_t)Ptr) >> 8);
  1980. p[3] = (uint8_t)(((uint32_t)Ptr) >> 0);
  1981. }
  1983. static void RemoveHandler(FormType *Form)
  1984. {
  1985. eventhandler* i;
  1986. for (i=EventHandler;i;i=i->Next)
  1987. if (i->Form == Form)
  1988. i->Form = NULL;
  1989. }
  1991. void FrmDeleteForm( FormType *formP )
  1992. {
  1993. _FrmDeleteForm(formP);
  1994. RemoveHandler(formP);
  1995. }
  1997. void FrmReturnToForm( UInt16 formId )
  1998. {
  1999. FormType* Form = FrmGetActiveForm();
  2000. _FrmReturnToForm(formId);
  2001. RemoveHandler(Form);
  2002. }
  2004. void* m68kCallBack(m68kcallback p,NativeFuncType* Func)
  2005. {
  2006. static const uint8_t Code[24] = 
  2007. { 0x4E,0x56,0x00,0x00, // link a6,#0
  2008.   0x48,0x6E,0x00,0x08,     // pea     8(a6)
  2009.   0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l  #$ARM,-(sp)
  2010.   0x4E,0x4F, // trap    #$F
  2011.   0xA4,0x5A, // dc.w    $A45A
  2012.   0x70,0x00, // moveq   #0,d0
  2013.   0x4E,0x5E, // unlk    a6
  2014.   0x4E,0x75 }; // rts
  2016. memcpy(p,Code,sizeof(m68kcallback));
  2017. SetCodePtr((uint8_t*)p+10,(void*)(uint32_t)Func);
  2018. return p;
  2019. }
  2021. void FrmSetGadgetHandler(FormType *formP, UInt16 objIndex,FormGadgetHandlerType *attrP)
  2022. {
  2023. gadgethandler* i;
  2024. gadgethandler* Free = NULL;
  2025. for (i=GadgetHandler;i;i=i->Next)
  2026. {
  2027. if (i->Form == formP && i->Index == objIndex)
  2028. break;
  2029. if (!i->Form)
  2030. Free = i;
  2031. }
  2032. if (!i)
  2033. {
  2034. if (Free)
  2035. i = Free;
  2036. else
  2037. {
  2038. i = MemGluePtrNew(sizeof(gadgethandler));
  2039. i->Next = GadgetHandler;
  2040. GadgetHandler = i;
  2041. }
  2042. }
  2044. if (i)
  2045. {
  2046. static const uint8_t Code[68] = 
  2047. { 0x4E,0x56,0x00,0x00, // link a6,#0
  2048.   0x30,0x2E,0x00,0x0C, // move.w  $C(a6),d0
  2049.   0x22,0x2E,0x00,0x0E, // move.l  $E(a6),d1
  2050.   0x23,0xEE,0x00,0x08,0x00,0x00,0x00,0x00,  // move.l  8(a6),($Gadget).l
  2051.   0x33,0xC0,0x00,0x00,0x00,0x00, // move.w  d0,($Cmd).l
  2052.   0x23,0xC1,0x00,0x00,0x00,0x00, // move.l  d1,($Event).l
  2053.   0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l  #This,-(sp)
  2054.   0x2F,0x39,0x00,0x00,0x00,0x00, // move.l  (Wrapper).l,-(sp)
  2055.   0x2F,0x39,0x00,0x00,0x00,0x00, // move.l  (Module).l,-(sp)
  2056.   0x20,0x79,0x00,0x00,0x00,0x00, // movea.l (PealCall).l,a0
  2057.   0x4E,0x90, // jsr     (a0)
  2058.   0x02,0x80,0x00,0x00,0x00,0xFF, // andi.l  #$FF,d0
  2059.   0x4E,0x5E, // unlk    a6
  2060.   0x4E,0x75 }; // rts
  2062. #if defined(_M_IX86)
  2063. const tchar_t* Name = T("tcpmp.dllWrapperGadgetHandler86");
  2064. i->Wrapper = SWAP32(Name);
  2065. #else
  2066. i->Wrapper = SWAP32(WrapperGadgetHandler);
  2067. #endif
  2068. i->Form = formP;
  2069. i->Index = objIndex;
  2070. i->Handler = attrP;
  2071. i->Module = Peal.Module;
  2072. i->PealCall = Peal.PealCall;
  2074. memcpy(i->Code,Code,sizeof(Code));
  2075. SetCodePtr(i->Code+16,&i->Gadget);
  2076. SetCodePtr(i->Code+22,&i->Cmd);
  2077. SetCodePtr(i->Code+28,&i->Event);
  2078. SetCodePtr(i->Code+34,i);
  2079. SetCodePtr(i->Code+40,&i->Wrapper);
  2080. SetCodePtr(i->Code+46,&i->Module);
  2081. SetCodePtr(i->Code+52,&i->PealCall);
  2083. _FrmSetGadgetHandler(formP,objIndex,(FormGadgetHandlerType*)i->Code);
  2084. }
  2085. }
  2087. void FrmSetEventHandler(FormType *formP,FormEventHandlerType *handler)
  2088. {
  2089. eventhandler* i;
  2090. eventhandler* Free = NULL;
  2091. for (i=EventHandler;i;i=i->Next)
  2092. {
  2093. if (i->Form == formP)
  2094. break;
  2095. if (!i->Form)
  2096. Free = i;
  2097. }
  2098. if (!i)
  2099. {
  2100. if (Free)
  2101. i = Free;
  2102. else
  2103. {
  2104. i = MemGluePtrNew(sizeof(eventhandler));
  2105. i->Next = EventHandler;
  2106. EventHandler = i;
  2107. }
  2108. }
  2110. if (i)
  2111. {
  2112. static const uint8_t Code[48] = 
  2113. { 0x4E,0x56,0x00,0x00, // link a6,#0
  2114.   0x23,0xEE,0x00,0x08,0x00,0x00,0x00,0x00, // move.l  arg_0(a6),(Event).l
  2115.   0x2F,0x3C,0x00,0x00,0x00,0x00, // move.l  #This,-(sp)
  2116.   0x2F,0x39,0x00,0x00,0x00,0x00, // move.l  (Wrapper).l,-(sp)
  2117.   0x2F,0x39,0x00,0x00,0x00,0x00, // move.l  (Module).l,-(sp)
  2118.   0x20,0x79,0x00,0x00,0x00,0x00, // movea.l (PealCall).l,a0
  2119.   0x4E,0x90, // jsr     (a0)
  2120.   0x4E,0x5E, // unlk    a6
  2121.   0x02,0x80,0x00,0x00,0x00,0xFF, // andi.l  #$FF,d0
  2122.   0x4E,0x75 }; // rts
  2124. #if defined(_M_IX86)
  2125. const tchar_t* Name = T("tcpmp.dllWrapperEventHandler86");
  2126. i->Wrapper = SWAP32(Name);
  2127. #else
  2128. i->Wrapper = SWAP32(WrapperEventHandler);
  2129. #endif
  2130. i->Form = formP;
  2131. i->Handler = handler;
  2132. i->Module = Peal.Module;
  2133. i->PealCall = Peal.PealCall;
  2134. i->Event = NULL;
  2136. memcpy(i->Code,Code,sizeof(Code));
  2137. SetCodePtr(i->Code+8,&i->Event);
  2138. SetCodePtr(i->Code+14,i);
  2139. SetCodePtr(i->Code+20,&i->Wrapper);
  2140. SetCodePtr(i->Code+26,&i->Module);
  2141. SetCodePtr(i->Code+32,&i->PealCall);
  2143. _FrmSetEventHandler(formP,(FormEventHandlerType*)i->Code);
  2144. }
  2145. }
  2147. void* PealLoadModule(uint16_t FtrId,Boolean Mem,Boolean OnlyFtr,Boolean MemSema)
  2148. {
  2149. uint16_t Param[4] = {SWAP16(FtrId),(uint8_t)Mem,(uint8_t)OnlyFtr,(uint8_t)MemSema};
  2150. return (void*)Call68K(SWAP32(Peal.LoadModule),&Param,sizeof(Param)|kPceNativeWantA0);
  2151. }
  2153. PACE_BEGIN(void* PealGetSymbol(void* Module,const tchar_t* Name))
  2154. PACE_ADD32(Module)
  2155. PACE_ADD32(Name)
  2156. }; return (void*)Call68K(SWAP32(Peal.GetSymbol),PACE_PARAM,sizeof(PACE_PARAM)|kPceNativeWantA0);
  2157. }
  2159. PACE_BEGIN(void PealFreeModule(void* Module))
  2160. PACE_ADD32(Module)
  2161. }; Call68K(SWAP32(Peal.FreeModule),PACE_PARAM,sizeof(PACE_PARAM));
  2162. }
  2164. Err FrmGlueNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP, 
  2165.     Int16* extraInfoP, RectangleType* boundsInsideRingP,
  2166.     FrmNavFocusRingStyleEnum* ringStyleP)
  2167. {
  2168. UInt32 ver;
  2169. if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
  2170. return FrmNavGetFocusRingInfo(formP,objectIDP,extraInfoP,boundsInsideRingP,ringStyleP);
  2171. #ifdef HAVE_PALMONE_SDK
  2172. else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
  2173. return HsNavGetFocusRingInfo(formP,objectIDP,extraInfoP,boundsInsideRingP,ringStyleP);
  2174. #endif
  2175. return uilibErrObjectFocusModeOff;
  2176. }
  2178. Err FrmGlueNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
  2179.     RectangleType* boundsInsideRingP,
  2180.     FrmNavFocusRingStyleEnum ringStyle, Boolean forceRestore)
  2181. {
  2182. UInt32 ver;
  2183. if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
  2184. return FrmNavDrawFocusRing(formP,objectID,extraInfo,boundsInsideRingP,ringStyle,forceRestore);
  2185. #ifdef HAVE_PALMONE_SDK
  2186. else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
  2187. return HsNavDrawFocusRing(formP,objectID,extraInfo,boundsInsideRingP,ringStyle,forceRestore);
  2188. #endif
  2189. return uilibErrObjectFocusModeOff;
  2190. }
  2192. Err FrmGlueNavRemoveFocusRing (FormType* formP)
  2193. {
  2194. UInt32 ver;
  2195. if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
  2196. return FrmNavRemoveFocusRing(formP);
  2197. #ifdef HAVE_PALMONE_SDK
  2198. else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
  2199. return HsNavRemoveFocusRing(formP);
  2200. #endif
  2201. return uilibErrObjectFocusModeOff;
  2202. }
  2204. void FrmGlueNavObjectTakeFocus(FormType* formP, UInt16 objID)
  2205. {
  2206. UInt32 ver;
  2207. if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
  2208. FrmNavObjectTakeFocus(formP,objID);
  2209. #ifdef HAVE_PALMONE_SDK
  2210. else if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
  2211. HsNavObjectTakeFocus(formP,objID);
  2212. #endif
  2213. }
  2215. Boolean FrmGlueNavIsSupported(void)
  2216. {
  2217. UInt32 ver;
  2218. if (FtrGet(sysFileCSystem, sysFtrNumFiveWayNavVersion, &ver)==errNone)
  2219. return 1;
  2220. #ifdef HAVE_PALMONE_SDK
  2221. if (FtrGet(hsFtrCreator,hsFtrIDNavigationSupported,&ver)==errNone)
  2222. return 1;
  2223. #endif
  2224. return 0;
  2225. }
  2227. PACE_BEGIN(Err FrmNavGetFocusRingInfo(const FormType* formP, UInt16* objectIDP, 
  2228.    Int16* extraInfoP, RectangleType* boundsInsideRingP,
  2229.    FrmNavFocusRingStyleEnum* ringStyleP))
  2230. PACE_ADD16(NavSelectorFrmNavGetFocusRingInfo)
  2231. PACE_ADD32(formP)
  2232. PACE_ADD32(objectIDP)
  2233. PACE_ADD32(extraInfoP)
  2234. PACE_ADD32(boundsInsideRingP)
  2235. PACE_ADD32(ringStyleP)
  2236. PACE_END16(sysTrapNavSelector, NONE, PACE_CDATA16(objectIDP) PACE_CDATA16(extraInfoP) PACE_CDATA16(ringStyleP) SwapStruct(boundsInsideRingP,2,2,2,2,0))
  2238. PACE_BEGINEX(Err FrmNavDrawFocusRing(FormType* formP, UInt16 objectID, Int16 extraInfo,
  2239.     RectangleType* boundsInsideRingP,
  2240. FrmNavFocusRingStyleEnum ringStyle, Boolean forceRestore),r)
  2241. PACE_ADD16(boundsInsideRingP->topLeft.x)
  2242. PACE_ADD16(boundsInsideRingP->topLeft.y)
  2243. PACE_ADD16(boundsInsideRingP->extent.x)
  2244. PACE_ADD16(boundsInsideRingP->extent.y)
  2245. PACE_VAR(PACE_PARAM)
  2246. PACE_ADD16(NavSelectorFrmNavDrawFocusRing)
  2247. PACE_ADD16(objectID)
  2248. PACE_ADD16(extraInfo)
  2249. PACE_ADD32(r)
  2250. PACE_ADD16(ringStyle)
  2251. PACE_ADD8(forceRestore)
  2252. PACE_END16(sysTrapNavSelector,NONE,NONE)
  2254. PACE_BEGIN(Err FrmNavRemoveFocusRing (FormType* formP))
  2255. PACE_ADD16(NavSelectorFrmNavRemoveFocusRing)
  2256. PACE_ADD32(formP)
  2257. PACE_END16(sysTrapNavSelector,NONE,NONE)
  2259. PACE_BEGIN(void FrmNavObjectTakeFocus (const FormType* formP, UInt16 objID))
  2260. PACE_ADD16(NavSelectorFrmNavObjectTakeFocus)
  2261. PACE_ADD32(formP)
  2262. PACE_ADD16(objID)
  2263. PACE_END(sysTrapNavSelector,NONE,NONE)
  2265. #endif