rom/usb/poseidon/popo.gui.c

   1 /*
   2  * GUI
   3  */
   4
   5 #include "debug.h"
   6 #include "poseidon.library.h"
   7
   8 #include <libraries/mui.h>
   9 #include <intuition/intuition.h>
  10 #include <intuition/intuitionbase.h>
  11 #include <libraries/gadtools.h>
  12 #include <datatypes/soundclass.h>
  13
  14 #include <proto/exec.h>
  15
  16 #define __NOLIBBASE__
  17 #include <proto/alib.h>
  18 #include <proto/muimaster.h>
  19 #include <proto/dos.h>
  20 #include <proto/datatypes.h>
  21 #include <proto/intuition.h>
  22 #include <proto/utility.h>
  23 #include <proto/usbclass.h>
  24
  25 #include "numtostr.h"
  26
  27 #define NewList NEWLIST
  28
  29 #include "popo.gui.h"
  30
  31 #include <stdarg.h>
  32
  33 #define MUIMasterBase po->po_MUIBase
  34 #define DataTypesBase po->po_DTBase
  35 #define IntuitionBase po->po_IntBase
  36
  37 /* /// "pPoPoGUITask()" */
  38 AROS_UFH0(void, pPoPoGUITask)
  39 {
  40     AROS_USERFUNC_INIT
  41     struct Task *thistask;
  42     LIBBASETYPEPTR ps;
  43     struct PsdPoPo *po;
  44     struct List *scrlist;
  45     struct PubScreenNode *pubscr;
  46     BOOL hasworkbench = FALSE;
  47
  48     thistask = FindTask(NULL);
  49
  50     ps = thistask->tc_UserData;
  51     SetTaskPri(thistask, 0);
  52     po = &ps->ps_PoPo;
  53
  54     NewList(&po->po_GadgetList);
  55     NewList(&po->po_Sounds);
  56
  57     if(!(IntuitionBase = OpenLibrary("intuition.library", 39)))
  58     {
  59         KPRINTF(10, ("Couldn't open intuition.library.\n"));
  60         pPoPoGUITaskCleanup(ps);
  61         return;
  62     }
  63
  64     scrlist = LockPubScreenList();
  65     pubscr = (struct PubScreenNode *) scrlist->lh_Head;
  66     while(pubscr->psn_Node.ln_Succ)
  67     {
  68         if(strcmp(pubscr->psn_Node.ln_Name, "Workbench") == 0)
  69         {
  70             if(pubscr->psn_Screen)
  71             {
  72                 hasworkbench = TRUE;
  73             }
  74             break;
  75         }
  76         pubscr = (struct PubScreenNode *) pubscr->psn_Node.ln_Succ;
  77     }
  78     UnlockPubScreenList();
  79
  80     if(!hasworkbench)
  81     {
  82         KPRINTF(10, ("No screen open yet.\n"));
  83         pPoPoGUITaskCleanup(ps);
  84         return;
  85     }
  86
  87     if(!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME, MUIMASTER_VMIN)))
  88     {
  89         KPRINTF(10, ("Couldn't open muimaster.library.\n"));
  90         pPoPoGUITaskCleanup(ps);
  91         return;
  92     }
  93
  94     if(!(DataTypesBase = OpenLibrary("datatypes.library", 39)))
  95     {
  96         KPRINTF(10, ("Couldn't open datatypes.library.\n"));
  97         pPoPoGUITaskCleanup(ps);
  98         return;
  99     }
 100
 101     if(!(po->po_MsgPort = CreateMsgPort()))
 102     {
 103         KPRINTF(10, ("Couldn't create MsgPort.\n"));
 104         pPoPoGUITaskCleanup(ps);
 105         return;
 106     }
 107
 108     po->po_EventHandler = psdAddEventHandler(po->po_MsgPort, EHMF_ADDDEVICE|EHMF_REMDEVICE|EHMF_ADDBINDING|EHMF_CONFIGCHG|EHMF_DEVICEDEAD|EHMF_DEVICELOWPW);
 109     if(!po->po_EventHandler)
 110     {
 111         KPRINTF(10, ("Couldn't add EventHandler.\n"));
 112         pPoPoGUITaskCleanup(ps);
 113         return;
 114     }
 115
 116     if(!(po->po_TimerMsgPort = CreateMsgPort()))
 117     {
 118         KPRINTF(10, ("Couldn't create MsgPort.\n"));
 119         pPoPoGUITaskCleanup(ps);
 120         return;
 121     }
 122
 123     if(!(po->po_TimerIOReq = (struct timerequest *) CreateIORequest(po->po_TimerMsgPort, sizeof(struct timerequest))))
 124     {
 125         KPRINTF(10, ("Couldn't create TimerIOReq.\n"));
 126         pPoPoGUITaskCleanup(ps);
 127         return;
 128     }
 129
 130     if(OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *) po->po_TimerIOReq, 0))
 131     {
 132         KPRINTF(10, ("Couldn't open timer.device.\n"));
 133         pPoPoGUITaskCleanup(ps);
 134         return;
 135     }
 136     po->po_TimerIOReq->tr_node.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 137     po->po_TimerIOReq->tr_node.io_Message.mn_Node.ln_Name = "PoPo";
 138     po->po_TimerIOReq->tr_node.io_Command = TR_ADDREQUEST;
 139
 140     if(!(po->po_PoPoClass = MUI_CreateCustomClass(NULL, MUIC_Area, NULL, sizeof(struct PoPoData), PoPoDispatcher)))
 141     {
 142         KPRINTF(10, ("Couldn't create PoPo Class\n"));
 143         pPoPoGUITaskCleanup(ps);
 144         return;
 145     }
 146     po->po_PoPoClass->mcc_Class->cl_UserData = (IPTR) ps;
 147
 148     po->po_AppObj = ApplicationObject,
 149         MUIA_Application_Title      , (IPTR)"PoPo -- Poseidon Popup Provider",
 150         MUIA_Application_Version    , (IPTR)VERSION_STRING,
 151         MUIA_Application_Copyright  , (IPTR)"©2004-2009 Chris Hodges",
 152         MUIA_Application_Author     , (IPTR)"Chris Hodges <chrisly@platon42.de>",
 153         MUIA_Application_Description, (IPTR)"Opens annoying windows",
 154         MUIA_Application_Base       , (IPTR)"POPO",
 155         MUIA_Application_HelpFile   , (IPTR)"HELP:Poseidon.guide",
 156         MUIA_Application_Menustrip  , (IPTR)MenustripObject,
 157             Child, (IPTR)MenuObjectT((IPTR)"Project"),
 158                 Child, (IPTR)(po->po_AboutMI = MenuitemObject,
 159                     MUIA_Menuitem_Title, (IPTR)"About...",
 160                     MUIA_Menuitem_Shortcut, (IPTR)"?",
 161                     End),
 162                 Child, (IPTR)MenuitemObject,
 163                     MUIA_Menuitem_Title, (IPTR)NM_BARLABEL,
 164                     End,
 165                 Child, (IPTR)(po->po_CloseMI = MenuitemObject,
 166                     MUIA_Menuitem_Title, (IPTR)"Close",
 167                     MUIA_Menuitem_Shortcut, (IPTR)"Q",
 168                     End),
 169                 End,
 170             Child, (IPTR)MenuObjectT((IPTR)"Settings"),
 171                 Child, (IPTR)(po->po_TridentMI = MenuitemObject,
 172                     MUIA_Menuitem_Title, (IPTR)"Open Trident",
 173                     MUIA_Menuitem_Shortcut, (IPTR)"O",
 174                     End),
 175                 Child, (IPTR)MenuitemObject,
 176                     MUIA_Menuitem_Title, (IPTR)NM_BARLABEL,
 177                     End,
 178                 Child, (IPTR)(po->po_MUIPrefsMI = MenuitemObject,
 179                     MUIA_Menuitem_Title, (IPTR)"MUI Settings",
 180                     MUIA_Menuitem_Shortcut, (IPTR)"M",
 181                     End),
 182                 End,
 183             End,
 184
 185         SubWindow, (IPTR)(po->po_WindowObj = WindowObject,
 186             MUIA_Window_ID   , MAKE_ID('P','O','P','O'),
 187             MUIA_Window_Title, (IPTR)"Poseidon Popups",
 188             MUIA_HelpNode, (IPTR)"main",
 189
 190             WindowContents, (IPTR)VGroup,
 191                 Child, (IPTR)(po->po_PoPoObj = NewObject(po->po_PoPoClass->mcc_Class, 0, MUIA_ShowMe, FALSE, TAG_END)),
 192                 Child, (IPTR)(po->po_GroupObj = VGroup,
 193                     Child, (IPTR)HGroup,
 194                         Child, (IPTR)HSpace(0),
 195                         Child, (IPTR)Label("Messages"),
 196                         Child, (IPTR)HSpace(0),
 197                         End,
 198                     End),
 199                 Child, (IPTR)HGroup,
 200                     Child, (IPTR)(po->po_StickyObj = ImageObject, ImageButtonFrame,
 201                         MUIA_Background, MUII_ButtonBack,
 202                         MUIA_CycleChain, 1,
 203                         MUIA_InputMode, MUIV_InputMode_Toggle,
 204                         MUIA_Image_Spec, MUII_CheckMark,
 205                         MUIA_Image_FreeVert, TRUE,
 206                         MUIA_Selected, FALSE,
 207                         MUIA_ShowSelState, FALSE,
 208                         End),
 209                     Child, (IPTR)Label("Hold on"),
 210                     Child, (IPTR)HGroup,
 211                         MUIA_Group_SameWidth, TRUE,
 212                         Child, (IPTR)(po->po_SaveObj = TextObject, ButtonFrame,
 213                             MUIA_Disabled, (ps->ps_SavedConfigHash == ps->ps_ConfigHash),
 214                             MUIA_Background, MUII_ButtonBack,
 215                             MUIA_CycleChain, 1,
 216                             MUIA_InputMode, MUIV_InputMode_RelVerify,
 217                             MUIA_Text_Contents, (IPTR)"\33c Save Prefs ",
 218                             End),
 219                         Child, (IPTR)(po->po_CloseObj = TextObject, ButtonFrame,
 220                             MUIA_Background, MUII_ButtonBack,
 221                             MUIA_CycleChain, 1,
 222                             MUIA_InputMode, MUIV_InputMode_RelVerify,
 223                             MUIA_Text_Contents, (IPTR)"\33c Close ",
 224                             End),
 225                         End,
 226                     End,
 227                 End,
 228             End),
 229         End;
 230
 231     if(!po->po_AppObj)
 232     {
 233         KPRINTF(10, ("Couldn't create application\n"));
 234         pPoPoGUITaskCleanup(ps);
 235         return;
 236     }
 237
 238     DoMethod(po->po_WindowObj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 239              po->po_AppObj, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 240     DoMethod(po->po_SaveObj, MUIM_Notify, MUIA_Pressed, FALSE,
 241              po->po_PoPoObj, 1, MUIM_PoPo_SavePrefs);
 242     DoMethod(po->po_CloseObj, MUIM_Notify, MUIA_Pressed, FALSE,
 243              po->po_AppObj, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 244     DoMethod(po->po_StickyObj, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
 245              po->po_PoPoObj, 1, MUIM_PoPo_Sticky);
 246
 247     DoMethod(po->po_AboutMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 248              po->po_PoPoObj, 1, MUIM_PoPo_About);
 249     DoMethod(po->po_CloseMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 250              po->po_AppObj, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 251     DoMethod(po->po_TridentMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 252              po->po_PoPoObj, 1, MUIM_PoPo_OpenTrident);
 253     DoMethod(po->po_MUIPrefsMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 254              po->po_AppObj, 2, MUIM_Application_OpenConfigWindow, 0);
 255
 256
 257     {
 258         BOOL isopen = FALSE;
 259         ULONG sigs;
 260         ULONG sigmask;
 261         LONG retid;
 262         struct PsdPoPoGadgets *pog;
 263         struct timeval currtime;
 264
 265         po->po_Task = thistask;
 266         Forbid();
 267         if(po->po_ReadySigTask)
 268         {
 269             Signal(po->po_ReadySigTask, 1L<<po->po_ReadySignal);
 270         }
 271         Permit();
 272
 273         //set(po->po_WindowObj, MUIA_Window_Open, TRUE);
 274         po->po_TimerIOReq->tr_time.tv_micro = 500*1000;
 275         SendIO(&po->po_TimerIOReq->tr_node);
 276         sigmask = (1UL<<po->po_MsgPort->mp_SigBit)|(1UL<<po->po_TimerMsgPort->mp_SigBit);
 277         do
 278         {
 279             retid = DoMethod(po->po_AppObj, MUIM_Application_NewInput, &sigs);
 280             if(sigs)
 281             {
 282                 pEventHandler(ps);
 283                 if(CheckIO(&po->po_TimerIOReq->tr_node))
 284                 {
 285                     WaitIO(&po->po_TimerIOReq->tr_node);
 286                     po->po_TimerIOReq->tr_time.tv_micro = 500*1000;
 287                     SendIO(&po->po_TimerIOReq->tr_node);
 288                 }
 289                 CurrentTime(&currtime.tv_secs, &currtime.tv_micro);
 290                 pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 291                 while(pog->pog_Node.ln_Succ)
 292                 {
 293                     if((currtime.tv_secs > pog->pog_TimeoutTime.tv_secs) ||
 294                        ((currtime.tv_secs == pog->pog_TimeoutTime.tv_secs) &&
 295                         (currtime.tv_micro > pog->pog_TimeoutTime.tv_micro)))
 296                     {
 297                         pFreePoPoGadgets(ps, pog);
 298                         pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 299                     } else {
 300                         pog = (struct PsdPoPoGadgets *) pog->pog_Node.ln_Succ;
 301                     }
 302                 }
 303
 304                 if(po->po_GadgetList.lh_Head->ln_Succ)
 305                 {
 306                     if(po->po_OpenRequest)
 307                     {
 308                         if(!isopen)
 309                         {
 310                             if(ps->ps_GlobalCfg->pgc_PopupActivateWin)
 311                             {
 312                                 set(po->po_WindowObj, MUIA_Window_Activate, TRUE);
 313                             } else {
 314                                 set(po->po_WindowObj, MUIA_Window_Activate, FALSE);
 315                             }
 316                             set(po->po_StickyObj, MUIA_Selected, FALSE);
 317                             set(po->po_WindowObj, MUIA_Window_Open, TRUE);
 318                             isopen = TRUE;
 319                         } else {
 320                             if(ps->ps_GlobalCfg->pgc_PopupWinToFront)
 321                             {
 322                                 DoMethod(po->po_WindowObj, MUIM_Window_ToFront);
 323                             }
 324                         }
 325                         po->po_OpenRequest = FALSE;
 326                     }
 327                 } else {
 328                     if(isopen)
 329                     {
 330                         set(po->po_WindowObj, MUIA_Window_Open, FALSE);
 331                         isopen = FALSE;
 332                     }
 333                 }
 334
 335                 sigs = Wait(sigs | sigmask | SIGBREAKF_CTRL_C);
 336                 if(sigs & SIGBREAKF_CTRL_C)
 337                 {
 338                     break;
 339                 }
 340             }
 341             if(retid == MUIV_Application_ReturnID_Quit)
 342             {
 343                 set(po->po_WindowObj, MUIA_Window_Open, FALSE);
 344                 /* remove all thingies */
 345                 pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 346                 while(pog->pog_Node.ln_Succ)
 347                 {
 348                     pFreePoPoGadgets(ps, pog);
 349                     pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 350                 }
 351             }
 352             if((ps->ps_GlobalCfg->pgc_PopupDeviceNew == PGCP_NEVER) &&
 353                (!ps->ps_GlobalCfg->pgc_PopupDeviceDeath) &&
 354                (!ps->ps_GlobalCfg->pgc_PopupDeviceGone))
 355             {
 356                 psdAddErrorMsg0(RETURN_OK, (STRPTR) "PoPo", "PoPo has been abandoned (is it you, stuntzi?).");
 357                 break;
 358             }
 359
 360         } while(TRUE);
 361         set(po->po_WindowObj, MUIA_Window_Open, FALSE);
 362     }
 363     pPoPoGUITaskCleanup(ps);
 364     AROS_USERFUNC_EXIT
 365 }
 366 /* \\\ */
 367
 368 /* /// "pPoPoGUITaskCleanup()" */
 369 void pPoPoGUITaskCleanup(LIBBASETYPEPTR ps)
 370 {
 371     struct PsdPoPo *po = &ps->ps_PoPo;
 372     struct PsdPoPoGadgets *pog;
 373     struct PsdPoPoSound *pps;
 374
 375     pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 376     while(pog->pog_Node.ln_Succ)
 377     {
 378         pFreePoPoGadgets(ps, pog);
 379         pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 380     }
 381
 382     pps = (struct PsdPoPoSound *) po->po_Sounds.lh_Head;
 383     while(pps->pps_Node.ln_Succ)
 384     {
 385         pPoPoFreeSound(ps, pps);
 386         pps = (struct PsdPoPoSound *) po->po_Sounds.lh_Head;
 387     }
 388
 389     if(po->po_TimerIOReq)
 390     {
 391         if(po->po_TimerIOReq->tr_node.io_Device)
 392         {
 393             AbortIO(&po->po_TimerIOReq->tr_node);
 394             WaitIO(&po->po_TimerIOReq->tr_node);
 395             CloseDevice((struct IORequest *) po->po_TimerIOReq);
 396         }
 397         DeleteIORequest((struct IORequest *) po->po_TimerIOReq);
 398         po->po_TimerIOReq = NULL;
 399     }
 400     if(po->po_TimerMsgPort)
 401     {
 402         DeleteMsgPort(po->po_TimerMsgPort);
 403         po->po_TimerMsgPort = NULL;
 404     }
 405
 406     if(po->po_EventHandler)
 407     {
 408         psdRemEventHandler(po->po_EventHandler);
 409         po->po_EventHandler = NULL;
 410     }
 411     if(po->po_MsgPort)
 412     {
 413         DeleteMsgPort(po->po_MsgPort);
 414         po->po_MsgPort = NULL;
 415     }
 416     if(po->po_AppObj)
 417     {
 418         MUI_DisposeObject(po->po_AppObj);
 419         po->po_AppObj = NULL;
 420     }
 421     if(po->po_PoPoClass)
 422     {
 423         MUI_DeleteCustomClass(po->po_PoPoClass);
 424         po->po_PoPoClass = NULL;
 425     }
 426     if(DataTypesBase)
 427     {
 428         CloseLibrary(DataTypesBase);
 429         DataTypesBase = NULL;
 430     }
 431     if(MUIMasterBase)
 432     {
 433         CloseLibrary(MUIMasterBase);
 434         MUIMasterBase = NULL;
 435     }
 436     if(IntuitionBase)
 437     {
 438         CloseLibrary(IntuitionBase);
 439         IntuitionBase = NULL;
 440     }
 441     Forbid();
 442     po->po_Task = NULL;
 443     if(po->po_ReadySigTask)
 444     {
 445         Signal(po->po_ReadySigTask, 1L<<po->po_ReadySignal);
 446     }
 447 }
 448 /* \\\ */
 449
 450 /* /// "pPoPoLoadSound()" */
 451 struct PsdPoPoSound * pPoPoLoadSound(LIBBASETYPEPTR ps, STRPTR name)
 452 {
 453     struct PsdPoPo *po = &ps->ps_PoPo;
 454     struct PsdPoPoSound *pps;
 455     if((pps = psdAllocVec(sizeof(struct PsdPoPoSound))))
 456     {
 457         if((pps->pps_Node.ln_Name = psdCopyStr(name)))
 458         {
 459             AddTail(&po->po_Sounds, &pps->pps_Node);
 460             pps->pps_DTHandle = NewDTObject(name,
 461                                         DTA_SourceType, DTST_FILE,
 462                                         DTA_GroupID, GID_SOUND,
 463                                         SDTA_Cycles, 1L,
 464                                         TAG_END);
 465             if(!pps->pps_DTHandle)
 466             {
 467                 psdAddErrorMsg(RETURN_ERROR, "PoPo", "Could not load soundfile '%s'.", name);
 468             }
 469             return(pps);
 470         }
 471         psdFreeVec(pps);
 472     }
 473     return(NULL);
 474 }
 475 /* \\\ */
 476
 477 /* /// "pPoPoPlaySound()" */
 478 BOOL pPoPoPlaySound(LIBBASETYPEPTR ps, STRPTR name)
 479 {
 480     struct PsdPoPo *po = &ps->ps_PoPo;
 481     struct PsdPoPoSound *pps;
 482     struct dtTrigger playmsg;
 483
 484     pps = (struct PsdPoPoSound *) FindName(&po->po_Sounds, name);
 485     if(!pps)
 486     {
 487         pps = pPoPoLoadSound(ps, name);
 488     }
 489     if(!pps)
 490     {
 491         return(FALSE);
 492     }
 493     if(!pps->pps_DTHandle)
 494     {
 495         return(FALSE);
 496     }
 497
 498     SetAttrs(pps->pps_DTHandle,
 499              SDTA_Volume, 64,
 500              TAG_END);
 501     playmsg.MethodID     = DTM_TRIGGER;
 502     playmsg.dtt_GInfo    = NULL;
 503     playmsg.dtt_Function = STM_PLAY;
 504     playmsg.dtt_Data     = NULL;
 505     DoMethodA(pps->pps_DTHandle, (Msg) &playmsg);
 506     return(TRUE);
 507 }
 508 /* \\\ */
 509
 510 /* /// "pPoPoFreeSound()" */
 511 void pPoPoFreeSound(LIBBASETYPEPTR ps, struct PsdPoPoSound *pps)
 512 {
 513     struct PsdPoPo *po = &ps->ps_PoPo;
 514     Remove(&pps->pps_Node);
 515     if(pps->pps_DTHandle)
 516     {
 517         DisposeDTObject(pps->pps_DTHandle);
 518     }
 519     psdFreeVec(pps->pps_Node.ln_Name);
 520     psdFreeVec(pps);
 521 }
 522 /* \\\ */
 523
 524 /* /// "pIsDeviceStillValid()" */
 525 BOOL pIsDeviceStillValid(LIBBASETYPEPTR ps, struct PsdDevice *pd)
 526 {
 527     struct PsdDevice *tmppd = NULL;
 528     while((tmppd = psdGetNextDevice(tmppd)))
 529     {
 530         if(tmppd == pd)
 531         {
 532             return(TRUE);
 533         }
 534     }
 535     return(FALSE);
 536 }
 537 /* \\\ */
 538
 539 /* /// "pIsClassStillValid()" */
 540 BOOL pIsClassStillValid(LIBBASETYPEPTR ps, struct Library *ucb)
 541 {
 542     struct PsdUsbClass *puc = (struct PsdUsbClass *) ps->ps_Classes.lh_Head;
 543     while(puc->puc_Node.ln_Succ)
 544     {
 545         if(puc->puc_ClassBase == ucb)
 546         {
 547             return(TRUE);
 548         }
 549         puc = (struct PsdUsbClass *) puc->puc_Node.ln_Succ;
 550     }
 551     return(FALSE);
 552 }
 553 /* \\\ */
 554
 555 /* /// "pRemoveOldBox()" */
 556 void pRemoveOldBox(LIBBASETYPEPTR ps, struct PsdDevice *pd)
 557 {
 558     struct PsdPoPo *po = &ps->ps_PoPo;
 559     struct PsdPoPoGadgets *pog;
 560     // try to remove adding message, if it still existing
 561     pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 562     while(pog->pog_Node.ln_Succ)
 563     {
 564         if(pog->pog_Device == pd)
 565         {
 566             pFreePoPoGadgets(ps, pog);
 567             pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 568         } else {
 569             pog = (struct PsdPoPoGadgets *) pog->pog_Node.ln_Succ;
 570         }
 571     }
 572 }
 573 /* \\\ */
 574
 575 /* /// "pGenerateAddBox()" */
 576 struct PsdPoPoGadgets * pGenerateAddBox(LIBBASETYPEPTR ps, struct PsdDevice *pd, struct PsdPoPoGadgets *pog)
 577 {
 578     struct PsdPoPo *po = &ps->ps_PoPo;
 579     STRPTR body = NULL;
 580     STRPTR bindingsstr;
 581     STRPTR bindinginfo;
 582     STRPTR bodyinfo;
 583     STRPTR wholebodyinfo;
 584     STRPTR gad[4] = { NULL, NULL, NULL, NULL };
 585     STRPTR lpwarn;
 586     STRPTR deadwarn;
 587     ULONG  configstate;
 588     BOOL   lowpower = FALSE;
 589     BOOL   isdead = FALSE;
 590     BOOL   updatetime = FALSE;
 591     STRPTR oldbody = NULL;
 592     UWORD  cnt;
 593     ULONG  methods[4] = { MUIM_PoPo_ConfigureBinding, MUIM_PoPo_ConfigureClass, MUIM_PoPo_ShutUp, MUIM_PoPo_RemInfo };
 594
 595     bindingsstr = pBindingsString(ps, pd);
 596     configstate = pCheckConfigurable(ps, pd);
 597
 598     lowpower = pd->pd_Flags & PDFF_LOWPOWER;
 599     isdead = pd->pd_Flags & PDFF_DEAD;
 600
 601     body = "A new USB device was detected:\n\n\33b%s\33n\n\n";
 602     if(lowpower)
 603     {
 604         lpwarn = "\n\n\33bWARNING: Detected low power situation!";
 605     } else {
 606         lpwarn = "";
 607     }
 608     if(isdead)
 609     {
 610         deadwarn = "\n\n\33bWARNING: Device seems to be dead!";
 611     } else {
 612         deadwarn = "";
 613     }
 614
 615     if(bindingsstr)
 616     {
 617         bindinginfo = psdCopyStrFmt("It is bound to \33b%s\33n", bindingsstr);
 618     } else {
 619         bindinginfo = psdCopyStr("No class seems responsible (yet)!");
 620     }
 621     if(!bindinginfo)
 622     {
 623         psdFreeVec(bindingsstr);
 624         return(NULL);
 625     }
 626     if(!(bodyinfo = psdCopyStrFmt(body, pd->pd_ProductStr)))
 627     {
 628         psdFreeVec(bindingsstr);
 629         psdFreeVec(bindinginfo);
 630         return(NULL);
 631     }
 632     if(!(wholebodyinfo = psdCopyStrFmt("%s%s%s%s", bodyinfo, bindinginfo, lpwarn, deadwarn)))
 633     {
 634         psdFreeVec(bindingsstr);
 635         psdFreeVec(bindinginfo);
 636         psdFreeVec(bodyinfo);
 637         return(NULL);
 638     }
 639     if(configstate & PPF_HasBindingGUI)
 640     {
 641         gad[0] = "Set Device Prefs";
 642     }
 643     if(configstate & PPF_HasBindConfig)
 644     {
 645         gad[0] = "Change Device Prefs";
 646     }
 647     if(configstate & PPF_HasClassGUI)
 648     {
 649         gad[1] = "Set Class Prefs";
 650     }
 651     if(configstate & PPF_HasClsConfig)
 652     {
 653         gad[1] = "Change Class Prefs";
 654     }
 655     if(isdead || lowpower)
 656     {
 657         gad[0] = "Disable Port";
 658         methods[0] = MUIM_PoPo_DisablePort;
 659         gad[1] = NULL;
 660     }
 661     if(isdead && (!lowpower))
 662     {
 663         gad[1] = "Powercycle Port";
 664         methods[1] = MUIM_PoPo_PowerCyclePort;
 665     }
 666     gad[2] = "No PopUps!";
 667     gad[3] = "Continue";
 668     if(!pog)
 669     {
 670         pog = pAllocPoPoGadgets(ps, wholebodyinfo, gad);
 671         if(pog)
 672         {
 673             pog->pog_Device = pd;
 674         }
 675     } else {
 676         get(pog->pog_BodyObj, MUIA_Text_Contents, &oldbody);
 677         if(strcmp(oldbody, wholebodyinfo))
 678         {
 679             set(pog->pog_BodyObj, MUIA_Text_Contents, wholebodyinfo);
 680             updatetime = TRUE;
 681         }
 682         for(cnt = 0; cnt < 4; cnt++)
 683         {
 684             if(gad[cnt])
 685             {
 686                 set(pog->pog_GadgetObj[cnt], MUIA_Text_Contents, gad[cnt]);
 687                 set(pog->pog_GadgetObj[cnt], MUIA_ShowMe, TRUE);
 688             } else {
 689                 set(pog->pog_GadgetObj[cnt], MUIA_ShowMe, FALSE);
 690             }
 691         }
 692     }
 693     if(pog)
 694     {
 695         for(cnt = 0; cnt < 4; cnt++)
 696         {
 697             DoMethod(pog->pog_GadgetObj[cnt], MUIM_KillNotify, MUIA_Pressed);
 698             if(gad[cnt])
 699             {
 700                 DoMethod(pog->pog_GadgetObj[cnt], MUIM_Notify, MUIA_Pressed,
 701                     FALSE, po->po_AppObj, 5, MUIM_Application_PushMethod,
 702                     po->po_PoPoObj, 2, methods[cnt], pog);
 703             }
 704         }
 705     }
 706
 707     psdFreeVec(bindingsstr);
 708     psdFreeVec(bindinginfo);
 709     psdFreeVec(bodyinfo);
 710     psdFreeVec(wholebodyinfo);
 711
 712     /* Everything after this depends on having gadgets */
 713     if(!pog)
 714         return NULL;
 715
 716     /* update delay */
 717     if(updatetime && pog)
 718     {
 719         CurrentTime(&pog->pog_TimeoutTime.tv_secs, &pog->pog_TimeoutTime.tv_micro);
 720         if(ps->ps_GlobalCfg->pgc_PopupCloseDelay)
 721         {
 722             pog->pog_TimeoutTime.tv_secs += ps->ps_GlobalCfg->pgc_PopupCloseDelay;
 723         } else {
 724             pog->pog_TimeoutTime.tv_secs += 60*60*24;
 725         }
 726     }
 727
 728     if((ps->ps_GlobalCfg->pgc_PopupDeviceNew >= PGCP_ISNEW) && pd->pd_IsNewToMe)
 729     {
 730         pog->pog_ShowMe = TRUE;
 731     }
 732     if((ps->ps_GlobalCfg->pgc_PopupDeviceNew >= PGCP_ERROR) && (isdead || lowpower))
 733     {
 734         pog->pog_ShowMe = TRUE;
 735     }
 736     switch(ps->ps_GlobalCfg->pgc_PopupDeviceNew)
 737     {
 738         case PGCP_NEVER:
 739         case PGCP_ERROR:
 740         case PGCP_ISNEW:
 741             break;
 742
 743         case PGCP_NOBINDING:
 744             if(configstate & PPF_HasBinding)
 745             {
 746                 break;
 747             }
 748             // break missing on purpose
 749         case PGCP_HASBINDING:
 750             if(configstate & PPF_HasBinding)
 751             {
 752                 pog->pog_ShowMe = TRUE;
 753             }
 754             break;
 755
 756         case PGCP_ASKCONFIG:
 757             if(configstate & PPF_HasBindingGUI)
 758             {
 759                 if(!(configstate & PPF_HasBindConfig))
 760                 {
 761                     pog->pog_ShowMe = TRUE;
 762                 }
 763                 break; // don't ask, if there is an unset default class config
 764             }
 765             if(configstate & PPF_HasClassGUI)
 766             {
 767                 if(!(configstate & PPF_HasClsConfig))
 768                 {
 769                     pog->pog_ShowMe = TRUE;
 770                 }
 771             }
 772             break;
 773
 774         case PGCP_CANCONFIG:
 775             if(configstate & (PPF_HasClassGUI|PPF_HasBindingGUI))
 776             {
 777                 pog->pog_ShowMe = TRUE;
 778             }
 779             break;
 780
 781         case PGCP_ALWAYS:
 782             pog->pog_ShowMe = TRUE;
 783             break;
 784
 785         default:
 786             break;
 787     }
 788     return(pog);
 789 }
 790 /* \\\ */
 791
 792 /* /// "pEventHandler()" */
 793 void pEventHandler(LIBBASETYPEPTR ps)
 794 {
 795     struct PsdPoPo *po = &ps->ps_PoPo;
 796     struct PsdDevice *pd;
 797     struct PsdEventNote *pen;
 798     struct PsdPoPoGadgets *pog;
 799     ULONG  eventmask;
 800     STRPTR body = NULL;
 801     BOOL   addsound = FALSE;
 802     BOOL   remsound = FALSE;
 803     BOOL   cfgchanged = FALSE;
 804
 805     /* delete removed devices first */
 806     psdLockReadPBase();
 807
 808     pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 809     while(pog->pog_Node.ln_Succ)
 810     {
 811         if(pog->pog_Device)
 812         {
 813             /* verify that device is still there */
 814             if(!pIsDeviceStillValid(ps, pog->pog_Device))
 815             {
 816                 /* huh, gone! */
 817                 pFreePoPoGadgets(ps, pog);
 818                 pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
 819                 continue;
 820             }
 821         }
 822         pog = (struct PsdPoPoGadgets *) pog->pog_Node.ln_Succ;
 823     }
 824
 825     eventmask = 0;
 826     while((pen = (struct PsdEventNote *) GetMsg(po->po_MsgPort)))
 827     {
 828         eventmask |= (1L<<pen->pen_Event);
 829         switch(pen->pen_Event)
 830         {
 831             case EHMB_ADDDEVICE:
 832             {
 833                 pd = (struct PsdDevice *) pen->pen_Param1;
 834                 if(pIsDeviceStillValid(ps, pd))
 835                 {
 836                     pRemoveOldBox(ps, pd);
 837                     if(pd->pd_PoPoCfg.poc_InhibitPopup)
 838                     {
 839                         break;
 840                     }
 841                     addsound = TRUE;
 842                     pog = pGenerateAddBox(ps, pd, NULL);
 843                     if(!pog)
 844                     {
 845                         break;
 846                     }
 847                     pog->pog_Device = pd;
 848                     if(pog->pog_ShowMe && (!pog->pog_WaitBinding))
 849                     {
 850                         po->po_OpenRequest = TRUE;
 851                     }
 852                 }
 853                 break;
 854             }
 855
 856             case EHMB_DEVICEDEAD:
 857             case EHMB_DEVICELOWPW:
 858             {
 859                 BOOL lowpower = FALSE;
 860                 BOOL isdead = FALSE;
 861                 BOOL autodis = FALSE;
 862                 STRPTR body;
 863                 STRPTR devname;
 864                 STRPTR gads[4] = { NULL, NULL, NULL, "Ignore" };
 865                 STRPTR autodismsg = "";
 866
 867                 pd = (struct PsdDevice *) pen->pen_Param1;
 868                 if(!pIsDeviceStillValid(ps, pd))
 869                 {
 870                     break;
 871                 }
 872                 lowpower = pd->pd_Flags & PDFF_LOWPOWER;
 873                 isdead = pd->pd_Flags & PDFF_DEAD;
 874                 if(!(lowpower || isdead))
 875                 {
 876                     break;
 877                 }
 878                 if((ps->ps_GlobalCfg->pgc_AutoDisableLP && lowpower) ||
 879                    (ps->ps_GlobalCfg->pgc_AutoDisableDead && isdead) ||
 880                    (ps->ps_GlobalCfg->pgc_AutoRestartDead && isdead))
 881                 {
 882                     struct Library *UsbClsBase;
 883                     struct PsdDevice *hubpd = pd->pd_Hub;
 884                     Forbid();
 885                     if(hubpd->pd_DevBinding)
 886                     {
 887                         UsbClsBase = hubpd->pd_ClsBinding->puc_ClassBase;
 888                         if(pIsClassStillValid(ps, UsbClsBase))
 889                         {
 890                             if(ps->ps_GlobalCfg->pgc_AutoRestartDead && isdead)
 891                             {
 892                                 usbDoMethod((ULONG) UCM_HubPowerCyclePort, hubpd, pd->pd_HubPort);
 893                                 psdAddErrorMsg(RETURN_WARN, ps->ps_Library.lib_Node.ln_Name,
 894                                                "Automatically powercycling port for '%s' due to death event.",
 895                                                pd->pd_ProductStr);
 896                                 autodismsg = "\n\n\33bAutomatically powercycling port!\33n";
 897                             } else {
 898                                 usbDoMethod((ULONG) UCM_HubDisablePort, hubpd, pd->pd_HubPort);
 899                                 psdAddErrorMsg(RETURN_WARN, ps->ps_Library.lib_Node.ln_Name,
 900                                                "Automatically disabling port for '%s' due lowpower/death event.",
 901                                                pd->pd_ProductStr);
 902                                 autodismsg = "\n\n\33bAutomatically disabling port!\33n";
 903                             }
 904                             autodis = TRUE;
 905                         }
 906                     }
 907                     Permit();
 908                 }
 909                 if(pd->pd_PoPoCfg.poc_InhibitPopup)
 910                 {
 911                     break;
 912                 }
 913
 914                 remsound = TRUE;
 915                 if((ps->ps_GlobalCfg->pgc_PopupDeviceNew < PGCP_ERROR) && (!ps->ps_GlobalCfg->pgc_PopupDeviceDeath))
 916                 {
 917                     break;
 918                 }
 919
 920                 pRemoveOldBox(ps, pd);
 921                 gads[0] = "Disable Port";
 922                 devname = pd->pd_ProductStr;
 923                 if(!devname)
 924                 {
 925                     devname = "Unknown Soldier";
 926                 }
 927                 if(lowpower && isdead)
 928                 {
 929                     body = psdCopyStrFmt("\33bWARNING: Detected LOW POWER situation\33n\n\nfor USB device\n\n\33b%s\33n\n\nand it has \33bdropped dead already\33n!%s", devname, autodismsg);
 930                 }
 931                 else if(lowpower)
 932                 {
 933                     body = psdCopyStrFmt("\33bWARNING: Detected LOW POWER situation\33n\n\nfor USB device\n\n\33b%s\33n\n\nand this might cause failures!%s", devname, autodismsg);
 934                 } else {
 935                     body = psdCopyStrFmt("\33bWARNING: DEAD DEVICE!\33n\n\nUSB device\n\n\33b%s\33n\n\ndropped dead for no apparent reason!%s", devname, autodismsg);
 936                     gads[1] = "Powercycle Port";
 937                 }
 938                 pog = pAllocPoPoGadgets(ps, body, gads);
 939                 psdFreeVec(body);
 940                 if(!pog)
 941                 {
 942                     break;
 943                 }
 944
 945                 if(autodis)
 946                 {
 947                     set(pog->pog_GadgetObj[0], MUIA_Disabled, TRUE);
 948                     pog->pog_Device = NULL; // to keep the message on the screen
 949                 } else {
 950                     pog->pog_Device = pd;
 951                 }
 952                 DoMethod(pog->pog_GadgetObj[0], MUIM_Notify, MUIA_Pressed, FALSE,
 953                          po->po_AppObj, 5, MUIM_Application_PushMethod, po->po_PoPoObj, 2, MUIM_PoPo_DisablePort, pog);
 954                 if(gads[1])
 955                 {
 956                     DoMethod(pog->pog_GadgetObj[1], MUIM_Notify, MUIA_Pressed, FALSE,
 957                              po->po_AppObj, 5, MUIM_Application_PushMethod, po->po_PoPoObj, 2, MUIM_PoPo_PowerCyclePort, pog);
 958                 }
 959                 DoMethod(pog->pog_GadgetObj[3], MUIM_Notify, MUIA_Pressed, FALSE,
 960                          po->po_AppObj, 5, MUIM_Application_PushMethod, po->po_PoPoObj, 2, MUIM_PoPo_RemInfo, pog);
 961                 po->po_OpenRequest = TRUE;
 962                 break;
 963             }
 964
 965             case EHMB_REMDEVICE:
 966             {
 967                 pd = (struct PsdDevice *) pen->pen_Param1;
 968                 pRemoveOldBox(ps, pd);
 969                 if(pd->pd_PoPoCfg.poc_InhibitPopup)
 970                 {
 971                     break;
 972                 }
 973                 remsound = TRUE;
 974                 if(!ps->ps_GlobalCfg->pgc_PopupDeviceGone)
 975                 {
 976                     break;
 977                 }
 978                 if(pd->pd_ProductStr)
 979                 {
 980                     body = psdCopyStrFmt("The USB device\n\n\33b%s\33n\n\nhas been removed!", pd->pd_ProductStr);
 981                     /* late free */
 982                     //psdFreeVec(pd->pd_ProductStr);
 983                     //pd->pd_ProductStr = NULL;
 984                 } else {
 985                     body = psdCopyStr("An USB device has been removed,\nbut I cannot recall its name.");
 986                 }
 987                 if(body)
 988                 {
 989                     STRPTR gads[4] = { NULL, NULL, NULL, "Bye bye!" };
 990                     pog = pAllocPoPoGadgets(ps, body, gads);
 991                     psdFreeVec(body);
 992                     if(!pog)
 993                     {
 994                         break;
 995                     }
 996                     DoMethod(pog->pog_GadgetObj[3], MUIM_Notify, MUIA_Pressed, FALSE,
 997                              po->po_AppObj, 5, MUIM_Application_PushMethod, po->po_PoPoObj, 2, MUIM_PoPo_RemInfo, pog);
 998                     po->po_OpenRequest = TRUE;
 999                 }
1000                 break;
1001             }
1002
1003             case EHMB_ADDBINDING:
1004             case EHMB_REMBINDING:
1005             {
1006                 pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
1007                 while(pog->pog_Node.ln_Succ)
1008                 {
1009                     if(pog->pog_Device == (struct PsdDevice *) pen->pen_Param1)
1010                     {
1011                         if(!pIsDeviceStillValid(ps, pog->pog_Device))
1012                         {
1013                             break;
1014                         }
1015                         if(pog->pog_Device->pd_PoPoCfg.poc_InhibitPopup)
1016                         {
1017                             break;
1018                         }
1019                         pGenerateAddBox(ps, pog->pog_Device, pog);
1020                         if(pog->pog_ShowMe)
1021                         {
1022                             po->po_OpenRequest = TRUE;
1023                         }
1024                         break;
1025                     }
1026                     pog = (struct PsdPoPoGadgets *) pog->pog_Node.ln_Succ;
1027                 }
1028                 break;
1029             }
1030
1031             case EHMB_CONFIGCHG:
1032                 if(!cfgchanged)
1033                 {
1034                     psdDelayMS(100);
1035                     cfgchanged = TRUE;
1036                 }
1037                 break;
1038
1039         }
1040         ReplyMsg(&pen->pen_Msg);
1041     }
1042     psdUnlockPBase();
1043     if(addsound)
1044     {
1045         if(po->po_InsertSndFile)
1046         {
1047             if(*po->po_InsertSndFile)
1048             {
1049                 pPoPoPlaySound(ps, po->po_InsertSndFile);
1050             }
1051         }
1052     }
1053     if(remsound)
1054     {
1055         if(po->po_RemoveSndFile)
1056         {
1057             if(*po->po_RemoveSndFile)
1058             {
1059                 pPoPoPlaySound(ps, po->po_RemoveSndFile);
1060             }
1061         }
1062     }
1063     if(cfgchanged)
1064     {
1065         set(po->po_SaveObj, MUIA_Disabled, (ps->ps_SavedConfigHash == ps->ps_ConfigHash));
1066     }
1067 }
1068 /* \\\ */
1069
1070 /* /// "pBindingsString()" */
1071 STRPTR pBindingsString(LIBBASETYPEPTR ps, struct PsdDevice *pd)
1072 {
1073     STRPTR oldstr = NULL;
1074     STRPTR newstr = NULL;
1075     struct PsdConfig *pc;
1076     struct PsdInterface *pif;
1077
1078     if(pd->pd_DevBinding)
1079     {
1080         if(pd->pd_Flags & PDFF_APPBINDING)
1081         {
1082             return(psdCopyStr(((struct PsdAppBinding *) pd->pd_DevBinding)->pab_Task->tc_Node.ln_Name));
1083         } else {
1084             return(psdCopyStr(pd->pd_ClsBinding->puc_ClassBase->lib_Node.ln_Name));
1085         }
1086     } else {
1087         pc = (struct PsdConfig *) pd->pd_Configs.lh_Head;
1088         while(pc->pc_Node.ln_Succ)
1089         {
1090             pif = (struct PsdInterface *) pc->pc_Interfaces.lh_Head;
1091             while(pif->pif_Node.ln_Succ)
1092             {
1093                 if(pif->pif_IfBinding)
1094                 {
1095                     if(oldstr)
1096                     {
1097                         newstr = psdCopyStrFmt("%s, %s", oldstr, pif->pif_ClsBinding->puc_ClassBase->lib_Node.ln_Name);
1098                         psdFreeVec(oldstr),
1099                         oldstr = newstr;
1100                     } else {
1101                         oldstr = psdCopyStr(pif->pif_ClsBinding->puc_ClassBase->lib_Node.ln_Name);
1102                     }
1103                 }
1104                 pif = (struct PsdInterface *) pif->pif_Node.ln_Succ;
1105             }
1106             pc = (struct PsdConfig *) pc->pc_Node.ln_Succ;
1107         }
1108     }
1109     return(oldstr);
1110 }
1111 /* \\\ */
1112
1113 /* /// "pCheckConfigurable()" */
1114 ULONG pCheckConfigurable(LIBBASETYPEPTR ps, struct PsdDevice *pd)
1115 {
1116     ULONG  hasclassgui;
1117     ULONG  hasbindinggui;
1118     ULONG  noconfig;
1119     struct PsdConfig *pc;
1120     struct PsdInterface *pif;
1121     struct Library *UsbClsBase;
1122     ULONG result = 0;
1123
1124     psdLockReadPBase();
1125     if(pd->pd_DevBinding)
1126     {
1127         if(!(pd->pd_Flags & PDFF_APPBINDING))
1128         {
1129             UsbClsBase = pd->pd_ClsBinding->puc_ClassBase;
1130             noconfig = FALSE;
1131             hasclassgui = FALSE;
1132             hasbindinggui = FALSE;
1133             if(pIsClassStillValid(ps, UsbClsBase))
1134             {
1135                 usbGetAttrs(UGA_CLASS, NULL,
1136                             UCCA_HasClassCfgGUI, &hasclassgui,
1137                             UCCA_HasBindingCfgGUI, &hasbindinggui,
1138                             UCCA_UsingDefaultCfg, &noconfig,
1139                             TAG_END);
1140                 result |= PPF_HasBinding;
1141                 if(hasclassgui)
1142                 {
1143                     result |= PPF_HasClassGUI;
1144                     if(!noconfig)
1145                     {
1146                         result |= PPF_HasClsConfig;
1147                     }
1148                 }
1149                 if(hasbindinggui)
1150                 {
1151                     result |= PPF_HasBindingGUI;
1152                     usbGetAttrs(UGA_BINDING, pd->pd_DevBinding,
1153                                 UCBA_UsingDefaultCfg, &noconfig,
1154                                 TAG_END);
1155                     if(!noconfig)
1156                     {
1157                         result |= PPF_HasBindConfig;
1158                     }
1159                 }
1160             }
1161         }
1162     } else {
1163         pc = (struct PsdConfig *) pd->pd_Configs.lh_Head;
1164         while(pc->pc_Node.ln_Succ)
1165         {
1166             pif = (struct PsdInterface *) pc->pc_Interfaces.lh_Head;
1167             while(pif->pif_Node.ln_Succ)
1168             {
1169                 if(pif->pif_IfBinding)
1170                 {
1171                     UsbClsBase = pif->pif_ClsBinding->puc_ClassBase;
1172                     noconfig = FALSE;
1173                     hasclassgui = FALSE;
1174                     hasbindinggui = FALSE;
1175                     if(pIsClassStillValid(ps, UsbClsBase))
1176                     {
1177                         usbGetAttrs(UGA_CLASS, NULL,
1178                                     UCCA_HasClassCfgGUI, &hasclassgui,
1179                                     UCCA_HasBindingCfgGUI, &hasbindinggui,
1180                                     UCCA_UsingDefaultCfg, &noconfig,
1181                                     TAG_END);
1182                         result |= PPF_HasBinding;
1183                         if(hasclassgui)
1184                         {
1185                             result |= PPF_HasClassGUI;
1186                             if(!noconfig)
1187                             {
1188                                 result |= PPF_HasClsConfig;
1189                             }
1190                         }
1191                         if(hasbindinggui)
1192                         {
1193                             result |= PPF_HasBindingGUI;
1194                             usbGetAttrs(UGA_BINDING, pif->pif_IfBinding,
1195                                         UCBA_UsingDefaultCfg, &noconfig,
1196                                         TAG_END);
1197                             if(!noconfig)
1198                             {
1199                                 result |= PPF_HasBindConfig;
1200                             }
1201                         }
1202                     }
1203                 }
1204                 pif = (struct PsdInterface *) pif->pif_Node.ln_Succ;
1205             }
1206             pc = (struct PsdConfig *) pc->pc_Node.ln_Succ;
1207         }
1208     }
1209     psdUnlockPBase();
1210     return(result);
1211 }
1212 /* \\\ */
1213
1214 /* /// "pOpenBindingsConfigGUI()" */
1215 void pOpenBindingsConfigGUI(LIBBASETYPEPTR ps, struct PsdDevice *pd)
1216 {
1217     struct PsdConfig *pc;
1218     struct PsdInterface *pif;
1219     struct Library *UsbClsBase;
1220     ULONG hascfggui;
1221     psdLockReadPBase();
1222     if(!pIsDeviceStillValid(ps, pd))
1223     {
1224         psdUnlockPBase();
1225         return;
1226     }
1227     if(pd->pd_DevBinding)
1228     {
1229         if(!(pd->pd_Flags & PDFF_APPBINDING))
1230         {
1231             UsbClsBase = pd->pd_ClsBinding->puc_ClassBase;
1232             if(pIsClassStillValid(ps, UsbClsBase))
1233             {
1234                 usbGetAttrs(UGA_CLASS, NULL,
1235                             UCCA_HasBindingCfgGUI, &hascfggui,
1236                             TAG_END);
1237                 if(hascfggui)
1238                 {
1239                     usbDoMethod(UCM_OpenBindingCfgWindow, pd->pd_DevBinding);
1240                 }
1241             }
1242         }
1243     } else {
1244         pc = (struct PsdConfig *) pd->pd_Configs.lh_Head;
1245         while(pc->pc_Node.ln_Succ)
1246         {
1247             pif = (struct PsdInterface *) pc->pc_Interfaces.lh_Head;
1248             while(pif->pif_Node.ln_Succ)
1249             {
1250                 if(pif->pif_IfBinding)
1251                 {
1252                     UsbClsBase =  pif->pif_ClsBinding->puc_ClassBase;
1253                     if(pIsClassStillValid(ps, UsbClsBase))
1254                     {
1255                         usbGetAttrs(UGA_CLASS, NULL,
1256                                     UCCA_HasBindingCfgGUI, &hascfggui,
1257                                     TAG_END);
1258                         if(hascfggui)
1259                         {
1260                             usbDoMethod(UCM_OpenBindingCfgWindow, pif->pif_IfBinding);
1261                         }
1262                     }
1263                 }
1264                 pif = (struct PsdInterface *) pif->pif_Node.ln_Succ;
1265             }
1266             pc = (struct PsdConfig *) pc->pc_Node.ln_Succ;
1267         }
1268     }
1269     psdUnlockPBase();
1270 }
1271 /* \\\ */
1272
1273 /* /// "pOpenClassesConfigGUI()" */
1274 void pOpenClassesConfigGUI(LIBBASETYPEPTR ps, struct PsdDevice *pd)
1275 {
1276     struct PsdConfig *pc;
1277     struct PsdInterface *pif;
1278     struct Library *UsbClsBase;
1279     ULONG hascfggui;
1280
1281     psdLockReadPBase();
1282     if(!pIsDeviceStillValid(ps, pd))
1283     {
1284         psdUnlockPBase();
1285         return;
1286     }
1287
1288     if(pd->pd_DevBinding)
1289     {
1290         if(!(pd->pd_Flags & PDFF_APPBINDING))
1291         {
1292             UsbClsBase = pd->pd_ClsBinding->puc_ClassBase;
1293             if(pIsClassStillValid(ps, UsbClsBase))
1294             {
1295                 usbGetAttrs(UGA_CLASS, NULL,
1296                             UCCA_HasClassCfgGUI, &hascfggui,
1297                             TAG_END);
1298                 if(hascfggui)
1299                 {
1300                     usbDoMethod(UCM_OpenCfgWindow);
1301                 }
1302             }
1303         }
1304     } else {
1305         pc = (struct PsdConfig *) pd->pd_Configs.lh_Head;
1306         while(pc->pc_Node.ln_Succ)
1307         {
1308             pif = (struct PsdInterface *) pc->pc_Interfaces.lh_Head;
1309             while(pif->pif_Node.ln_Succ)
1310             {
1311                 if(pif->pif_IfBinding)
1312                 {
1313                     UsbClsBase =  pif->pif_ClsBinding->puc_ClassBase;
1314                     if(pIsClassStillValid(ps, UsbClsBase))
1315                     {
1316                         usbGetAttrs(UGA_CLASS, NULL,
1317                                     UCCA_HasClassCfgGUI, &hascfggui,
1318                                     TAG_END);
1319                         if(hascfggui)
1320                         {
1321                             usbDoMethod(UCM_OpenCfgWindow);
1322                         }
1323                     }
1324                 }
1325                 pif = (struct PsdInterface *) pif->pif_Node.ln_Succ;
1326             }
1327             pc = (struct PsdConfig *) pc->pc_Node.ln_Succ;
1328         }
1329     }
1330     psdUnlockPBase();
1331 }
1332 /* \\\ */
1333
1334 /* /// "pDisableDevicePopup()" */
1335 void pDisableDevicePopup(LIBBASETYPEPTR ps, struct PsdDevice *pd)
1336 {
1337     if(!pIsDeviceStillValid(ps, pd))
1338     {
1339         return;
1340     }
1341     psdSetAttrs(PGA_DEVICE, pd, DA_InhibitPopup, TRUE, TAG_END);
1342 }
1343 /* \\\ */
1344
1345 /* /// "pAllocPoPoGadgets()" */
1346 struct PsdPoPoGadgets * pAllocPoPoGadgets(LIBBASETYPEPTR ps, STRPTR body, STRPTR *gad)
1347 {
1348     struct PsdPoPo *po = &ps->ps_PoPo;
1349     struct PsdPoPoGadgets *pog;
1350     if((pog = (struct PsdPoPoGadgets *) psdAllocVec(sizeof(struct PsdPoPoGadgets))))
1351     {
1352         pog->pog_GroupObj =
1353             VGroup,
1354                 Child, (IPTR)(pog->pog_BodyObj = TextObject,
1355                     MUIA_Frame, MUIV_Frame_Text,
1356                     MUIA_Background, MUII_TextBack,
1357                     MUIA_Text_PreParse, (IPTR)"\33c",
1358                     MUIA_Text_Contents, (IPTR)body,
1359                     End),
1360                 Child, (IPTR)(HGroup,
1361                     MUIA_Group_SameWidth, TRUE,
1362                     Child, (IPTR)(pog->pog_GadgetObj[0] = TextObject, ButtonFrame,
1363                         MUIA_Background, MUII_ButtonBack,
1364                         MUIA_CycleChain, 1,
1365                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1366                         MUIA_Text_PreParse, (IPTR)"\33c",
1367                         MUIA_Text_Contents, (IPTR)(gad[0] ? gad[0] : (STRPTR) ""),
1368                         MUIA_ShowMe, (IPTR)gad[0],
1369                         End),
1370                     Child, (IPTR)(pog->pog_GadgetObj[1] = TextObject, ButtonFrame,
1371                         MUIA_Background, MUII_ButtonBack,
1372                         MUIA_CycleChain, 1,
1373                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1374                         MUIA_Text_PreParse, (IPTR)"\33c",
1375                         MUIA_Text_Contents, (IPTR)(gad[1] ? gad[1] : (STRPTR) ""),
1376                         MUIA_ShowMe, (IPTR)gad[1],
1377                         End),
1378                     Child, (IPTR)(pog->pog_GadgetObj[2] = TextObject, ButtonFrame,
1379                         MUIA_Background, MUII_ButtonBack,
1380                         MUIA_CycleChain, 1,
1381                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1382                         MUIA_Text_PreParse, (IPTR)"\33c",
1383                         MUIA_Text_Contents, (IPTR)(gad[2] ? gad[2] : (STRPTR) ""),
1384                         MUIA_ShowMe, (IPTR)gad[2],
1385                         End),
1386                     Child, (IPTR)(pog->pog_GadgetObj[3] = TextObject, ButtonFrame,
1387                         MUIA_Background, MUII_ButtonBack,
1388                         MUIA_CycleChain, 1,
1389                         MUIA_InputMode, MUIV_InputMode_RelVerify,
1390                         MUIA_Text_PreParse, (IPTR)"\33c",
1391                         MUIA_Text_Contents, (IPTR)(gad[3] ? gad[3] : (STRPTR) ""),
1392                         MUIA_ShowMe, (IPTR)gad[3],
1393                         End),
1394                     End),
1395                 //Child, VSpace(0),
1396                 Child, (IPTR)(BalanceObject,
1397                     End),
1398                 //Child, VSpace(0),
1399                 End;
1400
1401         if(!pog->pog_GroupObj)
1402         {
1403             psdFreeVec(pog);
1404             return(NULL);
1405         }
1406         DoMethod(po->po_GroupObj, MUIM_Group_InitChange);
1407         DoMethod(po->po_GroupObj, OM_ADDMEMBER, pog->pog_GroupObj);
1408         DoMethod(po->po_GroupObj, MUIM_Group_ExitChange);
1409         AddTail(&po->po_GadgetList, &pog->pog_Node);
1410         CurrentTime(&pog->pog_TimeoutTime.tv_secs, &pog->pog_TimeoutTime.tv_micro);
1411         if(ps->ps_GlobalCfg->pgc_PopupCloseDelay && (!po->po_Sticky))
1412         {
1413             pog->pog_TimeoutTime.tv_secs += ps->ps_GlobalCfg->pgc_PopupCloseDelay;
1414         } else {
1415             pog->pog_TimeoutTime.tv_secs += 60*60*24;
1416         }
1417     }
1418     return(pog);
1419 }
1420 /* \\\ */
1421
1422 /* /// "pFreePoPoGadgets()" */
1423 void pFreePoPoGadgets(LIBBASETYPEPTR ps, struct PsdPoPoGadgets *pog)
1424 {
1425     struct PsdPoPo *po = &ps->ps_PoPo;
1426     Remove(&pog->pog_Node);
1427     DoMethod(po->po_GroupObj, MUIM_Group_InitChange);
1428     DoMethod(po->po_GroupObj, OM_REMMEMBER, pog->pog_GroupObj);
1429     DoMethod(po->po_GroupObj, MUIM_Group_ExitChange);
1430     MUI_DisposeObject(pog->pog_GroupObj);
1431     psdFreeVec(pog);
1432 }
1433 /* \\\ */
1434
1435 /* /// "PoPoDispatcher()" */
1436 AROS_UFH3(IPTR, PoPoDispatcher,
1437                  AROS_UFHA(struct IClass *, cl, A0),
1438                  AROS_UFHA(Object *, obj, A2),
1439                  AROS_UFHA(Msg, msg, A1))
1440 {
1441     AROS_USERFUNC_INIT
1442     struct PsdPoPoGadgets *pog;
1443     struct PsdPoPoGadgets *tmppog;
1444     LIBBASETYPEPTR ps = (LIBBASETYPEPTR) cl->cl_UserData;
1445     struct PsdPoPo *po = &ps->ps_PoPo;
1446     ULONG sticky = 0;
1447
1448     switch(msg->MethodID)
1449     {
1450         case OM_NEW:
1451             if(!(obj = (Object *)DoSuperMethodA(cl,obj,msg)))
1452                 return(0);
1453             return((IPTR)obj);
1454
1455         case MUIM_PoPo_SavePrefs:
1456             psdSaveCfgToDisk(NULL, FALSE);
1457             set(po->po_SaveObj, MUIA_Disabled, (ps->ps_SavedConfigHash == ps->ps_ConfigHash));
1458             return(0);
1459
1460         case MUIM_PoPo_Sticky:
1461             get(po->po_StickyObj, MUIA_Selected, &sticky);
1462             po->po_Sticky = sticky;
1463             pog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
1464             while(pog->pog_Node.ln_Succ)
1465             {
1466                 CurrentTime(&pog->pog_TimeoutTime.tv_secs, &pog->pog_TimeoutTime.tv_micro);
1467                 if(ps->ps_GlobalCfg->pgc_PopupCloseDelay && (!po->po_Sticky))
1468                 {
1469                     pog->pog_TimeoutTime.tv_secs += ps->ps_GlobalCfg->pgc_PopupCloseDelay;
1470                 } else {
1471                     pog->pog_TimeoutTime.tv_secs += 60*60*24;
1472                 }
1473                 pog = (struct PsdPoPoGadgets *) pog->pog_Node.ln_Succ;
1474             }
1475             return(0);
1476
1477         case MUIM_PoPo_ConfigureBinding:
1478             pog = (struct PsdPoPoGadgets *) ((IPTR *) msg)[1];
1479             //KPRINTF(20, ("Config Po=%08lx, Pog=%08lx, PS=%08lx\n", po, pog, ps));
1480             pog->pog_TimeoutTime.tv_secs += 60*60*24;
1481             pOpenBindingsConfigGUI(ps, pog->pog_Device);
1482             return(0);
1483
1484         case MUIM_PoPo_ConfigureClass:
1485             pog = (struct PsdPoPoGadgets *) ((IPTR *) msg)[1];
1486             //KPRINTF(20, ("Config Po=%08lx, Pog=%08lx, PS=%08lx\n", po, pog, ps));
1487             pog->pog_TimeoutTime.tv_secs += 60*60*24;
1488             pOpenClassesConfigGUI(ps, pog->pog_Device);
1489             return(0);
1490
1491         case MUIM_PoPo_ShutUp:
1492             pog = (struct PsdPoPoGadgets *) ((IPTR *) msg)[1];
1493             pDisableDevicePopup(ps, pog->pog_Device);
1494             pRemoveOldBox(ps, pog->pog_Device);
1495             return(0);
1496
1497         case MUIM_PoPo_RemInfo:
1498             pog = (struct PsdPoPoGadgets *) ((IPTR *) msg)[1];
1499             //KPRINTF(20, ("RemInfo Po=%08lx, Pog=%08lx, PS=%08lx\n", po, pog, ps));
1500             tmppog = (struct PsdPoPoGadgets *) po->po_GadgetList.lh_Head;
1501             while(tmppog->pog_Node.ln_Succ)
1502             {
1503                 if(tmppog == pog)
1504                 {
1505                     pFreePoPoGadgets(ps, pog);
1506                     break;
1507                 }
1508                 tmppog = (struct PsdPoPoGadgets *) tmppog->pog_Node.ln_Succ;
1509             }
1510             return(0);
1511
1512         case MUIM_PoPo_DisablePort:
1513         case MUIM_PoPo_PowerCyclePort:
1514         {
1515             struct PsdDevice *pd;
1516             struct Library *UsbClsBase;
1517             BOOL disable = (msg->MethodID == MUIM_PoPo_DisablePort);
1518
1519             pog = (struct PsdPoPoGadgets *) ((IPTR *) msg)[1];
1520             pd = pog->pog_Device;
1521             set(pog->pog_GadgetObj[0], MUIA_Disabled, TRUE);
1522             if(pog->pog_GadgetObj[1] && (!disable))
1523             {
1524                 set(pog->pog_GadgetObj[1], MUIA_Disabled, TRUE);
1525             }
1526             Forbid();
1527             if(pIsDeviceStillValid(ps, pd))
1528             {
1529                 struct PsdDevice *hubpd = pd->pd_Hub;
1530                 if(hubpd->pd_DevBinding)
1531                 {
1532                     UsbClsBase = hubpd->pd_ClsBinding->puc_ClassBase;
1533                     if(pIsClassStillValid(ps, UsbClsBase))
1534                     {
1535                         usbDoMethod((ULONG) (disable ? UCM_HubDisablePort : UCM_HubPowerCyclePort), hubpd, pd->pd_HubPort);
1536                     }
1537                 }
1538             }
1539             Permit();
1540             pog->pog_TimeoutTime.tv_secs += 60*60*24;
1541
1542             return(0);
1543         }
1544
1545         case MUIM_PoPo_About:
1546             MUI_RequestA(po->po_AppObj, po->po_WindowObj, 0, NULL, "Blimey!", "PoPo -- The Poseidon Popup Provider\n\nWritten by Chris Hodges.\n\nWichtig ist, was hinten rauskommt (Helmut Kohl).", NULL);
1547             return(0);
1548
1549         case MUIM_PoPo_OpenTrident:
1550         {
1551             struct Library *DOSBase;
1552             if((DOSBase = OpenLibrary("dos.library", 39)))
1553             {
1554                 BPTR fhandle;
1555                 if((fhandle = Open("NIL:", MODE_READWRITE)))
1556                 {
1557                     if(SystemTags("Trident",
1558                                   NP_StackSize, 32*1024,
1559                                   SYS_Input, fhandle,
1560                                   SYS_Output, NULL,
1561                                   SYS_Asynch, TRUE,
1562                                   TAG_END))
1563                     {
1564                         Close(fhandle);
1565                         MUI_RequestA(po->po_AppObj, po->po_WindowObj, 0, NULL, "Oh no!", "Bugger!\n\nI tried hard to load Trident,\nbut there was Cryptonite somewhere!", NULL);
1566                     }
1567                 }
1568                 CloseLibrary(DOSBase);
1569             }
1570             return(0);
1571         }
1572     }
1573     return(DoSuperMethodA(cl,obj,msg));
1574     AROS_USERFUNC_EXIT
1575 }
1576 /* \\\ */