scout/source/classes/scout_oop.c

   1 /**
   2  * Scout - The Amiga System Monitor
   3  *
   4  *------------------------------------------------------------------
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  *------------------------------------------------------------------
  21  *
  22  * @author Andreas Gelhausen
  23  * @author Richard Körber <rkoerber@gmx.de>
  24  * @author Pavel Fedin <pavel.fedin@mail.ru>
  25  */
  26
  27 #include "system_headers.h"
  28
  29 /* This class operates on AROS-specific data.
  30    On non-AROS systems oop.library and its classes do not exist,
  31    however it's possible to retrieve the data via network from the
  32    remote AROS machine */
  33
  34 #ifdef __AROS__
  35
  36 #include <oop/oop.h>
  37 #include <proto/oop.h>
  38
  39 struct Library *OOPBase;
  40 OOP_AttrBase MetaAttrBase;
  41
  42 #endif
  43
  44 struct OOPWinData {
  45     TEXT cwd_Title[WINDOW_TITLE_LENGTH];
  46     APTR cwd_ClassTree;
  47     APTR cwd_ClassText;
  48     APTR cwd_ClassCount;
  49     APTR cwd_RemoveButton;
  50     APTR cwd_MoreButton;
  51 };
  52
  53 struct OOPCallbackUserData {
  54     APTR ud_Tree;
  55     ULONG ud_Count;
  56 };
  57
  58 HOOKPROTONHNO(classtree_confunc, LONG, struct MUIP_NListtree_ConstructMessage *msg)
  59 {
  60     return AllocListEntry(msg->MemPool, msg->UserData, sizeof(struct OOPClassEntry));
  61 }
  62 MakeStaticHook(classtree_conhook, classtree_confunc);
  63
  64 HOOKPROTONHNO(classtree_desfunc, void, struct MUIP_NListtree_DestructMessage *msg)
  65 {
  66     FreeListEntry(msg->MemPool, &msg->UserData);
  67 }
  68 MakeStaticHook(classtree_deshook, classtree_desfunc);
  69
  70 HOOKPROTONHNO(classtree_dspfunc, void, struct MUIP_NListtree_DisplayMessage *msg)
  71 {
  72     if (msg->TreeNode != NULL) {
  73         struct OOPClassEntry *ce = msg->TreeNode->tn_User;
  74
  75         msg->Array[0] = ce->ce_Address;
  76         msg->Array[1] = ce->ce_ClassName;
  77         msg->Array[2] = ce->ce_Dispatcher;
  78         msg->Array[3] = ce->ce_CoerceDispatcher;
  79         msg->Array[4] = ce->ce_SuperDispatcher;
  80     } else {
  81         msg->Array[0] = txtAddress;
  82         msg->Array[1] = txtNodeName;
  83         msg->Array[2] = txtOOPDoMethod;
  84         msg->Array[3] = txtOOPCoerceMethod;
  85         msg->Array[4] = txtOOPDoSuperMethod;
  86         msg->Preparse[0] = (STRPTR)MUIX_B;
  87         msg->Preparse[1] = (STRPTR)MUIX_B;
  88         msg->Preparse[2] = (STRPTR)MUIX_B;
  89         msg->Preparse[3] = (STRPTR)MUIX_B;
  90         msg->Preparse[4] = (STRPTR)MUIX_B;
  91     }
  92 }
  93 MakeStaticHook(classtree_dsphook, classtree_dspfunc);
  94
  95 HOOKPROTONHNO(classtree_cmpfunc, LONG, struct MUIP_NListtree_CompareMessage *msg)
  96 {
  97     struct OOPClassEntry *ce1, *ce2;
  98     LONG cmp;
  99
 100     ce1 = (struct OOPClassEntry *)msg->TreeNode1->tn_User;
 101     ce2 = (struct OOPClassEntry *)msg->TreeNode2->tn_User;
 102
 103     cmp = stricmp(ce1->ce_SuperClassName, ce2->ce_SuperClassName);
 104     if (cmp == 0) cmp = stricmp(ce1->ce_ClassName, ce2->ce_ClassName);
 105
 106     return cmp;
 107 }
 108 MakeStaticHook(classtree_cmphook, classtree_cmpfunc);
 109
 110 HOOKPROTONHNO(classtree_findfunc, LONG, struct MUIP_NListtree_FindUserDataMessage *msg )
 111 {
 112     struct OOPClassEntry *ce;
 113
 114     ce = (struct OOPClassEntry *)msg->UserData;
 115
 116     if (ce) {
 117         return stricmp(msg->User, ce->ce_Address);
 118     } else {
 119         return ~0;
 120     }
 121 }
 122 MakeStaticHook(classtree_findhook, classtree_findfunc);
 123
 124
 125 STATIC void ReceiveList( void (* callback)( struct OOPClassEntry *ce, void *userData ),
 126                          void *userData )
 127 {
 128     struct OOPClassEntry *ce;
 129
 130     if ((ce = tbAllocVecPooled(globalPool, sizeof(struct OOPClassEntry))) != NULL) {
 131         if (SendDaemon("GetOOPClassList")) {
 132             while (ReceiveDecodedEntry(&ce, sizeof(struct OOPClassEntry))) {
 133                 callback(ce, userData);
 134             }
 135         }
 136
 137         tbFreeVecPooled(globalPool, ce);
 138     }
 139 }
 140
 141 STATIC void FormatAddress(STRPTR buf, APTR dispentry)
 142 {
 143     if (points2ram(dispentry)) {
 144         _snprintf(buf, ADDRESS_LENGTH, MUIX_PH "$%08lx" MUIX_PT, dispentry);
 145     } else {
 146         _snprintf(buf, ADDRESS_LENGTH, "$%08lx", dispentry);
 147     }
 148 }
 149
 150 STATIC void IterateList( void (* callback)( struct OOPClassEntry *ce, void *userData ),
 151                          void *userData )
 152 {
 153
 154 #ifdef __AROS__
 155
 156     OOP_Class *myclass;
 157
 158     struct OOP_InterfaceDescr my_if = {NULL, NULL, 0};
 159     struct TagItem mytags[] = {
 160         {aMeta_SuperID       , (IPTR)CLID_Root},
 161         {aMeta_InterfaceDescr, (IPTR)&my_if   },
 162         {aMeta_InstSize      , 0              },
 163         {TAG_DONE            , 0              }
 164     };
 165
 166     if ((myclass = OOP_NewObject(NULL, CLID_SIMeta, mytags)) != NULL) {
 167         struct List *clist;
 168         OOP_Class *cl;
 169         struct MinList tmplist;
 170         struct OOPClassEntry *ce;
 171
 172         NewList((struct List *)&tmplist);
 173
 174         OOP_AddClass(myclass);
 175
 176         Forbid();
 177
 178         clist = FindListOfNode(&myclass->ClassNode);
 179         ITERATE_LIST(clist, OOP_Class *, cl) {
 180             if (cl != myclass) {
 181                 if ((ce = AllocVec(sizeof(struct OOPClassEntry), MEMF_CLEAR)) != NULL) {
 182                     ce->ce_Addr = cl;
 183                     _snprintf(ce->ce_Address, sizeof(ce->ce_Address), "$%08lx", cl);
 184                     if (cl->superclass) {
 185                         stccpy(ce->ce_SuperClassName, (TEXT *)nonetest((STRPTR)cl->superclass->ClassNode.ln_Name), sizeof(ce->ce_SuperClassName));
 186                     } else {
 187                         stccpy(ce->ce_SuperClassName, (TEXT *)nonetest(NULL), sizeof(ce->ce_SuperClassName));
 188                     }
 189                     _snprintf(ce->ce_SuperClassAddress, sizeof(ce->ce_SuperClassAddress), "$%08lx", cl->superclass);
 190
 191                     FormatAddress(ce->ce_Dispatcher, cl->cl_DoMethod);
 192                     FormatAddress(ce->ce_CoerceDispatcher, cl->cl_CoerceMethod);
 193                     FormatAddress(ce->ce_SuperDispatcher, cl->cl_DoSuperMethod);
 194
 195                     stccpy(ce->ce_ClassName, (TEXT *)nonetest(cl->ClassNode.ln_Name), sizeof(ce->ce_ClassName));
 196
 197                     healstring(ce->ce_ClassName);
 198
 199                     AddTail((struct List *)&tmplist, (struct Node *)ce);
 200                 }
 201             }
 202         }
 203
 204         Permit();
 205
 206         ITERATE_LIST(&tmplist, struct OOPClassEntry *, ce) {
 207             callback(ce, userData);
 208         }
 209         FreeLinkedList((struct List *)&tmplist);
 210
 211         OOP_RemoveClass(myclass);
 212         OOP_DisposeObject((OOP_Object *)myclass);
 213     }
 214
 215 #endif
 216
 217 }
 218
 219 STATIC void UpdateCallback( struct OOPClassEntry *ce,
 220                             UNUSED void *userData )
 221 {
 222     struct OOPCallbackUserData *ud = (struct OOPCallbackUserData *)userData;
 223     struct MUI_NListtree_TreeNode *parent;
 224
 225     parent = (struct MUI_NListtree_TreeNode *)DoMethod(ud->ud_Tree, MUIM_NListtree_FindUserData, MUIV_NListtree_FindUserData_ListNode_Root, ce->ce_SuperClassAddress, MUIV_NListtree_FindUserData_Flag_StartNode);
 226     DoMethod(ud->ud_Tree, MUIM_NListtree_Insert, ce->ce_ClassName, ce, parent, MUIV_NListtree_Insert_PrevNode_Sorted, TNF_LIST | TNF_OPEN);
 227 }
 228
 229 INLINE STRPTR SkipFormat(STRPTR str)
 230 {
 231     if (strncmp(str, MUIX_PH, strlen(MUIX_PH)))
 232         return str;
 233     else
 234         return str + 2;
 235 }
 236
 237 STATIC void PrintCallback( struct OOPClassEntry *ce,
 238                            void *userData )
 239 {
 240     PrintFOneLine((BPTR)userData, txtOOPPrintLine, ce->ce_Address, ce->ce_SuperClassName,
 241                   SkipFormat(ce->ce_Dispatcher), SkipFormat(ce->ce_CoerceDispatcher), SkipFormat(ce->ce_SuperDispatcher), ce->ce_ClassName);
 242 }
 243
 244 STATIC void SendCallback( struct OOPClassEntry *ce,
 245                           UNUSED void *userData )
 246 {
 247     SendEncodedEntry(ce, sizeof(struct OOPClassEntry));
 248 }
 249
 250 STATIC ULONG mNew( struct IClass *cl,
 251                    Object *obj,
 252                    struct opSet *msg )
 253 {
 254     APTR classtree, classtext, classcount, updateButton, printButton, removeButton, moreButton, exitButton;
 255
 256     if ((obj = (Object *)DoSuperNew(cl, obj,
 257         MUIA_HelpNode, "OOPClass",
 258         MUIA_Window_ID, MakeID('O','O','P',' '),
 259         WindowContents, VGroup,
 260
 261             Child, (IPTR)MyNListtreeObject(&classtree, "BAR,BAR,BAR,BAR,BAR", &classtree_conhook, &classtree_deshook, &classtree_dsphook, &classtree_cmphook, &classtree_findhook, 1, TRUE),
 262
 263             Child, (IPTR)MyBelowListview(&classtext, &classcount),
 264
 265             Child, (IPTR)MyVSpace(4),
 266
 267             Child, HGroup, MUIA_Group_SameSize, TRUE,
 268                 Child, (IPTR)(updateButton = MakeButton(txtUpdate)),
 269                 Child, (IPTR)(printButton  = MakeButton(txtPrint)),
 270                 Child, (IPTR)(removeButton = MakeButton(txtRemove)),
 271                 Child, (IPTR)(moreButton   = MakeButton(txtMore)),
 272                 Child, (IPTR)(exitButton   = MakeButton(txtExit)),
 273             End,
 274         End,
 275         TAG_MORE, msg->ops_AttrList)) != NULL)
 276     {
 277         struct OOPWinData *cwd = INST_DATA(cl, obj);
 278         APTR parent;
 279
 280         cwd->cwd_ClassTree = classtree;
 281         cwd->cwd_ClassText = classtext;
 282         cwd->cwd_ClassCount = classcount;
 283         cwd->cwd_RemoveButton = removeButton;
 284         cwd->cwd_MoreButton = moreButton;
 285
 286         parent = (APTR)GetTagData(MUIA_Window_ParentWindow, (ULONG)NULL, msg->ops_AttrList);
 287
 288         set(obj, MUIA_Window_Title, MyGetWindowTitle(txtOOPTitle, cwd->cwd_Title, sizeof(cwd->cwd_Title)));
 289         set(obj, MUIA_Window_DefaultObject, classtree);
 290         DoMethod(obj, MUIM_MultiSet, MUIA_Disabled, TRUE, cwd->cwd_RemoveButton,
 291                                                           cwd->cwd_MoreButton,
 292                                                           NULL);
 293
 294         DoMethod(parent,       MUIM_Window_AddChildWindow, obj);
 295         DoMethod(obj,          MUIM_Notify, MUIA_Window_CloseRequest,   TRUE,           MUIV_Notify_Application, 5, MUIM_Application_PushMethod, parent, 2, MUIM_Window_RemChildWindow, obj);
 296         DoMethod(classtree,    MUIM_Notify, MUIA_NList_Active,          MUIV_EveryTime, obj,                     1, MUIM_OOPWin_ListChange);
 297         DoMethod(classtree,    MUIM_Notify, MUIA_NList_DoubleClick,     MUIV_EveryTime, obj,                     1, MUIM_OOPWin_More);
 298         DoMethod(updateButton, MUIM_Notify, MUIA_Pressed,               FALSE,          obj,                     1, MUIM_OOPWin_Update);
 299         DoMethod(printButton,  MUIM_Notify, MUIA_Pressed,               FALSE,          obj,                     1, MUIM_OOPWin_Print);
 300         DoMethod(removeButton, MUIM_Notify, MUIA_Pressed,               FALSE,          obj,                     1, MUIM_OOPWin_Remove);
 301         DoMethod(moreButton,   MUIM_Notify, MUIA_Pressed,               FALSE,          obj,                     1, MUIM_OOPWin_More);
 302         DoMethod(exitButton,   MUIM_Notify, MUIA_Pressed,               FALSE,          obj,                     3, MUIM_Set, MUIA_Window_CloseRequest, TRUE);
 303     }
 304
 305     return (ULONG)obj;
 306 }
 307
 308 STATIC ULONG mDispose( struct IClass *cl,
 309                        Object *obj,
 310                        Msg msg )
 311 {
 312     struct OOPWinData *cwd = INST_DATA(cl, obj);
 313
 314     set(obj, MUIA_Window_Open, FALSE);
 315     DoMethod(cwd->cwd_ClassTree, MUIM_NListtree_Clear, NULL, 0);
 316
 317     return (DoSuperMethodA(cl, obj, msg));
 318 }
 319
 320 STATIC ULONG mUpdate( struct IClass *cl,
 321                       Object *obj,
 322                       UNUSED Msg msg )
 323 {
 324     struct OOPWinData *cwd = INST_DATA(cl, obj);
 325     struct OOPCallbackUserData ud;
 326
 327     ApplicationSleep(TRUE);
 328     set(cwd->cwd_ClassTree, MUIA_NListtree_Quiet, TRUE);
 329     DoMethod(cwd->cwd_ClassTree, MUIM_NListtree_Clear, NULL, 0);
 330
 331     ud.ud_Tree = cwd->cwd_ClassTree;
 332     ud.ud_Count = 0;
 333
 334     if (clientstate) {
 335         ReceiveList(UpdateCallback, &ud);
 336     } else {
 337         IterateList(UpdateCallback, &ud);
 338     }
 339
 340     SetCountText(cwd->cwd_ClassCount, ud.ud_Count);
 341     MySetContents(cwd->cwd_ClassText, "");
 342
 343     set(cwd->cwd_ClassTree, MUIA_NListtree_Quiet, FALSE);
 344     set(cwd->cwd_ClassTree, MUIA_NListtree_Active, MUIV_NListtree_Active_Off);
 345     DoMethod(obj, MUIM_MultiSet, MUIA_Disabled, TRUE, cwd->cwd_RemoveButton,
 346                                                       cwd->cwd_MoreButton,
 347                                                       NULL);
 348     ApplicationSleep(FALSE);
 349
 350     return 0;
 351 }
 352
 353 STATIC ULONG mPrint( UNUSED struct IClass *cl,
 354                      UNUSED Object *obj,
 355                      UNUSED Msg msg )
 356 {
 357     PrintOOPClass(NULL);
 358
 359     return 0;
 360 }
 361
 362 STATIC ULONG mRemove( struct IClass *cl,
 363                       Object *obj,
 364                       UNUSED Msg msg )
 365 {
 366     struct OOPWinData *cwd = INST_DATA(cl, obj);
 367     struct MUI_NListtree_TreeNode *tn;
 368
 369     if ((tn = GetActiveTreeNode(cwd->cwd_ClassTree)) != NULL) {
 370         struct OOPClassEntry *ce = (struct OOPClassEntry *)tn->tn_User;
 371
 372         if (MyRequest(msgYesNo, msgWantToRemoveClass, ce->ce_ClassName)) {
 373             if (MyDoCommand("RemoveClass %s", ce->ce_Address) == RETURN_OK) {
 374                 DoMethod(obj, MUIM_ClassesWin_Update);
 375             }
 376         }
 377     }
 378
 379     return 0;
 380 }
 381
 382 STATIC ULONG mMore( struct IClass *cl,
 383                     Object *obj,
 384                     UNUSED Msg msg )
 385 {
 386     if (!clientstate) {
 387         struct OOPWinData *cwd = INST_DATA(cl, obj);
 388         struct MUI_NListtree_TreeNode *tn;
 389
 390         if ((tn = GetActiveTreeNode(cwd->cwd_ClassTree)) != NULL) {
 391             struct ClassEntry *ce = (struct ClassEntry *)tn->tn_User;
 392             APTR detailWin;
 393
 394             if ((detailWin = (Object *)(OOPDetailWindowObject,
 395                     MUIA_Window_ParentWindow, (IPTR)obj,
 396                 End)) != NULL) {
 397                 COLLECT_RETURNIDS;
 398                 set(detailWin, MUIA_OOPDetailWin_Class, ce);
 399                 set(detailWin, MUIA_Window_Open, TRUE);
 400                 REISSUE_RETURNIDS;
 401             }
 402         }
 403     }
 404
 405     return 0;
 406 }
 407
 408 STATIC ULONG mListChange( struct IClass *cl,
 409                           Object *obj,
 410                           UNUSED Msg msg )
 411 {
 412     struct OOPWinData *cwd = INST_DATA(cl, obj);
 413     struct MUI_NListtree_TreeNode *tn;
 414
 415     if ((tn = GetActiveTreeNode(cwd->cwd_ClassTree)) != NULL) {
 416         struct OOPClassEntry *ce = (struct OOPClassEntry *)tn->tn_User;
 417
 418         MySetContents(cwd->cwd_ClassText, "%s \"%s\"", ce->ce_Address, ce->ce_ClassName);
 419         DoMethod(obj, MUIM_MultiSet, MUIA_Disabled, FALSE, cwd->cwd_RemoveButton,
 420                                                            (clientstate) ? NULL : cwd->cwd_MoreButton,
 421                                                            NULL);
 422     }
 423
 424     return 0;
 425 }
 426
 427 DISPATCHER(OOPWinDispatcher)
 428 {
 429     switch (msg->MethodID) {
 430         case OM_NEW:                  return (mNew(cl, obj, (APTR)msg));
 431         case OM_DISPOSE:              return (mDispose(cl, obj, (APTR)msg));
 432         case MUIM_OOPWin_Update:      return (mUpdate(cl, obj, (APTR)msg));
 433         case MUIM_OOPWin_Print:       return (mPrint(cl, obj, (APTR)msg));
 434         case MUIM_OOPWin_Remove:      return (mRemove(cl, obj, (APTR)msg));
 435         case MUIM_OOPWin_More:        return (mMore(cl, obj, (APTR)msg));
 436         case MUIM_OOPWin_ListChange:  return (mListChange(cl, obj, (APTR)msg));
 437     }
 438
 439     return (DoSuperMethodA(cl, obj, msg));
 440 }
 441
 442 void PrintOOPClass( STRPTR filename )
 443 {
 444     BPTR handle;
 445
 446     if ((handle = HandlePrintStart(filename)) != ZERO) {
 447         PrintFOneLine(handle, txtOOPPrintHeader);
 448         IterateList(PrintCallback, (void *)handle);
 449     }
 450
 451     HandlePrintStop();
 452 }
 453
 454 void SendOOPClassList( STRPTR UNUSED dummy )
 455 {
 456     IterateList(SendCallback, NULL);
 457 }
 458
 459 APTR MakeOOPWinClass( void )
 460 {
 461     return MUI_CreateCustomClass(NULL, NULL, ParentWinClass, sizeof(struct OOPWinData), ENTRY(OOPWinDispatcher));
 462 }
 463
 464 #ifdef __AROS__
 465
 466 BOOL InitOOP(void)
 467 {
 468     OOPBase = OpenLibrary("oop.library", 0);
 469     if (!OOPBase)
 470         return FALSE;
 471
 472     MetaAttrBase = OOP_ObtainAttrBase(IID_Meta);
 473
 474     if (MetaAttrBase)
 475         return TRUE;
 476
 477     CleanupOOP();
 478     return FALSE;
 479 }
 480
 481 void CleanupOOP(void)
 482 {
 483     if (MetaAttrBase)
 484         OOP_ReleaseAttrBase(IID_Meta);
 485
 486     if (OOPBase) {
 487         CloseLibrary(OOPBase);
 488         OOPBase = NULL;
 489     }
 490 }
 491
 492 #else
 493
 494 BOOL InitOOP(void)
 495 {
 496     return TRUE;
 497 }
 498
 499 void CleanupOOP(void)
 500 {
 501 }
 502
 503 #endif