workbench/tools/SysExplorer/main.c

   1 /*
   2     Copyright (C) 2013, The AROS Development Team.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/memory.h>
   9 #include <hidd/ata.h>
  10 #include <hidd/hidd.h>
  11 #include <libraries/asl.h>
  12 #include <mui/NListtree_mcc.h>
  13 #include <mui/NListview_mcc.h>
  14 #include <utility/tagitem.h>
  15 #include <utility/hooks.h>
  16
  17 #include <proto/alib.h>
  18 #include <proto/dos.h>
  19 #include <proto/exec.h>
  20 #include <proto/muimaster.h>
  21 #include <proto/oop.h>
  22 #include <proto/utility.h>
  23 #include <proto/intuition.h>
  24
  25 #include <ctype.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include "locale.h"
  30 #include "classes.h"
  31
  32 #include <aros/debug.h>
  33
  34 #define APPNAME "SysExplorer"
  35 #define VERSION "SysExplorer 0.2"
  36
  37 struct ObjectUserData
  38 {
  39     OOP_Object *obj;
  40     struct MUI_CustomClass *winClass;
  41     Object *win;
  42 };
  43
  44 struct InsertObjectMsg
  45 {
  46     OOP_Object *obj;
  47     struct MUI_CustomClass *winClass;
  48 };
  49
  50 struct ClassHandlers
  51 {
  52     CONST_STRPTR classID;
  53     struct MUI_CustomClass **muiClass;
  54     void (*enumFunc)(OOP_Object *obj, struct MUI_NListtree_TreeNode *parent);
  55 };
  56
  57 static const struct ClassHandlers *FindClassHandler(OOP_Object *obj);
  58
  59 const char version[] = "$VER: " VERSION " (" ADATE ")\n";
  60
  61 static Object *app, *main_window, *property_window, *hidd_tree;
  62 static Object *property_menu, *expand_menu, *collapse_menu, *quit_menu;
  63
  64 OOP_AttrBase HiddAttrBase;
  65 OOP_AttrBase HWAttrBase;
  66 OOP_AttrBase HiddATABusAB;
  67 OOP_AttrBase HiddATAUnitAB;
  68
  69 const struct OOP_ABDescr abd[] =
  70 {
  71     {IID_Hidd        , &HiddAttrBase },
  72     {IID_HW          , &HWAttrBase   },
  73     {IID_Hidd_ATABus , &HiddATABusAB },
  74     {IID_Hidd_ATAUnit, &HiddATAUnitAB},
  75     {NULL            , NULL          }
  76 };
  77
  78 /* Here we have enumerators for different device and subsystem classes */
  79
  80 static void addATAUnit(OOP_Object *dev, ULONG attrID, struct MUI_NListtree_TreeNode *parent)
  81 {
  82     OOP_Object *unit = NULL;
  83
  84     OOP_GetAttr(dev, attrID, (IPTR *)&unit);
  85     if (unit)
  86     {
  87         struct InsertObjectMsg msg =
  88         {
  89             .obj      = unit,
  90             .winClass = ATAUnitWindow_CLASS
  91         };
  92         CONST_STRPTR name;
  93
  94         OOP_GetAttr(unit, aHidd_ATAUnit_Model, (IPTR *)&name);
  95         DoMethod(hidd_tree, MUIM_NListtree_Insert, name, &msg,
  96                  parent, MUIV_NListtree_Insert_PrevNode_Tail, 0);
  97     }
  98 }
  99
 100 static void ataUnitsEnum(OOP_Object *dev, struct MUI_NListtree_TreeNode *parent)
 101 {
 102     addATAUnit(dev, aHidd_ATABus_Master, parent);
 103     addATAUnit(dev, aHidd_ATABus_Slave , parent);
 104 }
 105
 106 AROS_UFH3S(BOOL, enumFunc,
 107     AROS_UFHA(struct Hook *, h,  A0),
 108     AROS_UFHA(OOP_Object*, obj, A2),
 109     AROS_UFHA(void *, parent, A1))
 110 {
 111     AROS_USERFUNC_INIT
 112
 113     CONST_STRPTR name = NULL;
 114     struct MUI_NListtree_TreeNode *tn;
 115     ULONG flags = 0;
 116     struct InsertObjectMsg msg =
 117     {
 118         .obj = obj,
 119         .winClass = NULL
 120     };
 121     const struct ClassHandlers *clHandlers = FindClassHandler(obj);
 122
 123     /* This is either HW or HIDD subclass */
 124     OOP_GetAttr(obj, aHW_ClassName, (IPTR *)&name);
 125     if (!name)
 126         OOP_GetAttr(obj, aHidd_HardwareName, (IPTR *)&name);
 127
 128     if (clHandlers)
 129     {
 130         if (clHandlers->muiClass)
 131             msg.winClass = *(clHandlers->muiClass);
 132         if (clHandlers->enumFunc)
 133             flags = TNF_LIST|TNF_OPEN;
 134     }
 135
 136     tn = (APTR)DoMethod(hidd_tree, MUIM_NListtree_Insert, name, &msg,
 137                         parent, MUIV_NListtree_Insert_PrevNode_Tail, flags);
 138     D(bug("Inserted TreeNode 0x%p <%s> UserData 0x%p\n", tn, tn->tn_Name, tn->tn_User));
 139
 140     /* If we have enumerator for this class, call it now */
 141     if (clHandlers && clHandlers->enumFunc)
 142         clHandlers->enumFunc(obj, tn);
 143
 144     return FALSE; /* Continue enumeration */
 145
 146     AROS_USERFUNC_EXIT
 147 }
 148
 149 static const struct Hook enum_hook =
 150 {
 151     .h_Entry = enumFunc
 152 };
 153
 154 static void hwEnum(OOP_Object *obj, struct MUI_NListtree_TreeNode *tn)
 155 {
 156     HW_EnumDrivers(obj, (struct Hook *)&enum_hook, tn);
 157 }
 158
 159 /*
 160  * This table lists handlers for known public classes.
 161  * It specifies information window class, as well as function
 162  * to enumerate children objects for the class.
 163  *
 164  * For proper operation CLIDs in this table should
 165  * be sorted from subclasses to superclasses.
 166  */
 167 static const struct ClassHandlers classHandlers[] =
 168 {
 169     {CLID_HW_Root    , &ComputerWindow_CLASS, hwEnum      },
 170     {CLID_HW         , NULL                 , hwEnum      },
 171     {CLID_Hidd_ATABus, &ATAWindow_CLASS     , ataUnitsEnum},
 172     {CLID_Hidd       , &GenericWindow_CLASS , NULL        },
 173     {NULL            , NULL                 , NULL        }
 174 };
 175
 176 static const struct ClassHandlers *FindClassHandler(OOP_Object *obj)
 177 {
 178     unsigned int i;
 179
 180     for (i = 0; classHandlers[i].classID; i++)
 181     {
 182         OOP_Class *cl;
 183
 184         for (cl = OOP_OCLASS(obj); cl ; cl = cl->superclass)
 185         {
 186             if (!strcmp(cl->ClassNode.ln_Name, classHandlers[i].classID))
 187                 return &classHandlers[i];
 188         }
 189     }
 190     return NULL;
 191 }
 192
 193 AROS_UFH3S(void, closeFunc,
 194     AROS_UFHA(struct Hook *, h,  A0),
 195     AROS_UFHA(Object*, obj, A2),
 196     AROS_UFHA(struct ObjectUserData **, msg, A1))
 197 {
 198     AROS_USERFUNC_INIT
 199
 200     D(bug("closeFunc address 0x%p\n", closeFunc));
 201     D(bug("Close window 0x%p, ObjectUserData 0x%p\n", obj, *msg));
 202
 203     SET(obj, MUIA_Window_Open, FALSE);
 204     DoMethod(app, OM_REMMEMBER, obj);
 205     DoMethod(app, MUIM_Application_PushMethod, obj, 1, OM_DISPOSE);
 206
 207     (*msg)->win = NULL;
 208
 209     AROS_USERFUNC_EXIT
 210 };
 211
 212 static const struct Hook close_hook =
 213 {
 214     .h_Entry = closeFunc
 215 };
 216
 217 AROS_UFH3S(APTR, constructFunc,
 218     AROS_UFHA(struct Hook *, h,  A0),
 219     AROS_UFHA(Object*, obj, A2),
 220     AROS_UFHA(struct MUIP_NListtree_ConstructMessage *, msg, A1))
 221 {
 222     AROS_USERFUNC_INIT
 223
 224     struct InsertObjectMsg *insertMsg = msg->UserData;
 225     struct ObjectUserData *data = AllocPooled(msg->MemPool, sizeof(struct ObjectUserData));
 226
 227     D(bug("%s: insertMsg 0x%p ObjectUserData 0x%p\n", msg->Name, insertMsg, data));
 228     if (data)
 229     {
 230         data->obj      = insertMsg->obj;
 231         data->winClass = insertMsg->winClass;
 232         data->win      = NULL;
 233     }
 234     return data;
 235
 236     AROS_USERFUNC_EXIT
 237 }
 238
 239 AROS_UFH3S(void, destructFunc,
 240     AROS_UFHA(struct Hook *, h,  A0),
 241     AROS_UFHA(Object*, obj, A2),
 242     AROS_UFHA(struct MUIP_NListtree_DestructMessage *, msg, A1))
 243 {
 244     AROS_USERFUNC_INIT
 245
 246     FreePooled(msg->MemPool, msg->UserData, sizeof(struct ObjectUserData));
 247
 248     AROS_USERFUNC_EXIT
 249 }
 250
 251 static const struct Hook constructHook =
 252 {
 253     .h_Entry = constructFunc
 254 };
 255
 256 static const struct Hook destructHook =
 257 {
 258     .h_Entry = destructFunc
 259 };
 260
 261 AROS_UFH3S(void, propertyFunc,
 262     AROS_UFHA(struct Hook *, h,  A0),
 263     AROS_UFHA(Object*, obj, A2),
 264     AROS_UFHA(struct MUI_NListtree_TreeNode **, tn, A1))
 265 {
 266     AROS_USERFUNC_INIT
 267
 268     struct MUI_NListtree_TreeNode *node = *tn;
 269     struct ObjectUserData *data;
 270
 271     if (node == NULL)
 272     {
 273         /* if we were called from menu we must 1st find the current entry */
 274         node = (struct MUI_NListtree_TreeNode *)XGET(hidd_tree, MUIA_NListtree_Active);
 275     }
 276
 277     if (node == NULL)
 278     {
 279         /* Do nothing if still no current entry */
 280         return;
 281     }
 282
 283     data = node->tn_User;
 284     D(bug("propertyFunc called: TreeNode 0x%p <%s> UserData 0x%p\n", node, node->tn_Name, data));
 285     D(bug("Window 0x%p\n", data->win));
 286
 287     if (data->win)
 288     {
 289         /* The window is already open, show it to the user */
 290         DoMethod(data->win, MUIM_Window_ToFront);
 291         SET(data->win, MUIA_Window_Activate, TRUE);
 292         return;
 293     }
 294
 295     if (data->winClass)
 296     {
 297         /* We have information window class. Open the window. */
 298         data->win = NewObject(data->winClass->mcc_Class, NULL,
 299                               MUIA_PropertyWin_Object, (IPTR)data->obj,
 300                               TAG_DONE);
 301         D(bug("Created window 0x%p\n", data->win));
 302
 303         if (data->win)
 304         {
 305             DoMethod(app, OM_ADDMEMBER, data->win);
 306             DoMethod(data->win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 307                      data->win, 3,
 308                      MUIM_CallHook, &close_hook, data);
 309             SET(data->win, MUIA_Window_Open, TRUE);
 310         }
 311     }
 312
 313     AROS_USERFUNC_EXIT
 314 }
 315
 316 static const struct Hook property_hook =
 317 {
 318     .h_Entry = propertyFunc
 319 };
 320
 321 static BOOL GUIinit()
 322 {
 323     BOOL retval = FALSE;
 324
 325     app = ApplicationObject,
 326         MUIA_Application_Title,         (IPTR)APPNAME,
 327         MUIA_Application_Version,       (IPTR)VERSION,
 328         MUIA_Application_Copyright,     (IPTR)"(C) 2013, The AROS Development Team",
 329         MUIA_Application_Author,        (IPTR)"Pavel Fedin",
 330         MUIA_Application_Base,          (IPTR)APPNAME,
 331         MUIA_Application_Description,   __(MSG_DESCRIPTION),
 332
 333         MUIA_Application_Menustrip, (IPTR)(MenuitemObject,
 334             MUIA_Family_Child, (IPTR)(MenuitemObject,
 335                 MUIA_Menuitem_Title, __(MSG_MENU_PROJECT),
 336                 MUIA_Family_Child, (IPTR)(property_menu = MenuitemObject,
 337                     MUIA_Menuitem_Title, (IPTR)"Properties",
 338                 End),
 339                 MUIA_Family_Child, (IPTR)(expand_menu = MenuitemObject,
 340                     MUIA_Menuitem_Title, (IPTR)"Expand All",
 341                 End),
 342                 MUIA_Family_Child, (IPTR)(collapse_menu = MenuitemObject,
 343                     MUIA_Menuitem_Title, (IPTR)"Collapse All",
 344                 End),
 345                 MUIA_Family_Child, (IPTR)(quit_menu = MenuitemObject,
 346                     MUIA_Menuitem_Title, __(MSG_MENU_QUIT),
 347                 End),
 348             End),
 349         End),
 350
 351         SubWindow, (IPTR)(main_window = WindowObject,
 352             MUIA_Window_Title,  __(MSG_WINTITLE),
 353             MUIA_Window_ID, MAKE_ID('S', 'Y', 'E', 'X'),
 354             WindowContents, (IPTR)(HGroup,
 355                 Child, (IPTR)(NListviewObject,
 356                     MUIA_NListview_NList, (IPTR)(hidd_tree = NListtreeObject,
 357                         ReadListFrame,
 358                         MUIA_CycleChain, TRUE,
 359                         MUIA_NListtree_ConstructHook, (IPTR)&constructHook,
 360                         MUIA_NListtree_DestructHook, (IPTR)&destructHook,
 361                         MUIA_NListtree_DragDropSort, FALSE, /* forbid sorting by drag'n'drop */
 362                     End),
 363                 End),
 364             End),
 365         End),
 366     End;
 367
 368     if (app)
 369     {
 370         OOP_Object *hwRoot = OOP_NewObject(NULL, CLID_HW_Root, NULL);
 371
 372         if (hwRoot)
 373         {
 374             /* This will kick our recursive enumeration into action */
 375             CALLHOOKPKT((struct Hook *)&enum_hook, hwRoot, MUIV_NListtree_Insert_ListNode_Root);
 376         }
 377
 378         /* Quit application if the main window's closegadget or the esc key is pressed. */
 379         DoMethod(main_window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 380                  app, 2,
 381                  MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 382
 383         DoMethod(property_window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 384                  property_window, 3,
 385                  MUIM_Set, MUIA_Window_Open, FALSE);
 386
 387
 388         DoMethod(property_menu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 389                  app, 3,
 390                  MUIM_CallHook, &property_hook, 0);
 391
 392         DoMethod(expand_menu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 393                  hidd_tree, 4,
 394                  MUIM_NListtree_Open, MUIV_NListtree_Open_ListNode_Root, MUIV_NListtree_Open_TreeNode_All, 0);
 395
 396         DoMethod(collapse_menu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 397                  hidd_tree, 4,
 398                  MUIM_NListtree_Close, MUIV_NListtree_Close_ListNode_Root, MUIV_NListtree_Close_TreeNode_All, 0);
 399
 400         DoMethod(quit_menu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
 401                  app, 2,
 402                  MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 403
 404         DoMethod(hidd_tree, MUIM_Notify, MUIA_NListtree_DoubleClick, MUIV_EveryTime,
 405                  app, 3,
 406                  MUIM_CallHook, &property_hook, MUIV_TriggerValue);
 407
 408         retval = TRUE;
 409     }
 410
 411     return retval;
 412 }
 413
 414 int __nocommandline = 1;
 415
 416 int main(void)
 417 {
 418     if (!Locale_Initialize())
 419         return 20;
 420
 421     if (!OOP_ObtainAttrBases(abd))
 422     {
 423         Locale_Deinitialize();
 424         return 20;
 425     }
 426
 427     if (GUIinit())
 428     {
 429         SET(main_window, MUIA_Window_Open, TRUE);
 430
 431         if (XGET(main_window, MUIA_Window_Open))
 432         {
 433             DoMethod(app, MUIM_Application_Execute);
 434             SET(main_window, MUIA_Window_Open, FALSE);
 435         }
 436
 437         DisposeObject(app);
 438     }
 439
 440     OOP_ReleaseAttrBases(abd);
 441
 442     Locale_Deinitialize();
 443     return 0;
 444 }