rom/usb/trident/DevWinClass.c

   1
   2 /*****************************************************************************
   3 ** This is the DevWinList custom class, a sub class of Window.mui.
   4 ******************************************************************************/
   5
   6 #include "debug.h"
   7
   8 #define USE_INLINE_STDARG
   9 #define __NOLIBBASE__
  10 #include <proto/muimaster.h>
  11 #include <proto/exec.h>
  12 #include <proto/dos.h>
  13 #include <proto/poseidon.h>
  14 #include <proto/intuition.h>
  15 #include <proto/graphics.h>
  16 #include <proto/usbclass.h>
  17 #include <proto/icon.h>
  18 #include <proto/utility.h>
  19
  20 #include "Trident.h"
  21 #include "ActionClass.h"
  22 #include "IconListClass.h"
  23 #include "DevWinClass.h"
  24 #include "CfgListClass.h"
  25
  26 extern struct ExecBase *SysBase;
  27 extern struct Library *ps;
  28 extern struct IntuitionBase *IntuitionBase;
  29 extern struct Library *UtilityBase;
  30 /*extern struct IntuitionBase *IntuitionBase;
  31 extern struct DosLibrary *DOSBase;*/
  32
  33 #define NewList(list) NEWLIST(list)
  34
  35 static char *overridepowerstrings[] =
  36 {
  37     "Trust device",
  38     "Override to bus-powered",
  39     "Override to self-powered",
  40     NULL
  41 };
  42
  43
  44 /* /// "AllocIfEntry()" */
  45 struct IfListEntry * AllocIfEntry(struct DevWinData *data, struct Node *pif, BOOL intend)
  46 {
  47     struct IfListEntry *iflnode;
  48     iflnode = psdAllocVec(sizeof(struct IfListEntry));
  49     if(iflnode)
  50     {
  51         iflnode->pif = pif;
  52         AddTail(&data->iflist, &iflnode->node);
  53     }
  54     return(iflnode);
  55 }
  56 /* \\\ */
  57
  58 /* /// "FreeIfEntry()" */
  59 void FreeIfEntry(struct DevWinData *data, struct IfListEntry *iflnode)
  60 {
  61     Remove(&iflnode->node);
  62     psdFreeVec(iflnode);
  63 }
  64 /* \\\ */
  65
  66 /* /// "InterfaceListDisplayHook()" */
  67 AROS_UFH3(LONG, InterfaceListDisplayHook,
  68                    AROS_UFHA(struct Hook *, hook, A0),
  69                    AROS_UFHA(char **, strarr, A2),
  70                    AROS_UFHA(struct IfListEntry *, iflnode, A1))
  71 {
  72     AROS_USERFUNC_INIT
  73
  74     static char buf1[12];
  75     static char buf3[48];
  76     static char buf4[8];
  77     static char buf5[8];
  78     static char buf6[8];
  79     struct IconListData *data;
  80     struct DevWinData *devdata = (struct DevWinData *) hook->h_Data;
  81
  82     if(iflnode)
  83     {
  84         IPTR clsimg;
  85         IPTR ifnum;
  86         IPTR ifaltnum;
  87         IPTR ifclass;
  88         IPTR ifsubclass;
  89         IPTR ifproto;
  90         STRPTR ifname;
  91         IPTR ifnumeps;
  92         APTR binding;
  93         struct Library *bindingcls;
  94         data = (struct IconListData *) INST_DATA(IconListClass->mcc_Class, devdata->iflvobj);
  95
  96         psdGetAttrs(PGA_INTERFACE, iflnode->pif,
  97                     IFA_InterfaceNum, &ifnum,
  98                     IFA_AlternateNum, &ifaltnum,
  99                     IFA_Class, &ifclass,
 100                     IFA_SubClass, &ifsubclass,
 101                     IFA_Protocol, &ifproto,
 102                     IFA_InterfaceName, &ifname,
 103                     IFA_NumEndpoints, &ifnumeps,
 104                     IFA_Binding, &binding,
 105                     IFA_BindingClass, &bindingcls,
 106                     TAG_END);
 107         psdSafeRawDoFmt(buf1, 12, "%ld/%ld", ifnum, ifaltnum);
 108         clsimg = 5;
 109         switch(ifclass)
 110         {
 111             case STILLIMG_CLASSCODE:
 112                 clsimg = 22;
 113                 break;
 114             case BLUETOOTH_CLASSCODE:
 115                 clsimg = 21;
 116                 break;
 117             case FWUPGRADE_CLASSCODE:
 118                 clsimg = 1;
 119                 break;
 120             case VENDOR_CLASSCODE:
 121                 clsimg++;
 122             case SECURITY_CLASSCODE:
 123                 clsimg++;
 124             case SMARTCARD_CLASSCODE:
 125                 clsimg++;
 126             case CDCDATA_CLASSCODE:
 127                 clsimg++;
 128             case HUB_CLASSCODE:
 129                 clsimg++;
 130             case MASSSTORE_CLASSCODE:
 131                 clsimg++;
 132             case PRINTER_CLASSCODE:
 133                 clsimg++;
 134             case PHYSICAL_CLASSCODE:
 135                 clsimg++;
 136             case HID_CLASSCODE:
 137                 clsimg++;
 138             case CDCCTRL_CLASSCODE:
 139                 clsimg += 2;
 140             case AUDIO_CLASSCODE:
 141                 clsimg++;
 142         }
 143
 144         psdSafeRawDoFmt(buf3, 48, "\33O[%08lx] %ld (%s)",
 145                         data->mimainlist[clsimg],
 146                         ifclass,
 147                         psdNumToStr(NTS_COMBOCLASS, (ifclass<<NTSCCS_CLASS)|(ifsubclass<<NTSCCS_SUBCLASS)|(ifproto<<NTSCCS_PROTO)|
 148                                                     NTSCCF_CLASS|NTSCCF_SUBCLASS|NTSCCF_PROTO, "None"));
 149         psdSafeRawDoFmt(buf4, 8, "%ld", ifsubclass);
 150         psdSafeRawDoFmt(buf5, 8, "%ld", ifproto);
 151         psdSafeRawDoFmt(buf6, 8, "%ld", ifnumeps);
 152         *strarr++ = buf1;
 153         *strarr++ = ifname;
 154         *strarr++ = buf3;
 155         *strarr++ = buf4;
 156         *strarr++ = buf5;
 157         *strarr++ = buf6;
 158         if(binding)
 159         {
 160             *strarr = bindingcls->lib_Node.ln_Name;
 161         } else {
 162             *strarr = "None";
 163         }
 164     } else {
 165         *strarr++ = "\33l\33uNum";
 166         *strarr++ = "\33l\33uName";
 167         *strarr++ = "\33l\33uClass";
 168         *strarr++ = "\33l\33uSub";
 169         *strarr++ = "\33l\33uProto";
 170         *strarr++ = "\33l\33uEPs";
 171         *strarr   = "\33l\33uBinding";
 172     }
 173     return(0);
 174     AROS_USERFUNC_EXIT
 175 }
 176 /* \\\ */
 177
 178 /* /// "DevWinDispatcher()" */
 179 AROS_UFH3(IPTR, DevWinDispatcher,
 180           AROS_UFHA(struct IClass *, cl, A0),
 181           AROS_UFHA(Object *, obj, A2),
 182           AROS_UFHA(Msg, msg, A1))
 183 {
 184     AROS_USERFUNC_INIT
 185     // There should never be an uninitialized pointer, but just in case, try to get an mungwall hit if so.
 186     struct DevWinData *data = (struct DevWinData *) 0xABADCAFE;
 187
 188     // on OM_NEW the obj pointer will be void, so don't try to get the data base in this case.
 189     if(msg->MethodID != OM_NEW) data = INST_DATA(cl,obj);
 190
 191     switch(msg->MethodID)
 192     {
 193         case OM_NEW:
 194         {
 195             struct DevListEntry *dlnode;
 196             struct IfListEntry  *iflnode;
 197             IPTR devadr;
 198             IPTR devusbvers;
 199             IPTR devclass;
 200             IPTR devsubclass;
 201             IPTR devproto;
 202             IPTR devvendorid;
 203             IPTR devprodid;
 204             IPTR devversion;
 205             STRPTR devmanufact;
 206             STRPTR devprodname = NULL;
 207             STRPTR devserial;
 208             STRPTR devidstr;
 209             STRPTR customname;
 210             IPTR devcurrlang;
 211             UWORD *devlangarray;
 212             IPTR devislowspeed;
 213             IPTR devishighspeed;
 214             #ifdef AROS_USB30_CODE
 215             IPTR devissuperspeed;
 216             #endif
 217             IPTR devisconnected;
 218             IPTR devhasaddress;
 219             IPTR devhasdevdesc;
 220             IPTR devisconfigured;
 221             IPTR devlowpower = 0;
 222             IPTR devnumcfgs;
 223             IPTR devdontpopup = 0;
 224             IPTR noclassbind = 0;
 225             IPTR overridepower = 0;
 226             IPTR devpowerdrain = 0;
 227             IPTR devpowersupply = 0;
 228             IPTR devhubport = 0;
 229             struct Node *devhub = NULL;
 230             STRPTR devhubname = "";
 231
 232             struct List *cfgs;
 233             struct Node *pc;
 234             IPTR cfgselfpow;
 235             IPTR cfgremwake;
 236             IPTR cfgnum;
 237             IPTR cfgmaxpower;
 238             STRPTR cfgname;
 239             IPTR cfgnumifs;
 240
 241             struct List *ifs;
 242             struct Node *pif;
 243             struct Node *altpif;
 244             struct List *altiflist;
 245
 246             APTR binding;
 247             struct Library *bindingcls;
 248
 249             STRPTR textbuf1, textbuf2, textbuf3;
 250             STRPTR devstate;
 251
 252             Object *oldroot = NULL;
 253
 254             if(!(obj = (Object *) DoSuperMethodA(cl, obj, msg)))
 255             {
 256                 return(0);
 257             }
 258             data = INST_DATA(cl, obj);
 259             NewList(&data->iflist);
 260             data->InterfaceDisplayHook.h_Data = data;
 261             data->InterfaceDisplayHook.h_Entry = (APTR) InterfaceListDisplayHook;
 262
 263             dlnode = (struct DevListEntry *) GetTagData(MUIA_DevWin_DevEntry, (IPTR) NULL, ((struct opSet *) msg)->ops_AttrList);
 264
 265             if(dlnode)
 266             {
 267                 dlnode->devdata = data;
 268                 data->dlnode = dlnode;
 269                 data->pd = dlnode->pd;
 270                 psdGetAttrs(PGA_DEVICE, dlnode->pd,
 271                             DA_Address, &devadr,
 272                             DA_UsbVersion, &devusbvers,
 273                             DA_Class, &devclass,
 274                             DA_SubClass, &devsubclass,
 275                             DA_Protocol, &devproto,
 276                             DA_VendorID, &devvendorid,
 277                             DA_ProductID, &devprodid,
 278                             DA_Version, &devversion,
 279                             DA_Manufacturer, &devmanufact,
 280                             DA_OrigProductName, &devprodname,
 281                             DA_ProductName, &customname,
 282                             DA_SerialNumber, &devserial,
 283                             DA_IDString, &devidstr,
 284                             DA_CurrLangID, &devcurrlang,
 285                             DA_LangIDArray, &devlangarray,
 286                             DA_IsLowspeed, &devislowspeed,
 287                             DA_IsHighspeed, &devishighspeed,
 288                             #ifdef AROS_USB30_CODE
 289                             DA_IsSuperspeed, &devissuperspeed,
 290                             #endif
 291                             DA_IsConnected, &devisconnected,
 292                             DA_HasAddress, &devhasaddress,
 293                             DA_HasDevDesc, &devhasdevdesc,
 294                             DA_IsConfigured, &devisconfigured,
 295                             DA_LowPower, &devlowpower,
 296                             DA_NumConfigs, &devnumcfgs,
 297                             DA_ConfigList, &cfgs,
 298                             DA_Binding, &binding,
 299                             DA_BindingClass, &bindingcls,
 300                             DA_InhibitPopup, &devdontpopup,
 301                             DA_InhibitClassBind, &noclassbind,
 302                             DA_OverridePowerInfo, &overridepower,
 303                             DA_PowerSupply, &devpowersupply,
 304                             DA_PowerDrained, &devpowerdrain,
 305                             DA_AtHubPortNumber, &devhubport,
 306                             DA_HubDevice, &devhub,
 307                             TAG_END);
 308                 if(devhub)
 309                 {
 310                     psdGetAttrs(PGA_DEVICE, devhub,
 311                                 DA_ProductName, &devhubname,
 312                                 TAG_END);
 313                 }
 314
 315                 if(!devprodname) /* backward compatibility */
 316                 {
 317                     devprodname = customname;
 318                 }
 319                 textbuf1 = psdAllocVec(3*1024);
 320                 textbuf2 = &textbuf1[1*1024];
 321                 textbuf3 = &textbuf1[2*1024];
 322                 if(!textbuf1)
 323                 {
 324                     return(FALSE);
 325                 }
 326                 psdSafeRawDoFmt(textbuf1, 1024, "%s\n%ld (=0x%04lx)\n%04lx\n%s\n%ld (=0x%04lx)\n%s\n%s\n%ld mA supply / %ldmA drained",
 327                                 devprodname, devprodid, devprodid, devversion, devmanufact, devvendorid, devvendorid,
 328                                 psdNumToStr(NTS_VENDORID, (LONG) devvendorid, "unknown"),
 329                                 devserial,
 330                                 devpowersupply, devpowerdrain);
 331                 if(devisconfigured)
 332                 {
 333                     devstate = "Configured";
 334                 }
 335                 else if(devhasdevdesc)
 336                 {
 337                     devstate = "DevDescriptor";
 338                 }
 339                 else if(devhasaddress)
 340                 {
 341                     devstate = "Valid addr";
 342                 }
 343                 else if(devisconnected)
 344                 {
 345                     devstate = "Connected";
 346                 } else {
 347                     devstate = "Dead";
 348                 }
 349
 350                 psdSafeRawDoFmt(textbuf2, 1024, "%s%s\n%s\n%ld\nPort %ld at %s\n%ld (%s)\n%ld\n%ld\n%04lx",
 351                                 devstate, (devlowpower ? " (Lowpower)" : ""),
 352                                 #ifdef AROS_USB30_CODE
 353                                 (devislowspeed ? "Lowspeed" : (devissuperspeed ? "Superspeed" : (devishighspeed ? "Highspeed" : "Fullspeed"))),
 354                                 #else
 355                                 (devislowspeed ? "Lowspeed" : (devishighspeed ? "Highspeed" : "Fullspeed")),
 356                                 #endif
 357                                 devadr,
 358                                 devhubport, devhubname,
 359                                 devclass,
 360                                 psdNumToStr(NTS_COMBOCLASS,
 361                                         (devclass<<NTSCCS_CLASS)|(devsubclass<<NTSCCS_SUBCLASS)|(devproto<<NTSCCS_PROTO)|
 362                                         NTSCCF_CLASS|NTSCCF_SUBCLASS|NTSCCF_PROTO, "None"),
 363                                 devsubclass, devproto, devusbvers);
 364
 365                 pc = cfgs->lh_Head;
 366                 textbuf3[0] = 0;
 367                 while(pc->ln_Succ)
 368                 {
 369                     psdGetAttrs(PGA_CONFIG, pc,
 370                                 CA_SelfPowered, &cfgselfpow,
 371                                 CA_RemoteWakeup, &cfgremwake,
 372                                 CA_ConfigNum, &cfgnum,
 373                                 CA_MaxPower, &cfgmaxpower,
 374                                 CA_ConfigName, &cfgname,
 375                                 CA_NumInterfaces, &cfgnumifs,
 376                                 CA_InterfaceList, &ifs,
 377                                 TAG_END);
 378
 379                     psdSafeRawDoFmt(&textbuf3[strlen(textbuf3)], (ULONG) 1024-strlen(textbuf3),
 380                                     "Config %ld (%s)\n  Attributes: %s%s\n  MaxPower: %ld mA\n  %ld interface%s.\n",
 381                                     cfgnum, cfgname,
 382                                     cfgselfpow ? "self-powered " : "bus-powered ",
 383                                     cfgremwake ? "remote-wakeup" : "",
 384                                     cfgmaxpower, cfgnumifs,
 385                                     (cfgnumifs != 1) ? "s" : "");
 386                     pc = pc->ln_Succ;
 387                 }
 388
 389                 data->classpopup = CreateClassPopup();
 390                 data->contents = VGroup,
 391                     Child, HGroup,
 392                         MUIA_ShortHelp, "These fields show some general information\n"
 393                                         "on the USB device. Note that strings are not\n"
 394                                         "mandatory and might be artificially created\n"
 395                                         "from the product and vendor IDs.",
 396                         MUIA_FrameTitle, "General device information",
 397                         Child, LabelB("Product name:\nProduct ID:\nProduct version:\nManufacturer:\nVendor:\n\nSerial #:\nPower State:"),
 398                         Child, TextObject,
 399                             TextFrame,
 400                             MUIA_Background, MUII_TextBack,
 401                             MUIA_Text_Contents, textbuf1,
 402                             End,
 403                         //Child, HSpace(0),
 404                         Child, LabelB("State:\nSpeed:\nAddress:\nConnected:\nDevClass:\nSubclass:\nProtocol:\nUSB vers:"),
 405                         Child, TextObject,
 406                             TextFrame,
 407                             MUIA_Background, MUII_TextBack,
 408                             MUIA_Text_Contents, textbuf2,
 409                             End,
 410                         End,
 411                     Child, HGroup,
 412                         Child, Label("Custom Device Name:"),
 413                         Child, data->cwnameobj = StringObject,
 414                             MUIA_ShortHelp, "You can enter a more readable name\n"
 415                                             "here, if the device does not provide\n"
 416                                             "a sensible name.",
 417                             StringFrame,
 418                             //MUIA_HorizWeight, 10,
 419                             MUIA_CycleChain, 1,
 420                             MUIA_String_Contents, customname,
 421                             MUIA_String_AdvanceOnCR, TRUE,
 422                             End,
 423                         Child, HGroup,
 424                             MUIA_Group_SameWidth, TRUE,
 425                             Child, data->changenameobj = TextObject,
 426                                 MUIA_ShortHelp, "Click on this button to change the name of the\n"
 427                                                 "name of the device to the new one.",
 428                                 ButtonFrame,
 429                                 MUIA_Background, MUII_ButtonBack,
 430                                 MUIA_CycleChain, 1,
 431                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 432                                 MUIA_Text_Contents, "\33c Change Name ",
 433                                 End,
 434                             Child, data->resetnameobj = TextObject,
 435                                 MUIA_ShortHelp, "Removes the custom name and restores\n"
 436                                                 "the original one that Poseidon generated.",
 437                                 ButtonFrame,
 438                                 MUIA_Background, MUII_ButtonBack,
 439                                 MUIA_CycleChain, 1,
 440                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 441                                 MUIA_Text_Contents, "\33c Restore Name ",
 442                                 End,
 443                             End,
 444                         End,
 445                     Child, HGroup,
 446                         Child, Label("Disable class bindings:"),
 447                         Child, data->noclassbindobj = ImageObject, ImageButtonFrame,
 448                             MUIA_ShortHelp, "Skips this device during class scan,\n"
 449                                             "making it available for application bindings.",
 450                             MUIA_Background, MUII_ButtonBack,
 451                             MUIA_CycleChain, 1,
 452                             MUIA_InputMode, MUIV_InputMode_Toggle,
 453                             MUIA_Image_Spec, MUII_CheckMark,
 454                             MUIA_Image_FreeVert, TRUE,
 455                             MUIA_Selected, noclassbind,
 456                             MUIA_ShowSelState, FALSE,
 457                             End,
 458                         Child, HSpace(0),
 459                         Child, Label("Inhibit popup:"),
 460                         Child, data->dontpopupobj = ImageObject, ImageButtonFrame,
 461                             MUIA_ShortHelp, "Inhibits a popup window appearing\n"
 462                                             "for this particular device.",
 463                             MUIA_Background, MUII_ButtonBack,
 464                             MUIA_CycleChain, 1,
 465                             MUIA_InputMode, MUIV_InputMode_Toggle,
 466                             MUIA_Image_Spec, MUII_CheckMark,
 467                             MUIA_Image_FreeVert, TRUE,
 468                             MUIA_Selected, devdontpopup,
 469                             MUIA_ShowSelState, FALSE,
 470                             End,
 471                         Child, HSpace(0),
 472                         Child, Label("Power info:"),
 473                         Child, data->overridepowerobj = CycleObject,
 474                             MUIA_CycleChain, 1,
 475                             MUIA_ShortHelp, "Some devices and hubs give wrong information\n"
 476                                             "about being self-powered, when they're actually\n"
 477                                             "bus-powered, making me lose my hair.\n"
 478                                             "Hence, you can override the information the\n"
 479                                             "device gives about itself, allowing the power\n"
 480                                             "management to work nicely.",
 481                             MUIA_Cycle_Entries, overridepowerstrings,
 482                             MUIA_Cycle_Active, overridepower,
 483                             End,
 484                         End,
 485                     Child, HGroup,
 486                         Child, VGroup,
 487                             MUIA_ShortHelp, "This is a list of supported languages\n"
 488                                             "for the USB device. It's not manadatory\n"
 489                                             "and in fact cheap devices won't even use\n"
 490                                             "any string descriptors in their firmware.",
 491                             Child, data->langlvobj = ListviewObject,
 492                                 MUIA_FrameTitle, "Supported languages",
 493                                 MUIA_Listview_List, ListObject,
 494                                     ReadListFrame,
 495                                     End,
 496                                 End,
 497                             Child, HGroup,
 498                                 Child, LabelB("Current language:"),
 499                                 Child, TextObject,
 500                                     TextFrame,
 501                                     MUIA_Background, MUII_TextBack,
 502                                     MUIA_Text_Contents, psdNumToStr(NTS_LANGID, devcurrlang, "<unknown>"),
 503                                     End,
 504                                 End,
 505                             End,
 506                         Child, HGroup,
 507                             MUIA_ShortHelp, "USB devices are able to support\n"
 508                                             "different configurations. However,\n"
 509                                             "this is really rare.",
 510                             MUIA_FrameTitle, "Configurations",
 511                             Child, data->cfglvobj = FloattextObject,
 512                                 ReadListFrame,
 513                                 MUIA_Floattext_Text, textbuf3,
 514                                 End,
 515                             End,
 516                         End,
 517                     Child, HGroup,
 518                         Child, ListviewObject,
 519                             MUIA_ShortHelp, "This is a list of so called interfaces\n"
 520                                             "the device has. USB devices can be built\n"
 521                                             "as compound, so that each interface has\n"
 522                                             "different functions. Each interface can be\n"
 523                                             "bound to a different class.",
 524                             MUIA_FrameTitle, "Interfaces",
 525                             MUIA_Listview_List, data->iflvobj =
 526     NewObject(IconListClass->mcc_Class, 0, MUIA_ContextMenu, data->classpopup, InputListFrame, MUIA_List_MinLineHeight, 16, MUIA_List_Format, "BAR,BAR,BAR,BAR,BAR,BAR,", MUIA_List_Title, TRUE,MUIA_List_DisplayHook, &data->InterfaceDisplayHook, TAG_END),
 527                             End,
 528                         End,
 529                     Child, HGroup,
 530                         MUIA_Group_SameWidth, TRUE,
 531                         Child, data->clsscanobj = TextObject,
 532                             MUIA_ShortHelp, "Clicking on this button will start a class scan. This means that\n"
 533                                             "each device will be examined if it matches some of the standard\n"
 534                                             "classes in the system. In this case, a binding will be established\n"
 535                                             "and the functionality will be added to the system automatically.",
 536                             ButtonFrame,
 537                             MUIA_Background, MUII_ButtonBack,
 538                             MUIA_CycleChain, 1,
 539                             MUIA_InputMode, MUIV_InputMode_RelVerify,
 540                             MUIA_Text_Contents, "\33c Class Scan ",
 541                             End,
 542                         Child, data->unbindobj = TextObject,
 543                             MUIA_ShortHelp, "Manually removes an interface binding. This can be\n"
 544                                             "useful to temporarily deactivate a device.\n"
 545                                             "Use 'Class Scan' to reactivate the binding.",
 546                             MUIA_Disabled, TRUE,
 547                             ButtonFrame,
 548                             MUIA_Background, MUII_ButtonBack,
 549                             MUIA_CycleChain, 1,
 550                             MUIA_InputMode, MUIV_InputMode_RelVerify,
 551                             MUIA_Text_Contents, "\33c Release Binding ",
 552                             End,
 553                         Child, data->cfgobj = TextObject,
 554                             MUIA_ShortHelp, "If there is an interface binding and the class\n"
 555                                             "supports a configuration GUI. Clicking on this\n"
 556                                             "button will open the interface preferences window.\n\n"
 557                                             "Note well, that the corrsponding button for the\n"
 558                                             "device binding settings can be found in the device\n"
 559                                             "list window.",
 560                             MUIA_Disabled, TRUE,
 561                             ButtonFrame,
 562                             MUIA_Background, MUII_ButtonBack,
 563                             MUIA_CycleChain, 1,
 564                             MUIA_InputMode, MUIV_InputMode_RelVerify,
 565                             MUIA_Text_Contents, "\33c Settings ",
 566                             End,
 567                         End,
 568                     End;
 569                 psdFreeVec(textbuf1);
 570                 if(data->contents)
 571                 {
 572                     set(obj, MUIA_Window_IsSubWindow, FALSE);
 573                     set(obj, MUIA_Window_Title, devidstr);
 574                     get(obj, MUIA_Window_RootObject, &oldroot);
 575                     set(obj, MUIA_Window_RootObject, data->contents);
 576                     DoMethod(oldroot, OM_DISPOSE);
 577                     set(obj, MUIA_Window_ID, MAKE_ID('D','I','N','F'));
 578                     if(devlangarray)
 579                     {
 580                         UWORD *wptr = devlangarray;
 581                         while(*wptr)
 582                         {
 583                             DoMethod(data->langlvobj, MUIM_List_InsertSingle,
 584                                      psdNumToStr(NTS_LANGID, (ULONG) *wptr++, "<unknown>"), MUIV_List_Insert_Bottom);
 585                         }
 586                     } else {
 587                         DoMethod(data->langlvobj, MUIM_List_InsertSingle, "<none>", MUIV_List_Insert_Bottom);
 588                     }
 589                     pc = cfgs->lh_Head;
 590                     while(pc->ln_Succ)
 591                     {
 592                         psdGetAttrs(PGA_CONFIG, pc,
 593                                     CA_InterfaceList, &ifs,
 594                                     TAG_END);
 595
 596                         pif = ifs->lh_Head;
 597                         while(pif->ln_Succ)
 598                         {
 599                             iflnode = AllocIfEntry(data, pif, FALSE);
 600                             if(iflnode)
 601                             {
 602                                 DoMethod(data->iflvobj, MUIM_List_InsertSingle, iflnode, MUIV_List_Insert_Bottom);
 603                             }
 604                             psdGetAttrs(PGA_INTERFACE, pif,
 605                                         IFA_AlternateIfList, &altiflist,
 606                                         TAG_END);
 607                             altpif = altiflist->lh_Head;
 608                             while(altpif->ln_Succ)
 609                             {
 610                                 iflnode = AllocIfEntry(data, altpif, TRUE);
 611                                 if(iflnode)
 612                                 {
 613                                     DoMethod(data->iflvobj, MUIM_List_InsertSingle, iflnode, MUIV_List_Insert_Bottom);
 614                                 }
 615
 616                                 altpif = altpif->ln_Succ;
 617                             }
 618                             pif = pif->ln_Succ;
 619                         }
 620                         pc = pc->ln_Succ;
 621                     }
 622
 623                     DoMethod(data->clsscanobj, MUIM_Notify, MUIA_Pressed, FALSE,
 624                              obj, 1, MUIM_DevWin_Dev_Bind);
 625                     DoMethod(data->unbindobj, MUIM_Notify, MUIA_Pressed, FALSE,
 626                              obj, 1, MUIM_DevWin_If_Unbind);
 627                     DoMethod(data->cfgobj, MUIM_Notify, MUIA_Pressed, FALSE,
 628                              obj, 2, MUIM_DevWin_If_Config);
 629                     DoMethod(data->iflvobj, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
 630                              obj, 1, MUIM_DevWin_If_Config);
 631                     DoMethod(data->iflvobj, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
 632                              obj, 1, MUIM_DevWin_If_Activate);
 633                     DoMethod(data->iflvobj, MUIM_Notify, MUIA_ContextMenuTrigger, MUIV_EveryTime,
 634                              obj, 2, MUIM_DevWin_If_FBind, MUIV_TriggerValue);
 635                     DoMethod(data->cwnameobj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 636                              obj, 1, MUIM_DevWin_SetCustomName);
 637                     DoMethod(data->changenameobj, MUIM_Notify, MUIA_Pressed, FALSE,
 638                              obj, 1, MUIM_DevWin_SetCustomName);
 639                     DoMethod(data->resetnameobj, MUIM_Notify, MUIA_Pressed, FALSE,
 640                              obj, 1, MUIM_DevWin_ResetCustomName);
 641                     DoMethod(data->dontpopupobj, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
 642                              obj, 1, MUIM_DevWin_PopupInhibitChg);
 643                     DoMethod(data->noclassbindobj, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
 644                              obj, 1, MUIM_DevWin_NoClassBindChg);
 645                     DoMethod(data->overridepowerobj, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
 646                              obj, 1, MUIM_DevWin_PowerInfoChg);
 647                 } else {
 648                     CoerceMethod(cl, obj, OM_DISPOSE);
 649                     return((IPTR) NULL);
 650                 }
 651             }
 652             return((IPTR) obj);
 653         }
 654
 655         case OM_DISPOSE:
 656         {
 657             struct IfListEntry *iflnode;
 658             if(data->dlnode)
 659             {
 660                 if(data->dlnode->infowindow)
 661                 {
 662                     data->dlnode->infowindow = NULL;
 663                 }
 664                 data->dlnode->devdata = NULL;
 665             }
 666             if(data->classpopup)
 667             {
 668                 DoMethod(data->classpopup, OM_DISPOSE);
 669                 data->classpopup = NULL;
 670             }
 671             iflnode = (struct IfListEntry *) data->iflist.lh_Head;
 672             while(iflnode->node.ln_Succ)
 673             {
 674                 FreeIfEntry(data, iflnode);
 675                 iflnode = (struct IfListEntry *) data->iflist.lh_Head;
 676             }
 677             data->dlnode = NULL;
 678             break;
 679         }
 680
 681         case MUIM_DevWin_Dev_Bind:
 682             psdClassScan();
 683             DoMethod(obj, MUIM_DevWin_If_Activate);
 684             DoMethod(data->iflvobj, MUIM_List_Redraw, MUIV_List_Redraw_All);
 685             return(TRUE);
 686
 687         case MUIM_DevWin_If_Activate:
 688         {
 689             APTR binding;
 690             struct Node *puc;
 691             IPTR hascfggui = FALSE;
 692             struct Library *UsbClsBase;
 693             struct IfListEntry *iflnode;
 694
 695             DoMethod(data->iflvobj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &iflnode);
 696             if(iflnode)
 697             {
 698                 psdGetAttrs(PGA_INTERFACE, iflnode->pif,
 699                             IFA_Binding, &binding,
 700                             IFA_BindingClass, &puc,
 701                             TAG_END);
 702                 set(data->unbindobj, MUIA_Disabled, !binding);
 703                 if(binding && puc)
 704                 {
 705                     psdGetAttrs(PGA_USBCLASS, puc,
 706                         UCA_ClassBase, &UsbClsBase,
 707                         TAG_END);
 708                     usbGetAttrs(UGA_CLASS, NULL,
 709                         UCCA_HasBindingCfgGUI, &hascfggui,
 710                         TAG_END);
 711                     set(data->cfgobj, MUIA_Disabled, !hascfggui);
 712                 } else {
 713                     set(data->cfgobj, MUIA_Disabled, TRUE);
 714                 }
 715                 set(data->iflvobj, MUIA_ContextMenu, data->classpopup);
 716             } else {
 717                 set(data->unbindobj, MUIA_Disabled, TRUE);
 718                 set(data->cfgobj, MUIA_Disabled, TRUE);
 719                 set(data->iflvobj, MUIA_ContextMenu, NULL);
 720             }
 721             return(TRUE);
 722         }
 723
 724         case MUIM_DevWin_If_Unbind:
 725         {
 726             APTR binding;
 727             struct IfListEntry *iflnode;
 728
 729             DoMethod(data->iflvobj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &iflnode);
 730             if(iflnode)
 731             {
 732                 psdGetAttrs(PGA_INTERFACE, iflnode->pif,
 733                             IFA_Binding, &binding,
 734                             TAG_END);
 735                 if(binding)
 736                 {
 737                     psdReleaseIfBinding(iflnode->pif);
 738                     set(data->unbindobj, MUIA_Disabled, TRUE);
 739                     set(data->cfgobj, MUIA_Disabled, TRUE);
 740                     DoMethod(data->iflvobj, MUIM_List_Redraw, MUIV_List_Redraw_All);
 741                 }
 742             }
 743             return(TRUE);
 744         }
 745
 746         case MUIM_DevWin_If_Config:
 747         {
 748             APTR binding;
 749             struct Node *puc;
 750             struct Library *UsbClsBase;
 751             struct IfListEntry *iflnode;
 752
 753             DoMethod(data->iflvobj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &iflnode);
 754             if(iflnode)
 755             {
 756                 psdGetAttrs(PGA_INTERFACE, iflnode->pif,
 757                             IFA_Binding, &binding,
 758                             IFA_BindingClass, &puc,
 759                             TAG_END);
 760                 if(binding && puc)
 761                 {
 762                     psdGetAttrs(PGA_USBCLASS, puc,
 763                                 UCA_ClassBase, &UsbClsBase,
 764                                 TAG_END);
 765                     usbDoMethod(UCM_OpenBindingCfgWindow, binding);
 766                 }
 767             }
 768             return(TRUE);
 769         }
 770
 771         case MUIM_DevWin_If_FBind:
 772         {
 773             Object *mi = (Object *) (((IPTR *) msg)[1]);
 774             STRPTR name = NULL;
 775             STRPTR devid = NULL;
 776             STRPTR ifid = NULL;
 777             STRPTR devname = NULL;
 778             BOOL clever;
 779             struct IfListEntry *iflnode;
 780
 781             DoMethod(data->iflvobj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &iflnode);
 782             if(iflnode)
 783             {
 784                 get(mi, MUIA_Menuitem_Title, &name);
 785                 if(!strcmp(name, "None"))
 786                 {
 787                     name = NULL;
 788                 }
 789                 psdGetAttrs(PGA_DEVICE, data->pd,
 790                             DA_ProductName, &devname,
 791                             DA_IDString, &devid,
 792                             TAG_END);
 793                 psdGetAttrs(PGA_INTERFACE, iflnode->pif,
 794                             IFA_IDString, &ifid,
 795                             TAG_END);
 796                 if(name)
 797                 {
 798                     clever = MUI_RequestA(_app(obj), obj, 0, NULL, "I'm not dumb!|I'll reconsider",
 799                                          "You are about to establish a forced \33binterface\33n\n"
 800                                          "binding. As most people are not capable of reading the\n"
 801                                          "manual and they cause more harm than good,\n"
 802                                          "please make sure you know, what you're doing\n"
 803                                          "and not breaking things (and then bugger me with\n"
 804                                          "silly emails).", NULL);
 805                     if(!clever)
 806                     {
 807                         return(FALSE);
 808                     }
 809                 }
 810                 if(psdSetForcedBinding(name, devid, ifid))
 811                 {
 812                     if(name)
 813                     {
 814                         psdAddErrorMsg(RETURN_OK, "Trident", "Forcing interface binding of %s to %s.", devname, name);
 815                     } else {
 816                         psdAddErrorMsg(RETURN_OK, "Trident", "Removed forced interface binding of %s.", devname);
 817                     }
 818                 }
 819             }
 820
 821             return(TRUE);
 822         }
 823
 824         case MUIM_DevWin_SetCustomName:
 825         {
 826             APTR pic;
 827             STRPTR devidstr = NULL;
 828             STRPTR oldname = NULL;
 829             CONST_STRPTR newname = "";
 830             STRPTR newnewname;
 831             psdGetAttrs(PGA_DEVICE, data->pd,
 832                         DA_IDString, &devidstr,
 833                         DA_ProductName, &oldname,
 834                         TAG_END);
 835             if(!devidstr)
 836             {
 837                 return(FALSE);
 838             }
 839             get(data->cwnameobj, MUIA_String_Contents, &newname);
 840             if(!(*newname))
 841             {
 842                 newname = "Empty";
 843             }
 844             if(oldname && !strcmp(newname, oldname))
 845             {
 846                 return(FALSE);
 847             }
 848             pic = psdGetUsbDevCfg("Trident", devidstr, NULL);
 849             if(!pic)
 850             {
 851                 psdSetUsbDevCfg("Trident", devidstr, NULL, NULL);
 852                 pic = psdGetUsbDevCfg("Trident", devidstr, NULL);
 853             }
 854             if(pic)
 855             {
 856                 if(psdAddStringChunk(pic, IFFCHNK_NAME, newname))
 857                 {
 858                     psdAddErrorMsg(RETURN_OK, "Trident", "Set new custom name '%s'.", newname);
 859                     newnewname = psdCopyStr(newname);
 860                     if(newnewname)
 861                     {
 862                         psdSetAttrs(PGA_DEVICE, data->pd,
 863                             DA_ProductName, newnewname,
 864                             TAG_END);
 865                         if (oldname)
 866                             psdFreeVec(oldname);
 867                     }
 868                 }
 869             }
 870             set(data->cwnameobj, MUIA_String_Contents, newname);
 871             DoMethod(data->dlnode->adata->devlistobj, MUIM_List_Redraw, MUIV_List_Redraw_All);
 872             return(TRUE);
 873         }
 874
 875         case MUIM_DevWin_ResetCustomName:
 876         {
 877             APTR pic;
 878             STRPTR devidstr = NULL;
 879             STRPTR oldname = NULL;
 880             STRPTR origname = NULL;
 881             STRPTR newname;
 882             psdGetAttrs(PGA_DEVICE, data->pd,
 883                         DA_IDString, &devidstr,
 884                         DA_ProductName, &oldname,
 885                         DA_OrigProductName, &origname,
 886                         TAG_END);
 887             if(!devidstr)
 888             {
 889                 return(FALSE);
 890             }
 891             pic = psdGetUsbDevCfg("Trident", devidstr, NULL);
 892             if(pic)
 893             {
 894                 if(psdRemCfgChunk(pic, IFFCHNK_NAME))
 895                 {
 896                     psdAddErrorMsg(RETURN_OK, "Trident", "Custom name '%s' removed.", oldname);
 897                     if(origname)
 898                     {
 899                         newname = psdCopyStr(origname);
 900                         if(newname)
 901                         {
 902                             psdSetAttrs(PGA_DEVICE, data->pd,
 903                                 DA_ProductName, newname,
 904                                 TAG_END);
 905                             psdFreeVec(oldname);
 906                         }
 907                     }
 908                 }
 909             }
 910             psdGetAttrs(PGA_DEVICE, data->pd,
 911                         DA_ProductName, &oldname,
 912                         TAG_END);
 913             set(data->cwnameobj, MUIA_String_Contents, oldname);
 914             DoMethod(data->dlnode->adata->devlistobj, MUIM_List_Redraw, MUIV_List_Redraw_All);
 915             return(TRUE);
 916         }
 917
 918         case MUIM_DevWin_PopupInhibitChg:
 919         case MUIM_DevWin_NoClassBindChg:
 920         case MUIM_DevWin_PowerInfoChg:
 921         {
 922             IPTR dontpopup = 0;
 923             IPTR noclassbind = 0;
 924             IPTR overridepower = 0;
 925             get(data->dontpopupobj, MUIA_Selected, &dontpopup);
 926             get(data->noclassbindobj, MUIA_Selected, &noclassbind);
 927             get(data->overridepowerobj, MUIA_Cycle_Active, &overridepower);
 928
 929             psdSetAttrs(PGA_DEVICE, data->pd,
 930                         DA_InhibitPopup, dontpopup,
 931                         DA_InhibitClassBind, noclassbind,
 932                         DA_OverridePowerInfo, overridepower,
 933                         TAG_END);
 934             return(TRUE);
 935         }
 936
 937     }
 938     return(DoSuperMethodA(cl,obj,msg));
 939     AROS_USERFUNC_EXIT
 940 }
 941 /* \\\ */