rom/usb/classes/bootkeyboard/bootkeyboard.class.c

   1 /*
   2  *----------------------------------------------------------------------------
   3  *                         bootkeyboard class for poseidon
   4  *----------------------------------------------------------------------------
   5  *                   By Chris Hodges <chrisly@platon42.de>
   6  */
   7
   8 #include "debug.h"
   9
  10 #include "bootkeyboard.class.h"
  11
  12 /* /// "Lib Stuff" */
  13 static const STRPTR libname = MOD_NAME_STRING;
  14
  15 static int libInit(LIBBASETYPEPTR nh)
  16 {
  17     KPRINTF(10, ("libInit nh: 0x%08lx SysBase: 0x%08lx\n", nh, SysBase));
  18
  19     nh->nh_UtilityBase = OpenLibrary("utility.library", 39);
  20
  21 #define UtilityBase     nh->nh_UtilityBase
  22
  23     if(!UtilityBase)
  24     {
  25         KPRINTF(20, ("libInit: OpenLibrary(\"utility.library\", 39) failed!\n"));
  26         return FALSE;
  27     }
  28
  29     KPRINTF(10, ("libInit: Ok\n"));
  30     return TRUE;
  31 }
  32
  33 static int libOpen(LIBBASETYPEPTR nh)
  34 {
  35     KPRINTF(10, ("libOpen nh: 0x%08lx\n", nh));
  36     nLoadClassConfig(nh);
  37
  38     return TRUE;
  39 }
  40
  41 static int libExpunge(LIBBASETYPEPTR nh)
  42 {
  43     KPRINTF(10, ("libExpunge nh: 0x%08lx SysBase: 0x%08lx\n", nh, SysBase));
  44
  45     CloseLibrary(UtilityBase);
  46     nh->nh_UtilityBase = NULL;
  47
  48     return TRUE;
  49 }
  50
  51 ADD2INITLIB(libInit, 0)
  52 ADD2OPENLIB(libOpen, 0)
  53 ADD2EXPUNGELIB(libExpunge, 0)
  54 /* \\\ */
  55
  56 /*
  57  * ***********************************************************************
  58  * * Library functions                                                   *
  59  * ***********************************************************************
  60  */
  61
  62 /* /// "usbAttemptInterfaceBinding()" */
  63 struct NepClassHid * usbAttemptInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
  64 {
  65     struct Library *ps;
  66     ULONG ifclass;
  67     ULONG subclass;
  68     ULONG proto;
  69
  70     KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
  71     if((ps = OpenLibrary("poseidon.library", 4)))
  72     {
  73         psdGetAttrs(PGA_INTERFACE, pif,
  74                     IFA_Class, &ifclass,
  75                     IFA_SubClass, &subclass,
  76                     IFA_Protocol, &proto,
  77                     TAG_DONE);
  78         CloseLibrary(ps);
  79         if((ifclass == HID_CLASSCODE) && (subclass == HID_BOOT_SUBCLASS) && (proto == HID_PROTO_KEYBOARD))
  80         {
  81             return(usbForceInterfaceBinding(nh, pif));
  82         }
  83     }
  84     return(NULL);
  85 }
  86 /* \\\ */
  87
  88 /* /// "usbForceInterfaceBinding()" */
  89 struct NepClassHid * usbForceInterfaceBinding(struct NepHidBase *nh, struct PsdInterface *pif)
  90 {
  91     struct Library *ps;
  92     struct NepClassHid *nch;
  93     struct PsdConfig *pc;
  94     struct PsdDevice *pd;
  95     STRPTR devname;
  96     UBYTE buf[64];
  97     struct Task *tmptask;
  98
  99     KPRINTF(1, ("nepHidAttemptInterfaceBinding(%08lx)\n", pif));
 100     if((ps = OpenLibrary("poseidon.library", 4)))
 101     {
 102         if((nch = psdAllocVec(sizeof(struct NepClassHid))))
 103         {
 104             nch->nch_ClsBase = nh;
 105             nch->nch_Device = NULL;
 106             nch->nch_Interface = pif;
 107
 108             nLoadClassConfig(nh);
 109
 110             psdSafeRawDoFmt(buf, 64, "bootkeyboard.class<%08lx>", nch);
 111             nch->nch_ReadySignal = SIGB_SINGLE;
 112             nch->nch_ReadySigTask = FindTask(NULL);
 113             SetSignal(0, SIGF_SINGLE);
 114             if((tmptask = psdSpawnSubTask(buf, nHidTask, nch)))
 115             {
 116                 psdBorrowLocksWait(tmptask, 1UL<<nch->nch_ReadySignal);
 117                 if(nch->nch_Task)
 118                 {
 119                     nch->nch_ReadySigTask = NULL;
 120                     //FreeSignal(nch->nch_ReadySignal);
 121                     psdGetAttrs(PGA_INTERFACE, pif, IFA_Config, &pc, TAG_END);
 122                     psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
 123                     psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
 124                     psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 125                                    "I've got my fingers on '%s'!",
 126                                    devname);
 127
 128                     CloseLibrary(ps);
 129                     return(nch);
 130                 }
 131             }
 132             nch->nch_ReadySigTask = NULL;
 133             //FreeSignal(nch->nch_ReadySignal);
 134             psdFreeVec(nch);
 135         }
 136         CloseLibrary(ps);
 137     }
 138     return(NULL);
 139 }
 140 /* \\\ */
 141
 142 /* /// "usbReleaseInterfaceBinding()" */
 143 void usbReleaseInterfaceBinding(struct NepHidBase *nh, struct NepClassHid *nch)
 144 {
 145     struct Library *ps;
 146     struct PsdConfig *pc;
 147     struct PsdDevice *pd;
 148     STRPTR devname;
 149
 150     KPRINTF(1, ("nepHidReleaseInterfaceBinding(%08lx)\n", nch));
 151     if((ps = OpenLibrary("poseidon.library", 4)))
 152     {
 153         Forbid();
 154         nch->nch_ReadySignal = SIGB_SINGLE;
 155         nch->nch_ReadySigTask = FindTask(NULL);
 156         if(nch->nch_Task)
 157         {
 158             Signal(nch->nch_Task, SIGBREAKF_CTRL_C);
 159         }
 160         Permit();
 161         while(nch->nch_Task)
 162         {
 163             Wait(1L<<nch->nch_ReadySignal);
 164         }
 165         //FreeSignal(nch->nch_ReadySignal);
 166         psdGetAttrs(PGA_INTERFACE, nch->nch_Interface, IFA_Config, &pc, TAG_END);
 167         psdGetAttrs(PGA_CONFIG, pc, CA_Device, &pd, TAG_END);
 168         psdGetAttrs(PGA_DEVICE, pd, DA_ProductName, &devname, TAG_END);
 169         psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 170                        "I lost my keys to '%s'!",
 171                        devname);
 172         psdFreeVec(nch);
 173         CloseLibrary(ps);
 174     }
 175 }
 176 /* \\\ */
 177
 178 /* /// "usbGetAttrsA()" */
 179 AROS_LH3(LONG, usbGetAttrsA,
 180          AROS_LHA(ULONG, type, D0),
 181          AROS_LHA(APTR, usbstruct, A0),
 182          AROS_LHA(struct TagItem *, tags, A1),
 183          LIBBASETYPEPTR, nh, 5, nep)
 184 {
 185     AROS_LIBFUNC_INIT
 186
 187     struct TagItem *ti;
 188     LONG count = 0;
 189
 190     KPRINTF(1, ("nepHidGetAttrsA(%ld, %08lx, %08lx)\n", type, usbstruct, tags));
 191     switch(type)
 192     {
 193         case UGA_CLASS:
 194              if((ti = FindTagItem(UCCA_Priority, tags)))
 195              {
 196                  *((IPTR *) ti->ti_Data) = -100;
 197                  count++;
 198              }
 199              if((ti = FindTagItem(UCCA_Description, tags)))
 200              {
 201                  *((STRPTR *) ti->ti_Data) = "Support for keyboards in boot protocol mode";
 202                  count++;
 203              }
 204              if((ti = FindTagItem(UCCA_HasClassCfgGUI, tags)))
 205              {
 206                  *((IPTR *) ti->ti_Data) = TRUE;
 207                  count++;
 208              }
 209              if((ti = FindTagItem(UCCA_HasBindingCfgGUI, tags)))
 210              {
 211                  *((IPTR *) ti->ti_Data) = FALSE;
 212                  count++;
 213              }
 214              if((ti = FindTagItem(UCCA_AfterDOSRestart, tags)))
 215              {
 216                  *((IPTR *) ti->ti_Data) = TRUE;
 217                  count++;
 218              }
 219              if((ti = FindTagItem(UCCA_UsingDefaultCfg, tags)))
 220              {
 221                  *((IPTR *) ti->ti_Data) = nh->nh_UsingDefaultCfg;
 222                  count++;
 223              }
 224              break;
 225
 226          case UGA_BINDING:
 227              if((ti = FindTagItem(UCBA_UsingDefaultCfg, tags)))
 228              {
 229                  *((IPTR *) ti->ti_Data) = FALSE;
 230                  count++;
 231              }
 232              break;
 233     }
 234     return(count);
 235     AROS_LIBFUNC_EXIT
 236 }
 237 /* \\\ */
 238
 239 /* /// "usbSetAttrsA()" */
 240 AROS_LH3(LONG, usbSetAttrsA,
 241          AROS_LHA(ULONG, type, D0),
 242          AROS_LHA(APTR, usbstruct, A0),
 243          AROS_LHA(struct TagItem *, tags, A1),
 244          LIBBASETYPEPTR, nh, 6, nep)
 245 {
 246     AROS_LIBFUNC_INIT
 247     return(0);
 248     AROS_LIBFUNC_EXIT
 249 }
 250 /* \\\ */
 251
 252 /* /// "usbDoMethodA()" */
 253 AROS_LH2(IPTR, usbDoMethodA,
 254          AROS_LHA(ULONG, methodid, D0),
 255          AROS_LHA(IPTR *, methoddata, A1),
 256          LIBBASETYPEPTR, nh, 7, nep)
 257 {
 258     AROS_LIBFUNC_INIT
 259
 260     KPRINTF(10, ("Do Method %ld\n", methodid));
 261     switch(methodid)
 262     {
 263         case UCM_AttemptInterfaceBinding:
 264             return((IPTR) usbAttemptInterfaceBinding(nh, (struct PsdInterface *) methoddata[0]));
 265
 266         case UCM_ForceInterfaceBinding:
 267             return((IPTR) usbForceInterfaceBinding(nh, (struct PsdInterface *) methoddata[0]));
 268
 269         case UCM_ReleaseInterfaceBinding:
 270             usbReleaseInterfaceBinding(nh, (struct NepClassHid *) methoddata[0]);
 271             return(TRUE);
 272
 273         case UCM_OpenCfgWindow:
 274             return(nOpenCfgWindow(nh));
 275
 276         case UCM_ConfigChangedEvent:
 277             nLoadClassConfig(nh);
 278             return(TRUE);
 279
 280         default:
 281             break;
 282     }
 283     return(0);
 284     AROS_LIBFUNC_EXIT
 285 }
 286 /* \\\ */
 287
 288 /* /// "nLoadClassConfig()" */
 289 BOOL nLoadClassConfig(struct NepHidBase *nh)
 290 {
 291     struct Library *ps;
 292     struct ClsGlobalCfg *cgc;
 293     struct PsdIFFContext *pic;
 294
 295     KPRINTF(10, ("Loading Class Config...\n"));
 296     if(nh->nh_GUITask)
 297     {
 298         return(FALSE);
 299     }
 300     if(!(ps = OpenLibrary("poseidon.library", 4)))
 301     {
 302         return(FALSE);
 303     }
 304     Forbid();
 305     /* Create default config */
 306     nh->nh_CurrentCGC.cgc_ChunkID = AROS_LONG2BE(MAKE_ID('B','K','E','Y'));
 307     nh->nh_CurrentCGC.cgc_Length = AROS_LONG2BE(sizeof(struct ClsGlobalCfg)-8);
 308     nh->nh_CurrentCGC.cgc_RHEnable = TRUE;
 309     nh->nh_CurrentCGC.cgc_ResetDelay = 10;
 310     nh->nh_CurrentCGC.cgc_CapsLock = FALSE;
 311     nh->nh_CurrentCGC.cgc_ISAMap = FALSE;
 312     nh->nh_CurrentCGC.cgc_ExtraEmulDisable = FALSE;
 313     nh->nh_UsingDefaultCfg = TRUE;
 314     pic = psdGetClsCfg(libname);
 315     if(pic)
 316     {
 317         if((cgc = psdGetCfgChunk(pic, nh->nh_CurrentCGC.cgc_ChunkID)))
 318         {
 319             CopyMem(((UBYTE *) cgc) + 8, ((UBYTE *) &nh->nh_CurrentCGC) + 8, min(AROS_LONG2BE(cgc->cgc_Length), AROS_LONG2BE(nh->nh_CurrentCGC.cgc_Length)));
 320             psdFreeVec(cgc);
 321             nh->nh_UsingDefaultCfg = FALSE;
 322         }
 323     }
 324     Permit();
 325     CloseLibrary(ps);
 326     return(FALSE);
 327 }
 328 /* \\\ */
 329
 330 /* /// "nOpenCfgWindow()" */
 331 LONG nOpenCfgWindow(struct NepHidBase *nh)
 332 {
 333     struct Library *ps;
 334     KPRINTF(10, ("Opening GUI...\n"));
 335     if(!(ps = OpenLibrary("poseidon.library", 4)))
 336     {
 337         return(FALSE);
 338     }
 339     Forbid();
 340     if(!nh->nh_GUITask)
 341     {
 342         if((nh->nh_GUITask = psdSpawnSubTask(MOD_NAME_STRING " GUI", nGUITask, nh)))
 343         {
 344             Permit();
 345             CloseLibrary(ps);
 346             return(TRUE);
 347         }
 348     }
 349     Permit();
 350     CloseLibrary(ps);
 351     return(FALSE);
 352 }
 353 /* \\\ */
 354
 355 /**************************************************************************/
 356
 357 /* /// "Keymap Table" */
 358 static const UBYTE usbkeymap[] =
 359 {
 360     0xff, 0xff, 0xff, 0xff, 0x20, 0x35, 0x33, 0x22,  /* 0x00 */
 361     0x12, 0x23, 0x24, 0x25, 0x17, 0x26, 0x27, 0x28,  /* 0x08 */
 362     0x37, 0x36, 0x18, 0x19, 0x10, 0x13, 0x21, 0x14,  /* 0x10 */
 363     0x16, 0x34, 0x11, 0x32, 0x15, 0x31, 0x01, 0x02,  /* 0x18 */
 364     0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,  /* 0x20 */
 365     0x44, 0x45, 0x41, 0x42, 0x40, 0x0b, 0x0c, 0x1a,  /* 0x28 */
 366     0x1b, 0x0d, 0x2b, 0x29, 0x2a, 0x00, 0x38, 0x39,  /* 0x30 */
 367     0x3a, 0x62, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,  /* 0x38 */
 368     0x56, 0x57, 0x58, 0x59, 0xff, 0x5f, 0xff, 0xff,  /* 0x40 */
 369     0xff, 0xff, 0xff, 0xff, 0x46, 0xff, 0xff, 0x4e,  /* 0x48 */
 370     0x4f, 0x4d, 0x4c, 0xff, 0x5c, 0x5d, 0x4a, 0x5e,  /* 0x50 */
 371     0x43, 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, 0x3d,  /* 0x58 */
 372     0x3e, 0x3f, 0x0f, 0x3c, 0x30, 0xff, 0xff, 0xff,  /* 0x60 */
 373     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x68 F13-F24 */
 374     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x70 */
 375     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x78 */
 376     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x80 */
 377     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x88 */
 378     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x90 */
 379     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0xff,  /* 0x98 */
 380     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xa0 */
 381     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xa8 */
 382     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xb0 */
 383     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xb8 */
 384     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xc0 */
 385     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xc8 */
 386     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xd0 */
 387     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xd8 */
 388     0x63, 0x60, 0x64, 0x66, 0x63, 0x61, 0x65, 0x67,  /* 0xe0 */
 389     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xe8 */
 390     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xf0 */
 391     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff   /* 0xf8 */
 392 };
 393
 394 static const UBYTE usbisakeymap[] =
 395 {
 396     0xff, 0xff, 0xff, 0xff, 0x20, 0x35, 0x33, 0x22,  /* 0x00 */
 397     0x12, 0x23, 0x24, 0x25, 0x17, 0x26, 0x27, 0x28,  /* 0x08 */
 398     0x37, 0x36, 0x18, 0x19, 0x10, 0x13, 0x21, 0x14,  /* 0x10 */
 399     0x16, 0x34, 0x11, 0x32, 0x15, 0x31, 0x01, 0x02,  /* 0x18 */
 400     0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,  /* 0x20 */
 401     0x44, 0x45, 0x41, 0x42, 0x40, 0x0b, 0x0c, 0x1a,  /* 0x28 */
 402     0x1b, 0x0d, 0x2b, 0x29, 0x2a, 0x00, 0x38, 0x39,  /* 0x30 */
 403     0x3a, 0x62, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,  /* 0x38 */
 404     0x56, 0x57, 0x58, 0x59, 0x4b, 0x6f, 0xff, 0xff,  /* 0x40 */
 405     0x6e, 0x47, 0x70, 0x48, 0x46, 0x71, 0x49, 0x4e,  /* 0x48 */
 406     0x4f, 0x4d, 0x4c, 0xff, 0x5c, 0x5d, 0x4a, 0x5e,  /* 0x50 */
 407     0x43, 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, 0x3d,  /* 0x58 */
 408     0x3e, 0x3f, 0x0f, 0x3c, 0x30, 0xff, 0xff, 0xff,  /* 0x60 */
 409     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x68 F13-F24 */
 410     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x70 */
 411     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x78 */
 412     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x80 */
 413     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x88 */
 414     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0x90 */
 415     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0xff,  /* 0x98 */
 416     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xa0 */
 417     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xa8 */
 418     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xb0 */
 419     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xb8 */
 420     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xc0 */
 421     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xc8 */
 422     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xd0 */
 423     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xd8 */
 424     0x63, 0x60, 0x64, 0x66, 0x63, 0x61, 0x65, 0x67,  /* 0xe0 */
 425     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xe8 */
 426     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  /* 0xf0 */
 427     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff   /* 0xf8 */
 428 };
 429 /* \\\ */
 430
 431 #undef ps
 432 #define ps nch->nch_Base
 433
 434 /* /// "nHidTask()" */
 435 AROS_UFH0(void, nHidTask)
 436 {
 437     AROS_USERFUNC_INIT
 438
 439     struct NepClassHid *nch;
 440     struct PsdPipe *pp;
 441     ULONG sigmask;
 442     ULONG sigs;
 443     UBYTE *buf;
 444     LONG ioerr;
 445
 446     if((nch = nAllocHid()))
 447     {
 448         Forbid();
 449         if(nch->nch_ReadySigTask)
 450         {
 451             Signal(nch->nch_ReadySigTask, 1L<<nch->nch_ReadySignal);
 452         }
 453         Permit();
 454         sigmask = (1L<<nch->nch_TaskMsgPort->mp_SigBit)|SIGBREAKF_CTRL_C;
 455         buf = nch->nch_EP1Buf;
 456         psdSendPipe(nch->nch_EP1Pipe, buf, nch->nch_EP1PktSize);
 457         do
 458         {
 459             sigs = Wait(sigmask);
 460             while((pp = (struct PsdPipe *) GetMsg(nch->nch_TaskMsgPort)))
 461             {
 462                 if(pp == nch->nch_EP1Pipe)
 463                 {
 464                     if(!(ioerr = psdGetPipeError(pp)))
 465                     {
 466                         nParseKeys(nch, buf);
 467                     } else {
 468                         KPRINTF(1, ("Int Pipe failed %ld\n", ioerr));
 469                         psdDelayMS(200);
 470                     }
 471                     psdSendPipe(nch->nch_EP1Pipe, buf, nch->nch_EP1PktSize);
 472                     break;
 473                 }
 474             }
 475         } while(!(sigs & SIGBREAKF_CTRL_C));
 476         KPRINTF(20, ("Going down the river!\n"));
 477         memset(buf, 0, 8);
 478         nParseKeys(nch, buf);
 479
 480         psdAbortPipe(nch->nch_EP1Pipe);
 481         psdWaitPipe(nch->nch_EP1Pipe);
 482         nFreeHid(nch);
 483     }
 484     AROS_USERFUNC_EXIT
 485 }
 486 /* \\\ */
 487
 488 /* /// "nParseKeys()" */
 489 void nParseKeys(struct NepClassHid *nch, UBYTE *buf)
 490 {
 491     UWORD iecode;
 492     UWORD qualcode = 0;
 493     ULONG oldqual;
 494     ULONG qualifier = 0;
 495     UWORD keyqual = buf[0];
 496     UWORD nkey, nkey2;
 497     UWORD keycode;
 498     BOOL keydown;
 499     BOOL keyup;
 500     BOOL bonuskey;
 501     BOOL sentkey = FALSE;
 502
 503     if(keyqual & 0x11) qualifier |= IEQUALIFIER_CONTROL;
 504     if(keyqual & 0x02) qualifier |= IEQUALIFIER_LSHIFT;
 505     if(keyqual & 0x04) qualifier |= IEQUALIFIER_LALT;
 506     if(keyqual & 0x08) qualifier |= IEQUALIFIER_LCOMMAND;
 507     if(keyqual & 0x20) qualifier |= IEQUALIFIER_RSHIFT;
 508     if(keyqual & 0x40) qualifier |= IEQUALIFIER_RALT;
 509     if(keyqual & 0x80) qualifier |= IEQUALIFIER_RCOMMAND;
 510     if(!nch->nch_ClsBase->nh_CurrentCGC.cgc_CapsLock)
 511     {
 512         if(qualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
 513         {
 514             nch->nch_CapsLock = FALSE;
 515         }
 516     }
 517     if(nch->nch_CapsLock) qualifier |= IEQUALIFIER_CAPSLOCK;
 518     if((qualifier & (IEQUALIFIER_CONTROL|IEQUALIFIER_LCOMMAND|IEQUALIFIER_RCOMMAND)) ==
 519                     (IEQUALIFIER_CONTROL|IEQUALIFIER_LCOMMAND|IEQUALIFIER_RCOMMAND))
 520     {
 521         struct MsgPort *mp;
 522         struct IOStdReq *ioreq;
 523         struct Interrupt tempint;
 524         struct Node *node;
 525         struct List *listhead = NULL;
 526         KPRINTF(20, ("Reboot!\n"));
 527
 528         if(nch->nch_ClsBase->nh_CurrentCGC.cgc_RHEnable)
 529         {
 530             if((mp = CreateMsgPort()))
 531             {
 532                 if((ioreq = (struct IOStdReq *) CreateIORequest(mp, sizeof(struct IOStdReq))))
 533                 {
 534                     if(!OpenDevice("keyboard.device", 0, (struct IORequest *) ioreq, 0))
 535                     {
 536                         /* Find list header of reset handlers */
 537                         tempint.is_Node.ln_Pred = NULL;
 538                         tempint.is_Node.ln_Succ = NULL;
 539                         tempint.is_Node.ln_Pri = 32;
 540                         tempint.is_Code = NULL;
 541                         ioreq->io_Command = KBD_ADDRESETHANDLER;
 542                         ioreq->io_Data = &tempint;
 543                         Forbid();
 544                         DoIO((struct IORequest *) ioreq);
 545                         if((node = tempint.is_Node.ln_Pred))
 546                         {
 547                             while(node->ln_Pred)
 548                             {
 549                                 node = node->ln_Pred;
 550                             }
 551                             listhead = (struct List *) node;
 552                         }
 553                         ioreq->io_Command = KBD_REMRESETHANDLER;
 554                         DoIO((struct IORequest *) ioreq);
 555                         Permit();
 556                         if(listhead)
 557                         {
 558                             node = listhead->lh_Head;
 559                             while(node->ln_Succ)
 560                             {
 561                                 KPRINTF(20, ("Kicking %s\n", node->ln_Name));
 562                                 Cause((struct Interrupt *) node);
 563                                 node = node->ln_Succ;
 564                             }
 565                             KPRINTF(20, ("Done... awaiting doom\n"));
 566                             psdDelayMS(nch->nch_ClsBase->nh_CurrentCGC.cgc_ResetDelay*1000);
 567                         } else {
 568                             KPRINTF(20, ("Reset handler list not found!\n"));
 569                         }
 570                         CloseDevice((struct IORequest *) ioreq);
 571                     }
 572                     DeleteIORequest((struct IORequest *) ioreq);
 573                 }
 574                 DeleteMsgPort(mp);
 575             }
 576         }
 577         ColdReboot();
 578     }
 579     if(qualifier != nch->nch_OldQualifier)
 580     {
 581         switch(qualifier^nch->nch_OldQualifier)
 582         {
 583             case IEQUALIFIER_LSHIFT:
 584                 qualcode = 0x60;
 585                 break;
 586             case IEQUALIFIER_RSHIFT:
 587                 qualcode = 0x61;
 588                 break;
 589             case IEQUALIFIER_CAPSLOCK:
 590                 qualcode = 0x62;
 591                 break;
 592             case IEQUALIFIER_CONTROL:
 593                 qualcode = 0x63;
 594                 break;
 595             case IEQUALIFIER_LALT:
 596                 qualcode = 0x64;
 597                 break;
 598             case IEQUALIFIER_RALT:
 599                 qualcode = 0x65;
 600                 break;
 601             case IEQUALIFIER_LCOMMAND:
 602                 qualcode = 0x66;
 603                 break;
 604             case IEQUALIFIER_RCOMMAND:
 605                 qualcode = 0x67;
 606                 break;
 607             default:
 608                 qualcode = 0xFF;
 609                 break;
 610         }
 611     }
 612
 613     KPRINTF(1, ("Qualifier %08lx\n", qualifier));
 614     for(nkey = 2; nkey < 8; nkey++)
 615     {
 616         keycode = nch->nch_OldKeyArray[nkey];
 617         if(!keycode)
 618         {
 619             continue;
 620         }
 621         /* Check, if key is still there */
 622         keyup = TRUE;
 623         for(nkey2 = 2; nkey2 < 8; nkey2++)
 624         {
 625             if(buf[nkey2] == keycode)
 626             {
 627                 keyup = FALSE;
 628                 break;
 629             }
 630         }
 631         if(keyup)
 632         {
 633             KPRINTF(1, ("Key up: %08lx\n", keycode));
 634             iecode = nch->nch_ClsBase->nh_CurrentCGC.cgc_ISAMap ? usbisakeymap[keycode] : usbkeymap[keycode];
 635             oldqual = qualifier;
 636             if(!nch->nch_ClsBase->nh_CurrentCGC.cgc_ExtraEmulDisable)
 637             {
 638                 bonuskey = TRUE;
 639                 switch(keycode)
 640                 {
 641                     case 0x49: /* Insert */
 642                         iecode = usbkeymap[0x19];
 643                         qualifier |= IEQUALIFIER_RCOMMAND;
 644                         qualcode = 0x67;
 645                         break;
 646                     case 0x4A: /* Pos 1 */
 647                         iecode = usbkeymap[0x50];
 648                         qualifier |= IEQUALIFIER_LSHIFT;
 649                         qualcode = 0x60;
 650                         break;
 651                     case 0x4D: /* End */
 652                         iecode = usbkeymap[0x4F];
 653                         qualifier |= IEQUALIFIER_LSHIFT;
 654                         qualcode = 0x60;
 655                         break;
 656                     case 0x4B: /* Page Up */
 657                         iecode = usbkeymap[0x52];
 658                         qualifier |= IEQUALIFIER_LSHIFT;
 659                         qualcode = 0x60;
 660                         break;
 661                     case 0x4E: /* Page Down */
 662                         iecode = usbkeymap[0x51];
 663                         qualifier |= IEQUALIFIER_LSHIFT;
 664                         qualcode = 0x60;
 665                         break;
 666                     case 0x48: /* Pause / Break */
 667                         /* *** FIXME *** should be a vanilla key for keymapping compatibility */
 668                         iecode = usbkeymap[0x06];
 669                         qualifier |= IEQUALIFIER_CONTROL;
 670                         qualcode = 0x63;
 671                         break;
 672                     default:
 673                         bonuskey = FALSE;
 674                 }
 675             } else {
 676                 bonuskey = FALSE;
 677             }
 678             nch->nch_FakeEvent.ie_Class = IECLASS_RAWKEY;
 679             nch->nch_FakeEvent.ie_SubClass = 0;
 680             nch->nch_FakeEvent.ie_Code = iecode|IECODE_UP_PREFIX;
 681             nch->nch_FakeEvent.ie_NextEvent = NULL;
 682             nch->nch_FakeEvent.ie_Qualifier = qualifier;
 683             nch->nch_InpIOReq->io_Data = &nch->nch_FakeEvent;
 684             nch->nch_InpIOReq->io_Length = sizeof(struct InputEvent);
 685             nch->nch_InpIOReq->io_Command = IND_WRITEEVENT;
 686             DoIO((struct IORequest *) nch->nch_InpIOReq);
 687             if(bonuskey)
 688             {
 689                 qualifier = oldqual;
 690                 nch->nch_FakeEvent.ie_Class = IECLASS_RAWKEY;
 691                 nch->nch_FakeEvent.ie_SubClass = 0;
 692                 nch->nch_FakeEvent.ie_Code = qualcode|IECODE_UP_PREFIX;
 693                 nch->nch_FakeEvent.ie_NextEvent = NULL;
 694                 nch->nch_FakeEvent.ie_Qualifier = qualifier;
 695                 nch->nch_InpIOReq->io_Data = &nch->nch_FakeEvent;
 696                 nch->nch_InpIOReq->io_Length = sizeof(struct InputEvent);
 697                 nch->nch_InpIOReq->io_Command = IND_WRITEEVENT;
 698                 DoIO((struct IORequest *) nch->nch_InpIOReq);
 699             }
 700             sentkey = TRUE;
 701         }
 702
 703     }
 704
 705     for(nkey = 2; nkey < 8; nkey++)
 706     {
 707         keycode = buf[nkey];
 708         if(!keycode)
 709         {
 710             continue;
 711         }
 712         KPRINTF(1, ("Key down: %08lx\n", keycode));
 713         /* Check, if key was there previously */
 714         keydown = TRUE;
 715         for(nkey2 = 2; nkey2 < 8; nkey2++)
 716         {
 717             if(nch->nch_OldKeyArray[nkey2] == keycode)
 718             {
 719                 keydown = FALSE;
 720                 break;
 721             }
 722         }
 723         if(keydown)
 724         {
 725             iecode = nch->nch_ClsBase->nh_CurrentCGC.cgc_ISAMap ? usbisakeymap[keycode] : usbkeymap[keycode];
 726             if(!nch->nch_ClsBase->nh_CurrentCGC.cgc_ExtraEmulDisable)
 727             {
 728                 switch(keycode)
 729                 {
 730                     case 0x49: /* Insert */
 731                         iecode = usbkeymap[0x19];
 732                         qualifier |= IEQUALIFIER_RCOMMAND;
 733                         break;
 734                     case 0x4A: /* Pos 1 */
 735                         iecode = usbkeymap[0x50];
 736                         qualifier |= IEQUALIFIER_LSHIFT;
 737                         break;
 738                     case 0x4D: /* End */
 739                         iecode = usbkeymap[0x4F];
 740                         qualifier |= IEQUALIFIER_LSHIFT;
 741                         break;
 742                     case 0x4B: /* Page Up */
 743                         iecode = usbkeymap[0x52];
 744                         qualifier |= IEQUALIFIER_LSHIFT;
 745                         break;
 746                     case 0x4E: /* Page Down */
 747                         iecode = usbkeymap[0x51];
 748                         qualifier |= IEQUALIFIER_LSHIFT;
 749                         break;
 750                     case 0x48: /* Pause / Break */
 751                         /* *** FIXME *** should be a vanilla key for keymapping compatibility */
 752                         iecode = usbkeymap[0x06];
 753                         qualifier |= IEQUALIFIER_CONTROL;
 754                         break;
 755                 }
 756             }
 757             if(keycode == 0x39) /* Caps Lock */
 758             {
 759                 if(nch->nch_ClsBase->nh_CurrentCGC.cgc_CapsLock)
 760                 {
 761                     nch->nch_CapsLock = !nch->nch_CapsLock;
 762                 } else {
 763                     nch->nch_CapsLock = TRUE;
 764                 }
 765                 if(nch->nch_CapsLock)
 766                 {
 767                     qualifier |= IEQUALIFIER_CAPSLOCK;
 768                 }
 769             }
 770
 771             nch->nch_FakeEvent.ie_Class = IECLASS_RAWKEY;
 772             nch->nch_FakeEvent.ie_SubClass = 0;
 773             nch->nch_FakeEvent.ie_Code = iecode;
 774             nch->nch_FakeEvent.ie_NextEvent = NULL;
 775             nch->nch_FakeEvent.ie_Qualifier = qualifier;
 776             nch->nch_InpIOReq->io_Data = &nch->nch_FakeEvent;
 777             nch->nch_InpIOReq->io_Length = sizeof(struct InputEvent);
 778             nch->nch_InpIOReq->io_Command = IND_WRITEEVENT;
 779             DoIO((struct IORequest *) nch->nch_InpIOReq);
 780             nch->nch_FakeEvent.ie_position.ie_dead.ie_prev2DownCode = nch->nch_FakeEvent.ie_position.ie_dead.ie_prev1DownCode;
 781             nch->nch_FakeEvent.ie_position.ie_dead.ie_prev2DownQual = nch->nch_FakeEvent.ie_position.ie_dead.ie_prev1DownQual;
 782             nch->nch_FakeEvent.ie_position.ie_dead.ie_prev1DownCode = iecode;
 783             nch->nch_FakeEvent.ie_position.ie_dead.ie_prev1DownQual = qualifier;
 784             sentkey = TRUE;
 785             break;
 786         }
 787     }
 788     /* copy old keymap */
 789     for(nkey = 2; nkey < nch->nch_EP1PktSize; nkey++)
 790     {
 791         nch->nch_OldKeyArray[nkey] = buf[nkey];
 792     }
 793     if((!sentkey) && (nch->nch_OldQualifier != qualifier))
 794     {
 795         nch->nch_FakeEvent.ie_Class = IECLASS_RAWKEY;
 796         nch->nch_FakeEvent.ie_SubClass = 0;
 797         nch->nch_FakeEvent.ie_Code = qualcode;
 798         nch->nch_FakeEvent.ie_NextEvent = NULL;
 799         nch->nch_FakeEvent.ie_Qualifier = qualifier;
 800         nch->nch_InpIOReq->io_Data = &nch->nch_FakeEvent;
 801         nch->nch_InpIOReq->io_Length = sizeof(struct InputEvent);
 802         nch->nch_InpIOReq->io_Command = IND_WRITEEVENT;
 803         DoIO((struct IORequest *) nch->nch_InpIOReq);
 804     }
 805     nch->nch_OldQualifier = qualifier;
 806 }
 807 /* \\\ */
 808
 809 /* /// "nAllocHid()" */
 810 struct NepClassHid * nAllocHid(void)
 811 {
 812     struct Task *thistask;
 813     struct NepClassHid *nch;
 814     LONG ioerr;
 815
 816     thistask = FindTask(NULL);
 817     nch = thistask->tc_UserData;
 818     do
 819     {
 820         if(!(nch->nch_Base = OpenLibrary("poseidon.library", 4)))
 821         {
 822             Alert(AG_OpenLib);
 823             break;
 824         }
 825         psdGetAttrs(PGA_INTERFACE, nch->nch_Interface,
 826                     IFA_Config, &nch->nch_Config,
 827                     IFA_InterfaceNum, &nch->nch_IfNum,
 828                     TAG_END);
 829         psdGetAttrs(PGA_CONFIG, nch->nch_Config,
 830                     CA_Device, &nch->nch_Device,
 831                     TAG_END);
 832
 833         nch->nch_EP1 = psdFindEndpoint(nch->nch_Interface, NULL,
 834                                        EA_IsIn, TRUE,
 835                                        EA_TransferType, USEAF_INTERRUPT,
 836                                        TAG_END);
 837         if(!nch->nch_EP1)
 838         {
 839             KPRINTF(1, ("Ooops!?! No Endpoints defined?\n"));
 840             break;
 841         }
 842         psdGetAttrs(PGA_ENDPOINT, nch->nch_EP1,
 843                     EA_MaxPktSize, &nch->nch_EP1PktSize,
 844                     TAG_END);
 845         if((nch->nch_InpMsgPort = CreateMsgPort()))
 846         {
 847             if((nch->nch_InpIOReq = (struct IOStdReq *) CreateIORequest(nch->nch_InpMsgPort, sizeof(struct IOStdReq))))
 848             {
 849                 if(!OpenDevice("input.device", 0, (struct IORequest *) nch->nch_InpIOReq, 0))
 850                 {
 851                     nch->nch_InputBase = (struct Library *) nch->nch_InpIOReq->io_Device;
 852                     if((nch->nch_TaskMsgPort = CreateMsgPort()))
 853                     {
 854                         if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL)))
 855                         {
 856                             if((nch->nch_EP1Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, nch->nch_EP1)))
 857                             {
 858                                 psdPipeSetup(nch->nch_EP0Pipe, URTF_CLASS|URTF_INTERFACE,
 859                                              UHR_SET_PROTOCOL, HID_PROTO_BOOT, nch->nch_IfNum);
 860                                 ioerr = psdDoPipe(nch->nch_EP0Pipe, NULL, 0);
 861                                 if(!ioerr)
 862                                 {
 863                                     psdPipeSetup(nch->nch_EP0Pipe, URTF_CLASS|URTF_INTERFACE,
 864                                                  UHR_SET_IDLE, 0, nch->nch_IfNum);
 865                                     ioerr = psdDoPipe(nch->nch_EP0Pipe, NULL, 0);
 866                                     if(ioerr)
 867                                     {
 868                                         psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 869                                                        "SET_IDLE=0 failed: %s (%ld)!",
 870                                                        psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 871                                     }
 872                                     if((nch->nch_EP1Buf = psdAllocVec(nch->nch_EP1PktSize)))
 873                                     {
 874                                         nch->nch_Task = thistask;
 875                                         return(nch);
 876                                     }
 877                                 } else {
 878                                     psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname,
 879                                                    "SET_PROTOCOL=BOOT failed: %s (%ld)!",
 880                                                    (APTR) psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 881                                 }
 882                                 psdFreePipe(nch->nch_EP1Pipe);
 883                             }
 884                             psdFreePipe(nch->nch_EP0Pipe);
 885                         }
 886                         DeleteMsgPort(nch->nch_TaskMsgPort);
 887                     }
 888                     CloseDevice((struct IORequest *) nch->nch_InpIOReq);
 889                 }
 890                 DeleteIORequest((struct IORequest *) nch->nch_InpIOReq);
 891             }
 892             DeleteMsgPort(nch->nch_InpMsgPort);
 893         }
 894     } while(FALSE);
 895     CloseLibrary(nch->nch_Base);
 896     Forbid();
 897     nch->nch_Task = NULL;
 898     if(nch->nch_ReadySigTask)
 899     {
 900         Signal(nch->nch_ReadySigTask, 1L<<nch->nch_ReadySignal);
 901     }
 902     return(NULL);
 903 }
 904 /* \\\ */
 905
 906 /* /// "nFreeHid()" */
 907 void nFreeHid(struct NepClassHid *nch)
 908 {
 909     psdFreeVec(nch->nch_EP1Buf);
 910     psdFreePipe(nch->nch_EP1Pipe);
 911     psdFreePipe(nch->nch_EP0Pipe);
 912     DeleteMsgPort(nch->nch_TaskMsgPort);
 913     CloseDevice((struct IORequest *) nch->nch_InpIOReq);
 914     DeleteIORequest((struct IORequest *) nch->nch_InpIOReq);
 915     DeleteMsgPort(nch->nch_InpMsgPort);
 916     CloseLibrary(nch->nch_Base);
 917     Forbid();
 918     nch->nch_Task = NULL;
 919     if(nch->nch_ReadySigTask)
 920     {
 921         Signal(nch->nch_ReadySigTask, 1L<<nch->nch_ReadySignal);
 922     }
 923 }
 924 /* \\\ */
 925
 926 /**************************************************************************/
 927
 928 #undef ps
 929 #define ps nh->nh_PsdBase
 930 #undef IntuitionBase
 931 #define IntuitionBase nh->nh_IntBase
 932 #undef MUIMasterBase
 933 #define MUIMasterBase nh->nh_MUIBase
 934
 935 /* /// "nGUITask()" */
 936 AROS_UFH0(void, nGUITask)
 937 {
 938     AROS_USERFUNC_INIT
 939
 940     struct Task *thistask;
 941     struct NepHidBase *nh;
 942     APTR pic;
 943
 944     thistask = FindTask(NULL);
 945
 946     nh = thistask->tc_UserData;
 947     ++nh->nh_Library.lib_OpenCnt;
 948     if(!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME, MUIMASTER_VMIN)))
 949     {
 950         KPRINTF(10, ("Couldn't open muimaster.library.\n"));
 951         nGUITaskCleanup(nh);
 952         return;
 953     }
 954
 955     if(!(IntuitionBase = OpenLibrary("intuition.library", 39)))
 956     {
 957         KPRINTF(10, ("Couldn't open intuition.library.\n"));
 958         nGUITaskCleanup(nh);
 959         return;
 960     }
 961     if(!(ps = OpenLibrary("poseidon.library", 4)))
 962     {
 963         KPRINTF(10, ("Couldn't open poseidon.library.\n"));
 964         nGUITaskCleanup(nh);
 965         return;
 966     }
 967
 968     nh->nh_App = ApplicationObject,
 969         MUIA_Application_Title      , libname,
 970         MUIA_Application_Version    , VERSION_STRING,
 971         MUIA_Application_Copyright  , "©2002-2009 Chris Hodges",
 972         MUIA_Application_Author     , "Chris Hodges <chrisly@platon42.de>",
 973         MUIA_Application_Description, "Settings for the bootkeyboard.class",
 974         MUIA_Application_Base       , "BOOTKEYBOARD",
 975         MUIA_Application_HelpFile   , "HELP:Poseidon.guide",
 976         MUIA_Application_Menustrip  , MenustripObject,
 977             Child, MenuObjectT("Project"),
 978                 Child, nh->nh_AboutMI = MenuitemObject,
 979                     MUIA_Menuitem_Title, "About...",
 980                     MUIA_Menuitem_Shortcut, "?",
 981                     End,
 982                 End,
 983             Child, MenuObjectT("Settings"),
 984                 Child, nh->nh_UseMI = MenuitemObject,
 985                     MUIA_Menuitem_Title, "Save",
 986                     MUIA_Menuitem_Shortcut, "S",
 987                     End,
 988                 Child, MenuitemObject,
 989                     MUIA_Menuitem_Title, NM_BARLABEL,
 990                     End,
 991                 Child, nh->nh_MUIPrefsMI = MenuitemObject,
 992                     MUIA_Menuitem_Title, "MUI Settings",
 993                     MUIA_Menuitem_Shortcut, "M",
 994                     End,
 995                 End,
 996             End,
 997
 998         SubWindow, nh->nh_MainWindow = WindowObject,
 999             MUIA_Window_ID   , MAKE_ID('M','A','I','N'),
