home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / Epoc / Palmtime / files / FrotzS5_src.ZIP / S5api.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-11  |  12.4 KB  |  547 lines
  1. // S5api.cpp
  2. #if !defined(__E32BASE_H__)
  3. #include <e32base.h>
  4. #endif
  5. #include <eikdoc.h>
  6. #include <eikon.rsg>
  7. #include "frotz.h"
  8. #include "frotzs5.h"
  9. #include "s5api.h"
  10. #include "s5inter.h"
  11. //**********************************
  12. //RMainServ
  13. //**********************************
  14. // The client class. An RSessionBase sends messages to the server with the function
  15. // RSessionBase::SendReceive(); specifying an opcode (TMainServRqst) and and array of argument pointers.
  16. // Functions in derived classes, such as RMainServ::Increase(), are wrappers for different calls to
  17. // SendReceive().
  18. // Most of the functions here return void because if they fail the server will panic the client.
  19. // If they return it can be assumed that there is no error.
  20. class MyDesC8 : TDesC8
  21.   {
  22.   public:
  23.     MyDesC8(unsigned char *p, int len):TDesC8(p, len, len){}
  24.   };
  25.  
  26.  
  27. //**********************************
  28. //RMainServ
  29. //**********************************
  30.  
  31. RMainServ::RMainServ()
  32.     {
  33.     }
  34.  
  35.  
  36. const TUint kDefaultMessageSlots=4;
  37.  
  38. CFrotzAppUi *RMainServ::GetApp()
  39. {
  40.   TAny *p[KMaxMessageArguments];
  41.   p[0] = (TAny*)NULL;
  42.   TInt app = SendReceive(EMainServGetApp, &p[0]);
  43.   return ((CFrotzAppUi *)app);
  44. }
  45. // Connect to the  server - default number of message slots = 4
  46. TInt RMainServ::Connect(struct sg *g)
  47.     {
  48.     TTime home;
  49.     TInt r;
  50.     g->aFs = new RFs;
  51.     ((RFs *)g->aFs)->Connect();
  52.     r=CreateSession(MAIN_SERVER_NAME,Version(),kDefaultMessageSlots);
  53.     g->papp = GetApp();
  54.     ((CFrotzAppUi *)(g->papp))->storyrunning = 1;
  55.     home.HomeTime();
  56.     g->seed = home.DateTime().MicroSecond();
  57.     return(r);
  58.     }
  59.  
  60. // Return the client side version number.
  61. TVersion RMainServ::Version(void) const
  62.     {
  63.     return(TVersion(KMainServMajorVersionNumber,KMainServMinorVersionNumber,KMainServBuildVersionNumber));
  64.     }
  65.  
  66. void RMainServ::Printf(struct sg *g, const char *msg)
  67.   {
  68.   TAny *p[KMaxMessageArguments];
  69.   p[0] = (TAny*)msg;
  70.   SendReceive(EMainServPrintf, &p[0]);
  71.   }
  72.  
  73. unsigned short RMainServ::GetCh(struct sg *g)
  74.   {
  75.   return (unsigned short)SendReceive(EMainServGetCh, NULL);
  76.   }
  77.  
  78. void RMainServ::KeyTimer(struct sg *g, int delay)
  79.   {
  80.   TAny *p[KMaxMessageArguments];
  81.   p[0] = (TAny*)&delay;
  82.   SendReceive(EMainServKeyTimer, &p[0]);
  83.   }
  84.  
  85. void RMainServ::Exit(struct sg *g)
  86. {
  87.     SendReceive(EMainServTerminate, NULL);
  88.     Close();
  89.     ((RThread *)(g->thisthread))->Terminate(0);
  90. }
  91.  
  92. void RMainServ::EraseRect(struct sg *g, int top, int left, int bottom, int right, int rev)
  93. {
  94.   TRect r(left-1,top-1,right,bottom);
  95.   TAny *p[KMaxMessageArguments];
  96.   p[0] = (TAny*)&r;
  97.   p[1] = (TAny*)&rev;
  98.   SendReceive(EMainServEraseRect, &p[0]);
  99. }
  100.  
  101. void RMainServ::Scroll(struct sg *g, int top, int left, int bottom, int right, int units, int rev)
  102. {
  103.   TRect r(left-1,top-1,right,bottom);
  104.   TPoint pt(0, -units);
  105.   TAny *p[KMaxMessageArguments];
  106.   p[0] = (TAny*)&r;
  107.   p[1] = (TAny*)&pt;
  108.   SendReceive(EMainServScroll, &p[0]);
  109.   EraseRect(g,(units > 0 ? bottom+1-units : top) , left, (units > 0 ?  bottom : top+1-units), right, rev);
  110. }
  111.  
  112. void RMainServ::Cursor(struct sg *g, int cursor)
  113. {
  114.   TAny *p[KMaxMessageArguments];
  115.   p[0] = (TAny*)&cursor;
  116.   SendReceive(EMainServCursor, &p[0]);
  117. }
  118.  
  119. void RMainServ::TextAttr(struct sg *g, int attr)
  120. {
  121.   TAny *p[KMaxMessageArguments];
  122.   p[0] = (TAny*)&attr;
  123.   SendReceive(EMainServTextAttr, &p[0]);
  124. }
  125.  
  126. void RMainServ::PutChar(struct sg *g, int x, int y, unsigned char c)
  127. {
  128. int cx,cy;
  129. unsigned char cc;
  130.   cc = c; cx = x; cy = y;
  131.   TAny *p[KMaxMessageArguments];
  132.   p[0] = (TAny*)&cx;
  133.   p[1] = (TAny*)&cy;
  134.   p[2] = (TAny*)&cc;
  135.   SendReceive(EMainServPutChar, &p[0]);
  136. }
  137.  
  138. void RMainServ::PutString(struct sg *g, int x, int y, zchar *s)
  139. {
  140.   int cx = x, cy = y;
  141.   TAny *p[KMaxMessageArguments];
  142.   p[0] = (TAny*)&cx;
  143.   p[1] = (TAny*)&cy;
  144.   p[2] = (TAny*)s;
  145.   SendReceive(EMainServPutString, &p[0]);
  146. }
  147.  
  148. void RMainServ::SetCursor(struct sg *g, int x, int y)
  149. {
  150.   TPoint pt(x,y);
  151.   TAny *p[KMaxMessageArguments];
  152.   p[0] = (TAny*)&pt;
  153.   SendReceive(EMainServSetCursor, &p[0]);
  154. }
  155.  
  156. int  RMainServ::DlgOpen(struct sg *g, char *pathname, char *filename)
  157. {
  158.   TAny *p[KMaxMessageArguments];
  159.   p[0] = (TAny*)pathname;
  160.   p[1] = (TAny*)filename;
  161.   return SendReceive(EMainServDlgOpen, &p[0]);
  162. }
  163.  
  164. int  RMainServ::DlgSave(struct sg *g, char *pathname, char *filename)
  165. {
  166.   TAny *p[KMaxMessageArguments];
  167.   p[0] = (TAny*)pathname;
  168.   p[1] = (TAny*)filename;
  169.   return SendReceive(EMainServDlgSave, &p[0]);
  170. }
  171.  
  172. void  RMainServ::GetStoryName(char *sn)
  173. {
  174.   TAny *p[KMaxMessageArguments];
  175.   p[0] = (TAny*)sn;
  176.   SendReceive(EMainServGetStoryName, &p[0]);
  177. }
  178.  
  179. void SrvConnect(struct sg *g, void *tr)
  180.   {
  181.     g->thisthread = tr;
  182.     User::LeaveIfError(((RMainServ *)(g->ss))->Connect(g));
  183.   }
  184. void SrvDisconnect(struct sg *g)
  185.   {
  186.     ((RFs *)g->aFs)->Close();
  187.     delete ((RFs *)g->aFs);
  188.     ((RMainServ *)(g->ss))->Exit(g);
  189.   }
  190.  
  191. void SrvPrintf(struct sg *g, const char *msg)
  192.     {
  193.     ((RMainServ *)(g->ss))->Printf(g,msg);
  194.     }
  195.  
  196. unsigned short SrvGetTimedCh(struct sg *g, int delay)
  197. {
  198.     if(((CFrotzAppUi *)(g->papp))->keyready)
  199.         return (((RMainServ *)(g->ss))->GetCh(g));
  200.     if(delay == 0)
  201.     {
  202.         ((CFrotzAppUi *)(g->papp))->waitingkey = 1;
  203.         ((CFrotzAppUi *)(g->papp))->SemaKey.Wait();
  204.     } 
  205.     else
  206.     {
  207.         ((RMainServ *)(g->ss))->KeyTimer(g,delay*100000);
  208.         ((CFrotzAppUi *)(g->papp))->waitingkey = 1;
  209.         ((CFrotzAppUi *)(g->papp))->SemaKey.Wait();
  210.     }
  211.     return (((RMainServ *)(g->ss))->GetCh(g));
  212. }
  213.  
  214. void SrvBeep(struct sg *g, int pitch)
  215. {
  216.     pitch = pitch;
  217. }
  218.  
  219. FILE *SrvOpenRead(struct sg *g, const char *filename) 
  220. // uses RFile, returns NULL if error
  221. {
  222.     RFile *rfile;
  223.     rfile = new RFile;
  224.     TInt res = rfile->Open(*((RFs *)g->aFs),_L(filename), 0);
  225.     if(res == KErrNone)
  226.         return (FILE *)rfile;
  227.     return NULL;
  228. }
  229.  
  230. FILE *SrvOpenWrite(struct sg *g, const char *filename) 
  231. // returns NULL if error
  232. {
  233.     RFile *rfile;
  234.     TInt res;
  235.     rfile = new RFile;
  236.     res = rfile->Open(*((RFs *)g->aFs),_L(filename), EFileWrite);
  237.     if(res == KErrNotFound)
  238.       res = rfile->Create(*((RFs *)g->aFs),_L(filename), EFileWrite);
  239.     else
  240.       rfile->SetSize(0);
  241.     if(res == KErrNone)
  242.         return (FILE *)rfile;
  243.     return NULL;
  244. }
  245.  
  246. FILE *SrvOpenRWText(struct sg *g, const char *filename) 
  247. // Read/Write && text mode
  248. {
  249.     TInt res;
  250.     RFile *rfile;
  251.     rfile = new RFile;
  252.     res = rfile->Open(*((RFs *)g->aFs),_L(filename), EFileWrite);
  253.     if(res == KErrNotFound)
  254.       res = rfile->Create(*((RFs *)g->aFs),_L(filename), EFileWrite);
  255.     else
  256.       rfile->SetSize(0);
  257.     if(res == KErrNone)
  258.         return (FILE *)rfile;
  259.     return NULL;
  260. }
  261.  
  262. FILE *SrvOpenWText(struct sg *g, const char *filename) 
  263. // Write && text mode
  264. {
  265.     TInt res;
  266.     RFile *rfile;
  267.     rfile = new RFile;
  268.     res = rfile->Open(*((RFs *)g->aFs),_L(filename), EFileWrite);
  269.     if(res == KErrNotFound)
  270.       res = rfile->Create(*((RFs *)g->aFs),_L(filename), EFileWrite);
  271.     else
  272.       rfile->SetSize(0);
  273.     if(res == KErrNone)
  274.         return (FILE *)rfile;
  275.     return NULL;
  276. }
  277.  
  278. FILE *SrvOpenRText(struct sg *g, const char *filename) 
  279. // Read && text mode
  280. {
  281.     RFile *rfile;
  282.     rfile = new RFile;
  283.     TInt res = rfile->Open(*((RFs *)g->aFs),_L(filename), EFileStreamText);
  284.     if(res == KErrNone)
  285.         return (FILE *)rfile;
  286.     return NULL;
  287. }
  288.  
  289. void SrvClose(struct sg *g, FILE *file)
  290. {
  291.     RFile *rfile = (RFile *)file;
  292.     rfile->Close();
  293.     delete rfile;
  294. }
  295.  
  296. #ifndef SEEK_SET
  297. #define SEEK_SET 0
  298. #define SEEK_CUR 1
  299. #define SEEK_END 2
  300. #endif
  301. void SrvSeek(struct sg *g, FILE *file, int offset, int origin)
  302. {
  303.     int pos = offset;
  304.     RFile *rfile = (RFile *)file;
  305.     if(origin == SEEK_SET)
  306.       rfile->Seek(ESeekStart,pos);
  307.     else
  308.     if(origin == SEEK_CUR)
  309.       rfile->Seek(ESeekCurrent,pos);
  310.     else
  311.       rfile->Seek(ESeekEnd,pos);
  312. }
  313.  
  314. int  SrvTell(struct sg *g, FILE *file)
  315. {
  316.     int pos = 0;
  317.     RFile *rfile = (RFile *)file;
  318.     rfile->Seek(ESeekCurrent,pos);
  319.     return pos;
  320. }
  321.  
  322. int  SrvRead (struct sg *g, void *buff, int width, int count, FILE *file)  
  323. // returns <= 'count' !
  324. {
  325.     TPtr8 p((unsigned char *)buff, width*count);
  326.     int res;
  327.     RFile *rfile = (RFile *)file;
  328.     res = rfile->Read(p, width*count);
  329.     if(res != KErrNone)
  330.       return 0;
  331.     return p.Length();
  332. }
  333.  
  334. int  SrvWrite(struct sg *g, void *buff, int width, int count, FILE *file) 
  335. // returns <= 'count' !
  336. {
  337.     int res;
  338.     TPtrC8 p((const unsigned char *)buff, width*count);
  339.     RFile *rfile = (RFile *)file;
  340.     res = rfile->Write(p, width*count);
  341.     if(res != KErrNone)
  342.       return 0;
  343.     return p.Length();
  344. }
  345.  
  346. int  SrvPutc (struct sg *g, int c, FILE *file) 
  347. // return the char written
  348. {
  349.     int res;
  350.     unsigned char d = (unsigned char)c;
  351.     res = SrvWrite(g,&d, 1, 1, file);
  352.     if(res != 1)
  353.       return 0;
  354.     return c;
  355. }
  356.  
  357. int  SrvGetc(struct sg *g, FILE *file) 
  358. // EOF = returns 0
  359. {
  360.     int res;
  361.     unsigned char c;
  362.     res = SrvRead(g,&c, 1, 1, file);
  363.     if(res != 1)
  364.       return 0;
  365.     return c;
  366. }
  367.  
  368. int  SrvError(struct sg *g, FILE *file) 
  369. // return always 0....
  370. {
  371.     file = file;
  372.     return 0;
  373. }
  374.  
  375. void SrvSetFileSize(struct sg *g, FILE *file, int adjust)
  376. {
  377.     TInt sz;
  378.     RFile *rfile = (RFile *)file;
  379.     rfile->Size(sz);
  380.     rfile->SetSize(sz+adjust);  
  381. }
  382.  
  383. char *Srvstrchr(const char *str, char c)
  384. {
  385.     char *ptr = (char *)str;
  386.     while((*ptr != c) && (*ptr != '\0'))
  387.         ptr++;
  388.     if(c != '\0')
  389.       if(*ptr == '\0')
  390.         return NULL;
  391.     return ptr;
  392. }
  393.  
  394. int  Srvstrlen(char *str)
  395. {
  396.     char *ptr = str;
  397.     int len = 0;
  398.     while((*ptr++) != '\0')
  399.         len++;
  400.     return len;
  401. }
  402.  
  403. void Srvmemcpy(void *dst, void *src, int count)
  404. {
  405.     unsigned char *pdst = (unsigned char *)dst;
  406.     unsigned char *psrc = (unsigned char *)src;
  407.     while(count > 0)
  408.     {
  409.         *pdst++ = *psrc++;
  410.         --count;
  411.     }
  412. }
  413.  
  414. void Srvmemmove (void *dst, void *src, int count)
  415. {
  416.     unsigned char *pdst = (unsigned char *)dst;
  417.     unsigned char *psrc = (unsigned char *)src;
  418.     if(pdst < psrc)
  419.         Srvmemcpy(dst,src,count);
  420.     else
  421.     {
  422.         pdst += count;
  423.         psrc += count;
  424.         while(count > 0)
  425.         {
  426.             *--pdst = *--psrc;
  427.             --count;
  428.         }
  429.     }
  430. }
  431.  
  432. char *Srvstrcpy(char *dst, const char *src) 
  433. // returns dst
  434. {
  435.     char *ptr = (char *)src;
  436.     char *bdst = dst;
  437.  
  438.     while(*ptr != '\0')
  439.         *dst++ = *ptr++;
  440.     *dst = '\0';
  441.     return bdst;
  442. }
  443.  
  444. char *Srvstrcat(char *dst, const char *src) 
  445. // returns dst
  446. {
  447.     char *ptr = Srvstrchr(dst, '\0');
  448.     Srvstrcpy(ptr, src);
  449.     return dst;
  450. }
  451.  
  452.  
  453. void *SrvMalloc(struct sg *g, int num, int size) 
  454. // uses HBufC, alloc size+ptr (pointer to HBufC) TDes->Ptr()
  455. {
  456.     char *ptr;
  457.     g->hbuff[num] = (void *)HBufC::NewL(size);
  458.     ptr = (char *)((HBufC *)g->hbuff[num])->Ptr();
  459.     return (void *)ptr;
  460. }
  461.  
  462. void SrvFree(struct sg *g, int num, void *buff)  
  463. // uses delete
  464. {
  465.     delete ((HBufC *)g->hbuff[num]);
  466. }
  467.  
  468. void *SrvRealloc(struct sg *g, int num, void *buff, int size) 
  469. // warning: ptr may change
  470. {
  471.     char *ptr;
  472.     g->hbuff[num] = (void *)((HBufC *)g->hbuff[num])->ReAllocL(size);
  473.     ptr = (char *)((HBufC *)g->hbuff[num])->Ptr();
  474.     return (void *)buff;
  475. }
  476.  
  477. void SrvExit(struct sg *g)
  478. {
  479.     ((RMainServ *)(g->ss))->Exit(g);
  480. }
  481.  
  482. void SrvEraseRect(struct sg *g, int top, int left, int bottom, int right, int rev)
  483. {
  484.     ((RMainServ *)(g->ss))->EraseRect(g,top, left, bottom, right, rev);
  485. }
  486.  
  487. void SrvScroll(struct sg *g, int top, int left, int bottom, int right, int units, int rev)
  488. {
  489.     ((RMainServ *)(g->ss))->Scroll(g,top, left, bottom, right, units, rev);
  490. }
  491.  
  492. void SrvSwitchCursor(struct sg *g, int cursor)
  493. {
  494.     ((RMainServ *)(g->ss))->Cursor(g,cursor);
  495. }
  496.  
  497. void SrvTextAttr(struct sg *g, int attr)
  498. {
  499.     ((RMainServ *)(g->ss))->TextAttr(g,attr);
  500. }
  501.  
  502. // Return an appropriate random seed value in the range from 0 to
  503. // 32767, possibly by using the current system time.
  504. int SrvRandom(struct sg *g)
  505. {
  506.     Math::Rand(g->seed);
  507.     return (g->seed.Low() & 0x7FFF);
  508. }
  509.  
  510. void SrvPutChar(struct sg *g, int x, int y, unsigned char c)
  511. {
  512.     ((RMainServ *)(g->ss))->PutChar(g,x,y,c);
  513. }
  514.  
  515. void SrvPutString(struct sg *g, int x, int y, zchar *s)
  516. {
  517.     ((RMainServ *)(g->ss))->PutString(g,x,y,s);
  518. }
  519.  
  520. void SrvSetCursor(struct sg *g, int x, int y)
  521. {
  522.     ((RMainServ *)(g->ss))->SetCursor(g,x,y);
  523. }
  524.  
  525. int SrvDlgOpen(struct sg *g, char *pathsrc, char *file)
  526. {
  527.     return ((RMainServ *)(g->ss))->DlgOpen(g,pathsrc, file);
  528. }
  529.  
  530. int SrvDlgSave(struct sg *g, char *pathsrc, char *file)
  531. {
  532.     return ((RMainServ *)(g->ss))->DlgSave(g,pathsrc, file);
  533. }
  534.  
  535. void SrvGetStoryName(struct sg *g, char **sn)
  536. {
  537.     ((RMainServ *)(g->ss))->GetStoryName(g->thestoryname);
  538.     *sn = g->thestoryname;
  539. }
  540.  
  541. void SrvScreenSize(struct sg *g, int *w, int *h)
  542. {
  543.   *w = ((CFrotzAppUi *)(g->papp))->cscreenwidth;
  544.   *h = ((CFrotzAppUi *)(g->papp))->cscreenheight;
  545. }
  546.  
  547.