home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / pocketbk / utilsf / lpc091s / LPCON.C < prev    next >
C/C++ Source or Header  |  1994-04-24  |  27KB  |  1,066 lines
  1. /* LPCON.C
  2.  
  3.   Copyright (C) Psion PLC 1994
  4.   Started by : DavidW
  5.   Started on:  1/1/94
  6. */
  7.  
  8. #include <p_std.h>
  9. #include <p_gen.h>
  10. #include <p_file.h>
  11. #include <epoc.h>
  12. #include <ats.h>
  13. #include <wskeys.h>
  14. #include <wlib.h>
  15. #include <lpc.g>
  16. #include <gate.g>
  17. #include <hwimman.g>
  18. #include <ipc.g>
  19. #include "lpcdat.h"
  20.  
  21. #ifndef W_KEY_DIAMOND
  22. #define W_KEY_DIAMOND 0x124
  23. #endif
  24.  
  25. GLREF_D PR_GATE *DatGate;
  26. GLREF_D VOID *DatCommandPtr;
  27. GLREF_D VOID *DatUsedPathNamePtr;
  28. GLREF_D VOID *DatStatusNamePtr;
  29. GLREF_D VOID *DatProcessNamePtr;
  30. GLREF_D VOID *DatCommandPtr;
  31. GLREF_D UWORD DatLocked;
  32. GLREF_D PR_APPMAN *w_am;
  33. GLREF_D PR_WSERV *w_ws;
  34. GLREF_D PR_DLGCHAIN *DatDialogPtr;
  35.  
  36. GLREF_C VOID WservName(VOID);
  37. GLREF_C VOID OplComline(VOID);
  38. GLREF_C VOID Sys$prgoName(VOID);
  39.  
  40. LOCAL_C VOID SignalCompletion(PR_LPCON *self,WORD completion)
  41.     {
  42.     *self->lpcon.pMstat=completion;
  43.     p_iosignal();           /* force completion */
  44.     }
  45.  
  46. LOCAL_C INT SendMessage(PR_LPCON *self,INT type,ATS_MESS_BODY *pu)
  47. /*
  48. Can be called within WaitHandler so never leaves in that case
  49. */
  50.     {
  51.     INT ret;
  52.  
  53.     if (type==TY_ATS_RECORD)
  54.         return(p_msendreceivew(self->lpcon.pid,type,pu));
  55.     ret=p_msendreceivea(self->lpcon.pid,type,pu,self->lpcon.pMstat);
  56.     if (ret)
  57.         SignalCompletion(self,ret);     /* simulate completion */
  58.     if (self->lpcon.pUstat || self->lpcon.pstr)
  59.         return(0);
  60.     p_waitstat(self->lpcon.pMstat);
  61.     return(self->lpcon.mstat);
  62.     }
  63.  
  64. LOCAL_C VOID ResetPMstat(PR_LPCON *self)
  65. /*
  66. Reset to use user's stat, if specified, or else internal one
  67. */
  68.     {
  69.     self->lpcon.pMstat=
  70.             (self->lpcon.pUstat? self->lpcon.pUstat: &self->lpcon.mstat);
  71.     }
  72.  
  73. LOCAL_C VOID CancelStringState(PR_LPCON *self)
  74.     {
  75.     self->lpcon.pstr=NULL;
  76.     ResetPMstat(self);
  77.     }
  78.  
  79. LOCAL_C INT CurrentDriveLetter(VOID)
  80.     {
  81.     INT i;
  82.  
  83.     i=(*(((UBYTE *)DatCommandPtr)+P_FSYSNAMESIZE));
  84.     if (i=='M')
  85.         i='I';
  86.     return(i);
  87.     }
  88.  
  89. LOCAL_C INT LookUp(INT key)
  90.     {
  91.     switch (key)
  92.         {
  93.     case 'C':
  94.         return(W_KEY_RETURN);
  95.     case 'D':
  96.         return(W_KEY_DOWN);
  97.     case 'E':
  98.         return(W_KEY_END);
  99.     case 'H':
  100.         return(W_KEY_HOME);
  101.     case 'L':
  102.         return(W_KEY_LEFT);
  103.     case 'M':
  104.         return(W_KEY_MENU);
  105.     case 'P':
  106.         return(W_KEY_PAGE_UP);
  107.     case 'Q':
  108.         return(W_KEY_PAGE_DOWN);
  109.     case 'R':
  110.         return(W_KEY_RIGHT);
  111.     case 'T':
  112.         return(W_KEY_TAB);
  113.     case 'U':
  114.         return(W_KEY_UP);
  115.     case 'X':
  116.         return(W_KEY_ESCAPE);
  117.     case '+':
  118.         return(W_KEY_DIAMOND);
  119.     case '-':
  120.         return(W_KEY_DELETE_LEFT);
  121.     case '?':
  122.         return(CurrentDriveLetter());
  123.         }
  124.     return(key);
  125.     }
  126.  
  127. LOCAL_C VOID DoPause(PR_LPCON *self,INT delay)
  128. /*
  129. This will never leave since is called only within WaitHandler during string
  130. handling, when messaging always takes place asynchronously
  131. */
  132.     {
  133.     p_send3(self,O_LPC_PAUSE,delay);
  134.     }
  135.  
  136. LOCAL_C VOID ProcessNextCharacterInString(PR_LPCON *self)
  137.     {
  138.     INT chr;
  139.     INT mods;
  140.  
  141.     mods=0;
  142. Again:
  143.     chr=(*self->lpcon.pstr++);
  144.     if (!chr)
  145.         {
  146.         SignalCompletion(self,-1);
  147.         return;
  148.         }
  149.     if (chr=='@')
  150.         {
  151.         chr=(*self->lpcon.pstr++);
  152.         if (!chr)
  153.             {
  154.             SignalCompletion(self,-1);
  155.             return;
  156.             }
  157.         if (chr>='0' && chr<='9')
  158.             {
  159.             mods=chr-'0';
  160.             if (mods&1)
  161.                 {
  162.                 mods&=(~1);
  163.                 mods|=W_PSION_MODIFIER;
  164.                 }
  165.             goto Again;
  166.             }
  167.         if (chr!='@')
  168.             {
  169.             mods=(p_isupper(chr)? W_PSION_MODIFIER|W_SHIFT_MODIFIER:
  170.                                                     W_PSION_MODIFIER);
  171.             chr+=W_SPECIAL_KEY;
  172.             }
  173.         }
  174.     else if (chr=='^')
  175.         {
  176.         chr=(*self->lpcon.pstr++);
  177.         if (!chr)
  178.             {
  179.             SignalCompletion(self,-1);
  180.             return;
  181.             }
  182.         if (chr>='0' && chr<='9')
  183.             {
  184.             DoPause(self,10*(chr-'0'));
  185.             return;
  186.             }
  187.         if (chr=='%')
  188.             {
  189.             DoPause(self,5);
  190.             return;
  191.             }
  192.         if (chr=='Y')
  193.             {
  194.             p_send2(self,O_LPC_YIELD);
  195.             SignalCompletion(self,0);
  196.             return;
  197.             }
  198.         chr=LookUp(chr);
  199.         }
  200.     p_send4(self,O_LPC_KEY,chr,mods);
  201.     }
  202.  
  203. LOCAL_C VOID SendEscapeKey(PR_LPCON *self)
  204.     {
  205.     p_send4(self,O_LPC_KEY,W_KEY_ESCAPE,0);
  206.     }
  207.  
  208. #define wws ((PR_WSERV *)self->lpcon.pstr)
  209.  
  210. LOCAL_C VOID NextGroundStep(PR_LPCON *self)
  211.     {
  212.     INT ret;
  213.     VOID *win;
  214.  
  215.     if (self->lpcon.strCount++==1)
  216.         {
  217.         ret=p_pcpyfr(self->lpcon.pid,&wws->wserv.bar,&win,2);
  218.         if (ret)
  219.             {
  220.             SignalCompletion(self,ret);
  221.             return;
  222.             }
  223.         if (win)
  224.             {
  225.             SendEscapeKey(self);
  226.             return;
  227.             }
  228.         }
  229.     if (self->lpcon.strCount==32)
  230.         {
  231.         SignalCompletion(self,E_GEN_TOOMANY);
  232.         return;
  233.         }
  234.     ret=p_pcpyfr(self->lpcon.pid,&wws->wserv.dial,&win,2);
  235.     if (!ret && !win)
  236.         ret=(-1);
  237.     if (ret)
  238.         {
  239.         SignalCompletion(self,ret);
  240.         return;
  241.         }
  242.     SendEscapeKey(self);
  243.     }
  244.  
  245. #undef wws
  246.  
  247. LOCAL_C INT WaitHandler(PR_LPCON *self)
  248.     {
  249.     if (self->lpcon.pid && self->lpcon.lstat!=E_FILE_PENDING)
  250.         {       /* attached process has terminated */
  251.         self->lpcon.pid=0;
  252.         if (self->lpcon.pstr)
  253.             {           /* cancel any string processing */
  254.             if (self->lpcon.sstat!=E_FILE_PENDING)
  255.                 p_iowait();         /* use up the string signal */
  256.             CancelStringState(self);
  257.             self->lpcon.cancel=FALSE;
  258.             }
  259.         if (*self->lpcon.pMstat==E_FILE_PENDING)
  260.             SignalCompletion(self,E_GEN_RECEIVER);
  261.         return(P_SIGNAL_DISABLE);
  262.         }
  263.     if (!self->lpcon.pstr || self->lpcon.sstat==E_FILE_PENDING)
  264.         return(P_SIGNAL_UNUSED);
  265.     if (self->lpcon.cancel)
  266.         {
  267.         self->lpcon.cancel=FALSE;
  268.         self->lpcon.sstat=E_FILE_CANCEL;
  269.         }
  270.     if (self->lpcon.sstat<0)
  271.         {
  272.         CancelStringState(self);
  273.         if (self->lpcon.sstat==(-1))
  274.             self->lpcon.sstat=0;
  275.         SignalCompletion(self,self->lpcon.sstat);
  276.         }
  277.     else if (!self->lpcon.strCount)
  278.         ProcessNextCharacterInString(self);
  279.     else
  280.         NextGroundStep(self);
  281.     return(P_SIGNAL_ENABLE);
  282.     }
  283.  
  284. LOCAL_C VOID LogOff(PR_LPCON *self)
  285.     {
  286.     if (self->lpcon.pid)
  287.         {
  288.         p_sveccall(self->lpcon.whandler,FALSE);
  289.         if (!p_logoffa(self->lpcon.pid));
  290.             p_waitstat(&self->lpcon.lstat);
  291.         self->lpcon.pid=0;
  292.         }
  293.     }
  294.  
  295. LOCAL_C VOID LogOn(PR_LPCON *self)
  296.     {
  297.     INT ret;
  298.  
  299.     ret=p_logona(self->lpcon.pid,&self->lpcon.lstat);
  300.     if (ret)
  301.         {
  302.         self->lpcon.pid=0;
  303.         f_leave(ret);
  304.         }
  305.     p_sveccall(self->lpcon.whandler,TRUE);
  306.     }
  307.  
  308. LOCAL_C INT fSendMessage(PR_LPCON *self,INT type,ATS_MESS_BODY *pu)
  309.     {
  310.     return(f_leave(SendMessage(self,type,pu)));
  311.     }
  312.  
  313. LOCAL_C VOID SendEscapeKeyWait(PR_LPCON *self)
  314.     {
  315.     ATS_MESS_BODY u;
  316.     INT ret;
  317.  
  318.     u.k.mod=0;
  319.     u.k.key=W_KEY_ESCAPE;
  320.     self->lpcon.pMstat=(&self->lpcon.mstat);
  321.     ret=SendMessage(self,TY_ATS_KEY,&u);
  322.     if (self->lpcon.pUstat)
  323.         {
  324.         p_waitstat(self->lpcon.pMstat);
  325.         ret=self->lpcon.mstat;
  326.         }   /* in !pUstat case, waits inside SendMessage */
  327.     ResetPMstat(self);
  328.     f_leave(ret);
  329.     }
  330.  
  331. LOCAL_C VOID CopyTo(PR_LPCON *self,VOID *trg,VOID *src,UINT len)
  332.     {
  333.     f_leave(p_pcpyto(self->lpcon.pid,trg,src,len));
  334.     }
  335.  
  336. LOCAL_C VOID CopyFrom(PR_LPCON *self,VOID *src,VOID *trg,UINT len)
  337.     {
  338.     f_leave(p_pcpyfr(self->lpcon.pid,src,trg,len));
  339.     }
  340.  
  341. LOCAL_C INT Exec