scalos/libraries/popupmenu/pminput.c

   1 //
   2 // PopupMenu
   3 // ©1996-2002 Henrik Isaksson
   4 //
   5 // User Input & timer
   6 //
   7 // $Date$
   8 // $Revision$
   9 //
  10
  11 #include "pmpriv.h"
  12 #include "pminput.h"
  13
  14 //
  15 // Input Handler
  16 //
  17
  18 /// Input handler
  19 M68KFUNC_P2(struct InputEvent *, myhandler,
  20         A0, struct InputEvent *, ev,
  21         A1, struct MsgPort *, port)
  22 {
  23     struct InputEvent *evnt = ev;
  24
  25     do {
  26         if (evnt->ie_Class == IECLASS_RAWKEY) {
  27             struct PM_InpMsg *m;
  28
  29             m = PM_Mem_Alloc(sizeof(struct PM_InpMsg));
  30             if (m) {
  31                 m->msg.mn_Length = sizeof(struct PM_InpMsg);
  32                 m->msg.mn_ReplyPort = NULL;
  33                 m->Kind = 0;
  34                 switch(evnt->ie_Code) {
  35                     case 208:
  36                     case 0x45:
  37                             m->Kind = PM_MSG_TERMINATE;
  38                                   break;
  39                     case 0x4c:
  40                             m->Kind = PM_MSG_UP;
  41                             break;
  42                     case 0x4d:
  43                             m->Kind = PM_MSG_DOWN;
  44                             break;
  45                     case 0x4e:
  46                             m->Kind = PM_MSG_OPENSUB;
  47                             break;
  48                     case 0x4f:
  49                             m->Kind = PM_MSG_CLOSESUB;
  50                             break;
  51                     case 0x44:
  52                     case 0x43:
  53                             m->Kind = PM_MSG_SELECT;
  54                             break;
  55                     case 0x40:
  56                             m->Kind = PM_MSG_MULTISELECT;
  57                             break;
  58                     case 0x50:
  59                             m->Kind = PM_MSG_DEBUGINFO;
  60                             break;
  61                 }
  62                 if (m->Kind) PutMsg(port, (struct Message *)m);
  63                 else PM_Mem_Free(m);
  64             }
  65             evnt->ie_Class = 0;
  66         }
  67         if (evnt->ie_Class == IECLASS_TIMER) {
  68             struct PM_InpMsg *m;
  69
  70             m = PM_Mem_Alloc(sizeof(struct PM_InpMsg));
  71             if (m) {
  72                 m->msg.mn_Length = sizeof(struct PM_InpMsg);
  73                 m->msg.mn_ReplyPort = NULL;
  74                 m->Kind = PM_MSG_TIMER;
  75                 PutMsg(port, (struct Message *)m);
  76             }
  77         }
  78         if (evnt->ie_Class == IECLASS_RAWMOUSE) {
  79             struct PM_InpMsg *m;
  80
  81             m = PM_Mem_Alloc(sizeof(struct PM_InpMsg));
  82             if (m) {
  83                 m->msg.mn_Length = sizeof(struct PM_InpMsg);
  84                 m->msg.mn_ReplyPort = NULL;
  85                 m->Kind = PM_MSG_RAWMOUSE;
  86                 m->Code = evnt->ie_Code;
  87                 m->Qual = evnt->ie_Qualifier;
  88                 PutMsg(port, (struct Message *)m);
  89             }
  90
  91             evnt->ie_Code = IECODE_NOBUTTON;
  92         }
  93         evnt = evnt->ie_NextEvent;
  94     } while (evnt);
  95
  96     return ev;
  97 }
  98 M68KFUNC_END
  99 ///
 100
 101 /// handlername
 102 static char handlername[] = "PM Input Handler";
 103 ///
 104
 105 #ifdef __AROS__
 106 AROS_UFH2(struct InputEvent *, myhandler_aros,
 107  AROS_UFHA(struct InputEvent *, ev, A0),
 108  AROS_UFHA(struct MsgPort *, port, A1))
 109 {
 110     AROS_USERFUNC_INIT
 111
 112     return myhandler(ev, port);
 113
 114     AROS_USERFUNC_EXIT
 115 }
 116 #define HANDLER_CODE (APTR)AROS_ASMSYMNAME(myhandler_aros)
 117 #else
 118 #define HANDLER_CODE (void *)myhandler
 119 #endif
 120
 121
 122 /// Install handler
 123 struct PM_InputHandler *PM_InstallHandler(int pri)
 124 {
 125     struct PM_InputHandler *pmh;
 126         STATIC_PATCHFUNC(myhandler)
 127
 128     pmh = PM_Mem_Alloc(sizeof(struct PM_InputHandler));
 129     if (pmh) {
 130         pmh->mp = CreatePort(0,0);
 131         if (pmh->mp) {
 132             pmh->port = CreatePort(0,0);
 133             if (pmh->port) {
 134                 pmh->ior = CreateStdIO(pmh->mp);
 135                 if (pmh->ior) {
 136                     pmh->error = OpenDevice("input.device",0,(struct IORequest *)pmh->ior,0);
 137                     if (!pmh->error) {
 138                         pmh->intr.is_Data = (APTR)pmh->port;
 139                         pmh->intr.is_Code = (VOID (*)()) PATCH_NEWFUNC(myhandler);
 140                         pmh->intr.is_Node.ln_Pri = pri;
 141                         pmh->intr.is_Node.ln_Name = handlername;
 142
 143                         pmh->ior->io_Command = IND_ADDHANDLER;
 144                         pmh->ior->io_Data = (APTR)&pmh->intr;
 145                         pmh->ior->io_Message.mn_ReplyPort = pmh->mp;
 146
 147                         DoIO((struct IORequest *)pmh->ior);
 148
 149                     }
 150                 }
 151             }
 152         }
 153
 154     }
 155
 156     return pmh;
 157 }
 158 ///
 159
 160 /// Remove handler
 161 void PM_RemoveHandler(struct PM_InputHandler *pmh)
 162 {
 163     struct PM_InpMsg *msg;
 164
 165     if (pmh->mp) {
 166         if (pmh->port) {
 167             if (pmh->ior) {
 168                 if (!pmh->error) {
 169                     pmh->ior->io_Command = IND_REMHANDLER;
 170                     pmh->ior->io_Data = (APTR)&pmh->intr;
 171                     DoIO((struct IORequest *)pmh->ior);
 172
 173                     CloseDevice((struct IORequest *)pmh->ior);
 174                 }
 175                 DeleteStdIO(pmh->ior);
 176             }
 177             while ((msg = (struct PM_InpMsg *)GetMsg(pmh->port))) {
 178                 PM_Mem_Free(msg);
 179             }
 180             DeletePort(pmh->port);
 181         }
 182         DeletePort(pmh->mp);
 183     }
 184     PM_Mem_Free(pmh);
 185 }
 186 ///
 187
 188 //
 189 // Timer
 190 //
 191
 192 /// Timer functions
 193 //
 194 // timer funcs
 195 //
 196
 197 void EZDeleteTimer(T_TIMEREQUEST *TimeRequest)
 198 {
 199     struct MsgPort *TimePort;
 200
 201     if (TimeRequest)
 202     {
 203         if (TimeRequest->tr_node.io_Device)
 204             CloseDevice((struct IORequest *)TimeRequest);
 205
 206         if ((TimePort = TimeRequest->tr_node.io_Message.mn_ReplyPort))
 207             DeletePort(TimePort);
 208
 209         DeleteExtIO((struct IORequest *)TimeRequest);
 210     }
 211 }
 212
 213 T_TIMEREQUEST *EZCreateTimer(LONG Unit)
 214 {
 215     struct MsgPort      *TimePort;
 216     T_TIMEREQUEST  *TimeRequest;
 217
 218     if (!(TimePort = (struct MsgPort *)CreatePort(NULL,0)))
 219         return(NULL);
 220
 221     if (!(TimeRequest = (T_TIMEREQUEST *)CreateExtIO(TimePort,sizeof(T_TIMEREQUEST))))
 222     {
 223         DeletePort(TimePort);
 224
 225         return(NULL);
 226     }
 227
 228     if (OpenDevice(TIMERNAME, Unit, (struct IORequest *)TimeRequest, 0))
 229     {
 230         DeleteExtIO((struct IORequest *)TimeRequest);
 231         DeletePort(TimePort);
 232
 233         return(NULL);
 234     }
 235
 236     return(TimeRequest);
 237 }
 238 ///