1000             MUIA_Window_Title, libname,
1001             MUIA_HelpNode, libname,
1002
1003             WindowContents, VGroup,
1004                 Child, ColGroup(2), GroupFrameT("Global Settings"),
1005                     Child, Label((IPTR) "Hijack ResetHandlers:"),
1006                     Child, HGroup,
1007                         Child, nh->nh_RHEnableObj = ImageObject, ImageButtonFrame,
1008                             MUIA_Background, MUII_ButtonBack,
1009                             MUIA_CycleChain, 1,
1010                             MUIA_InputMode, MUIV_InputMode_Toggle,
1011                             MUIA_Image_Spec, MUII_CheckMark,
1012                             MUIA_Image_FreeVert, TRUE,
1013                             MUIA_Selected, nh->nh_CurrentCGC.cgc_RHEnable,
1014                             MUIA_ShowSelState, FALSE,
1015                             End,
1016                         Child, HSpace(0),
1017                         End,
1018                     Child, Label((IPTR) "Reset delay:"),
1019                     Child, nh->nh_ResetDelayObj = SliderObject, SliderFrame,
1020                         MUIA_CycleChain, 1,
1021                         MUIA_Numeric_Min, 0,
1022                         MUIA_Numeric_Max, 60,
1023                         MUIA_Numeric_Value, nh->nh_CurrentCGC.cgc_ResetDelay,
1024                         MUIA_Numeric_Format, "%ldsec",
1025                         End,
1026                     Child, Label((IPTR) "Amiga CapsLock behaviour:"),
1027                     Child, HGroup,
1028                         Child, nh->nh_CapsLockObj = ImageObject, ImageButtonFrame,
1029                             MUIA_Background, MUII_ButtonBack,
1030                             MUIA_CycleChain, 1,
1031                             MUIA_InputMode, MUIV_InputMode_Toggle,
1032                             MUIA_Image_Spec, MUII_CheckMark,
1033                             MUIA_Image_FreeVert, TRUE,
1034                             MUIA_Selected, nh->nh_CurrentCGC.cgc_CapsLock,
1035                             MUIA_ShowSelState, FALSE,
1036                             End,
1037                         Child, HSpace(0),
1038                         End,
1039                     Child, Label((IPTR) "Use standard ISA mapping:"),
1040                     Child, HGroup,
1041                         Child, nh->nh_ISAMapObj = ImageObject, ImageButtonFrame,
1042                             MUIA_Background, MUII_ButtonBack,
1043                             MUIA_CycleChain, 1,
1044                             MUIA_InputMode, MUIV_InputMode_Toggle,
1045                             MUIA_Image_Spec, MUII_CheckMark,
1046                             MUIA_Image_FreeVert, TRUE,
1047                             MUIA_Selected, nh->nh_CurrentCGC.cgc_ISAMap,
1048                             MUIA_ShowSelState, FALSE,
1049                             End,
1050                         Child, HSpace(0),
1051                         End,
1052                     Child, Label((IPTR) "Disable extra key emulation:"),
1053                     Child, HGroup,
1054                         Child, nh->nh_ExtraEmulObj = ImageObject, ImageButtonFrame,
1055                             MUIA_Background, MUII_ButtonBack,
1056                             MUIA_CycleChain, 1,
1057                             MUIA_InputMode, MUIV_InputMode_Toggle,
1058                             MUIA_Image_Spec, MUII_CheckMark,
1059                             MUIA_Image_FreeVert, TRUE,
1060                             MUIA_Selected, nh->nh_CurrentCGC.cgc_ExtraEmulDisable,
1061                             MUIA_ShowSelState, FALSE,
1062                             End,
1063                         Child, HSpace(0),
1064                         End,
1065                     End,
1066                 Child, VSpace(0),
1067                 Child, HGroup,
1068                     MUIA_Group_SameWidth, TRUE,
1069                     Child, nh->nh_UseObj = TextObject, ButtonFrame,
1070                         MUIA_Background, MUII_ButtonBack,
1071                         MUIA_CycleChain, 1,
1072                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1073                         MUIA_Text_Contents, "\33c Save ",
1074                         End,
1075                     Child, nh->nh_CloseObj = TextObject, ButtonFrame,
1076                         MUIA_Background, MUII_ButtonBack,
1077                         MUIA_CycleChain, 1,
1078                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1079                         MUIA_Text_Contents, "\33c Use ",
1080                         End,
1081                     End,
1082                 End,
1083             End,
1084         End;
1085
1086     if(!nh->nh_App)
1087     {
1088         KPRINTF(10, ("Couldn't create application\n"));
1089         nGUITaskCleanup(nh);
1090         return;
1091     }
1092     DoMethod(nh->nh_MainWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
1093              nh->nh_App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1094     DoMethod(nh->nh_UseObj, MUIM_Notify, MUIA_Pressed, FALSE,
1095              nh->nh_App, 2, MUIM_Application_ReturnID, ID_STORE_CONFIG);
1096     DoMethod(nh->nh_CloseObj, MUIM_Notify, MUIA_Pressed, FALSE,
1097              nh->nh_App, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1098
1099     DoMethod(nh->nh_AboutMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1100              nh->nh_App, 2, MUIM_Application_ReturnID, ID_ABOUT);
1101     DoMethod(nh->nh_UseMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1102              nh->nh_App, 2, MUIM_Application_ReturnID, ID_STORE_CONFIG);
1103     DoMethod(nh->nh_RestoreDefMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1104              nh->nh_App, 2, MUIM_Application_ReturnID, ID_RESTORE_DEF);
1105     DoMethod(nh->nh_MUIPrefsMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1106              nh->nh_App, 2, MUIM_Application_OpenConfigWindow, 0);
1107
1108     {
1109         ULONG isopen;
1110         ULONG iconify;
1111         ULONG sigs;
1112         ULONG sigmask;
1113         LONG retid;
1114
1115         get(nh->nh_App, MUIA_Application_Iconified, &iconify);
1116         set(nh->nh_MainWindow, MUIA_Window_Open, TRUE);
1117         get(nh->nh_MainWindow, MUIA_Window_Open, &isopen);
1118         if(!(isopen || iconify))
1119         {
1120             nGUITaskCleanup(nh);
1121             return;
1122         }
1123         sigmask = 0;
1124         do
1125         {
1126             retid = DoMethod(nh->nh_App, MUIM_Application_NewInput, &sigs);
1127             switch(retid)
1128             {
1129                 case ID_STORE_CONFIG:
1130                 case MUIV_Application_ReturnID_Quit:
1131                     get(nh->nh_RHEnableObj, MUIA_Selected, &nh->nh_CurrentCGC.cgc_RHEnable);
1132                     get(nh->nh_ResetDelayObj, MUIA_Numeric_Value, &nh->nh_CurrentCGC.cgc_ResetDelay);
1133                     get(nh->nh_CapsLockObj, MUIA_Selected, &nh->nh_CurrentCGC.cgc_CapsLock);
1134                     get(nh->nh_ISAMapObj, MUIA_Selected, &nh->nh_CurrentCGC.cgc_ISAMap);
1135                     get(nh->nh_ExtraEmulObj, MUIA_Selected, &nh->nh_CurrentCGC.cgc_ExtraEmulDisable);
1136                     pic = psdGetClsCfg(libname);
1137                     if(!pic)
1138                     {
1139                         psdSetClsCfg(libname, NULL);
1140                         pic = psdGetClsCfg(libname);
1141                     }
1142                     if(pic)
1143                     {
1144                         if(psdAddCfgEntry(pic, &nh->nh_CurrentCGC))
1145                         {
1146                             if(retid != MUIV_Application_ReturnID_Quit)
1147                             {
1148                                 psdSaveCfgToDisk(NULL, FALSE);
1149                             }
1150                             retid = MUIV_Application_ReturnID_Quit;
1151                         }
1152                     }
1153                     break;
1154
1155                 case ID_ABOUT:
1156                     MUI_RequestA(nh->nh_App, nh->nh_MainWindow, 0, NULL, "Amazing!", VERSION_STRING, NULL);
1157                     break;
1158             }
1159             if(retid == MUIV_Application_ReturnID_Quit)
1160             {
1161                 break;
1162             }
1163             if(sigs)
1164             {
1165                 sigs = Wait(sigs | sigmask | SIGBREAKF_CTRL_C);
1166                 if(sigs & SIGBREAKF_CTRL_C)
1167                 {
1168                     break;
1169                 }
1170             }
1171         } while(TRUE);
1172         set(nh->nh_MainWindow, MUIA_Window_Open, FALSE);
1173     }
1174     nGUITaskCleanup(nh);
1175
1176     AROS_USERFUNC_EXIT
1177 }
1178 /* \\\ */
1179
1180 /* /// "nGUITaskCleanup()" */
1181 void nGUITaskCleanup(struct NepHidBase *nh)
1182 {
1183     if(nh->nh_App)
1184     {
1185         MUI_DisposeObject(nh->nh_App);
1186         nh->nh_App = NULL;
1187     }
1188     if(MUIMasterBase)
1189     {
1190         CloseLibrary(MUIMasterBase);
1191         MUIMasterBase = NULL;
1192     }
1193     if(IntuitionBase)
1194     {
1195         CloseLibrary(IntuitionBase);
1196         IntuitionBase = NULL;
1197     }
1198     if(ps)
1199     {
1200         CloseLibrary(ps);
1201         ps = NULL;
1202     }
1203     Forbid();
1204     nh->nh_GUITask = NULL;
1205     --nh->nh_Library.lib_OpenCnt;
1206 }
1207 /* \\\ */
1208