workbench/network/stacks/AROSTCP/MUI.MiamiPanel/Classes/muimiamipanel_class_ifgroup.c

   1
   2 #include <proto/dos.h>
   3 #include <proto/intuition.h>
   4 #include <proto/muimaster.h>
   5 #include <proto/utility.h>
   6
   7 #include <libraries/mui.h>
   8 #include <libraries/gadtools.h>
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12
  13 #include "muimiamipanel_intern.h"
  14 #include "muimiamipanel_locale.h"
  15 #include "muimiamipanel_misc.h"
  16 #include "muimiamipanel_message.h"
  17
  18 /***********************************************************************/
  19
  20 struct MiamiPanelIfGroupClass_DATA
  21 {
  22     Object                      *app;
  23
  24     Object                      *space;
  25     APTR                        cmenu;
  26
  27     int                         children;
  28     int                         refresh;
  29
  30     ULONG                       show;
  31
  32     struct MUI_InputHandlerNode ih;
  33
  34     ULONG                       flags;
  35 };
  36
  37 enum
  38 {
  39     FLG_Setup   = 1<<0,
  40     FLG_Handler = 1<<1,
  41     FLG_BWin    = 1<<2,
  42     FLG_Bar     = 1<<3,
  43     FLG_SkipBar = 1<<4,
  44 };
  45
  46 /***********************************************************************/
  47
  48 #define NMX(x) ((1<<8)-1-(1<<x))
  49
  50 static ULONG cMenuIDs[] =
  51 {
  52     MSG_Menu_Project,
  53         MSG_IFGroup_CItem_Online,
  54         MSG_IFGroup_CItem_Offline,
  55         MSG_IFGroup_CItem_Scale
  56 };
  57
  58 static struct NewMenu cMenu[] =
  59 {
  60     MTITLE(MSG_Menu_Project),
  61         MITEM(MSG_IFGroup_CItem_Online),
  62         MITEM(MSG_IFGroup_CItem_Offline),
  63         MITEM(MSG_IFGroup_CItem_Scale),
  64             MXSUB(TAG_SCALE_1,NMX(0)),
  65             MXSUB(TAG_SCALE_2,NMX(1)),
  66             MXSUB(TAG_SCALE_3,NMX(2)),
  67             MXSUB(TAG_SCALE_4,NMX(3)),
  68             MXSUB(TAG_SCALE_5,NMX(4)),
  69             MXSUB(TAG_SCALE_6,NMX(5)),
  70             MXSUB(TAG_SCALE_7,NMX(6)),
  71             MXSUB(TAG_SCALE_8,NMX(7)),
  72     MEND
  73 };
  74
  75 static struct MiamiPanelBase_intern *MiamiPanelBaseIntern;
  76
  77 static ULONG
  78 MUIPC_IfGroup__OM_NEW(struct IClass *CLASS,Object *self,struct opSet *message)
  79 {
  80     struct TagItem   *attrs = message->ops_AttrList;
  81     Object           *space;
  82
  83     if (self = (Object *)DoSuperNewTags
  84                 (
  85                         CLASS, self, NULL,
  86
  87             MUIA_Frame,      MUIV_Frame_Virtual,
  88             //MUIA_Background, MUII_GroupBack,
  89             MUIA_HelpNode,   "IFGroup",
  90             Child, space = RectangleObject, /*MUIA_Background, MUII_GroupBack, */End,
  91             TAG_MORE,attrs))
  92     {
  93         struct MiamiPanelIfGroupClass_DATA *data = INST_DATA(CLASS,self);
  94
  95         data->space = space;
  96         data->show  = GetTagData(MPA_Show,0,attrs);
  97
  98         if (data->cmenu = MUI_MakeObject(MUIO_MenustripNM,(ULONG)cMenu,0))
  99         {
 100             if (!(data->show & MIAMIPANELV_Init_Flags_ShowDataTransferRate))
 101             {
 102                 Object *cmscale;
 103
 104                 DoMethod(data->cmenu,MUIM_Family_Remove,(ULONG)(cmscale = (Object *)DoMethod(data->cmenu,MUIM_FindUData,MSG_IFGroup_CItem_Scale)));
 105                 MUI_DisposeObject(cmscale);
 106             }
 107         }
 108
 109         data->flags |= FLG_Bar;
 110     }
 111
 112     return (ULONG)self;
 113 }
 114
 115 /***********************************************************************/
 116
 117 static ULONG
 118 MUIPC_IfGroup__OM_SET(struct IClass *CLASS,Object *self,struct opSet *message)
 119 {
 120     struct MiamiPanelIfGroupClass_DATA    *data = INST_DATA(CLASS,self);
 121     struct TagItem *tag;
 122     struct TagItem *tstate;
 123
 124     for (tstate = message->ops_AttrList; tag = NextTagItem(&tstate); )
 125     {
 126         ULONG tidata = tag->ti_Data;
 127
 128         switch(tag->ti_Tag)
 129         {
 130             case MPA_Prefs:
 131                 if (PREFS(tidata)->flags & MPV_Flags_BWin)
 132                     data->flags |= FLG_BWin;
 133                 else data->flags &= ~FLG_BWin;
 134                 break;
 135
 136             case MPA_SkipBar:
 137                 if (tidata) data->flags |= FLG_SkipBar;
 138                 else
 139                 {
 140                     ULONG vh;
 141
 142                     data->flags &= ~FLG_SkipBar;
 143
 144                     DoSuperMethod(CLASS,self,OM_GET,MUIA_Virtgroup_Height,(ULONG)&vh);
 145
 146                     if (vh>=_height(self))
 147                     {
 148                         data->flags |= FLG_Bar;
 149                         set(_app(self),MPA_Bar,TRUE);
 150                     }
 151                     else
 152                     {
 153                         data->flags &= ~FLG_Bar;
 154                         set(_app(self),MPA_Bar,FALSE);
 155                     }
 156                 }
 157                 break;
 158         }
 159     }
 160
 161     return DoSuperMethodA(CLASS,self,(Msg)message);
 162 }
 163
 164 /***********************************************************************/
 165
 166 static ULONG
 167 MUIPC_IfGroup__OM_DISPOSE(struct IClass *CLASS,Object *self,Msg message)
 168 {
 169     struct MiamiPanelIfGroupClass_DATA *data = INST_DATA(CLASS,self);
 170
 171     if (data->cmenu) MUI_DisposeObject(data->cmenu);
 172
 173     if (data->flags & FLG_Handler)
 174         DoMethod(data->app,MUIM_Application_RemInputHandler,(ULONG)&data->ih);
 175
 176     return DoSuperMethodA(CLASS,self,message);
 177 }
 178
 179 /***********************************************************************/
 180
 181 static ULONG
 182 MUIPC_IfGroup__MUIM_Setup(struct IClass *CLASS,Object *self,Msg message)
 183 {
 184     struct MiamiPanelIfGroupClass_DATA *data = INST_DATA(CLASS,self);
 185
 186     if (!DoSuperMethodA(CLASS,self,message)) return FALSE;
 187
 188     if (!(data->flags & FLG_Handler))
 189     {
 190         data->app = _app(self);
 191         memset(&data->ih,0,sizeof(data->ih));
 192         data->ih.ihn_Object  = self;
 193         data->ih.ihn_Method  = MPM_IfGroup_HandleEvent;
 194         data->ih.ihn_Signals = 1<<MiamiPanelBaseIntern->mpb_port->mp_SigBit;
 195         DoMethod(data->app,MUIM_Application_AddInputHandler,(ULONG)&data->ih);
 196
 197         data->flags |= FLG_Handler;
 198     }
 199
 200     data->flags |= FLG_Setup;
 201
 202     return TRUE;
 203 }
 204
 205 /***********************************************************************/
 206
 207 static ULONG
 208 MUIPC_IfGroup__MUIM_Cleanup(struct IClass *CLASS,Object *self,Msg message)
 209 {
 210     struct MiamiPanelIfGroupClass_DATA *data = INST_DATA(CLASS,self);
 211
 212     data->flags &= ~FLG_Setup;
 213
 214     return DoSuperMethodA(CLASS,self,message);
 215 }
 216
 217 /***********************************************************************/
 218
 219 static ULONG
 220 MUIPC_IfGroup__MUIM_Show(struct IClass *CLASS,Object *self,Msg message)
 221 {
 222     struct MiamiPanelIfGroupClass_DATA *data = INST_DATA(CLASS,self);
 223
 224     if (!DoSuperMethodA(CLASS,self,message)) return FALSE;
 225
 226     if (data->flags & FLG_BWin)
 227     {
 228         ULONG bar;
 229         ULONG vh;
 230
 231         DoSuperMethod(CLASS,self,OM_GET,MUIA_Virtgroup_Height,(ULONG)&vh);
 232
 233         if (!BOOLSAME(data->flags & FLG_Bar,bar = vh>=_height(self)))
 234         {
 235             if (bar) data->flags |= FLG_Bar;
 236             else data->flags &= ~FLG_Bar;
 237
 238             if (!(data->flags & FLG_SkipBar))
 239                 DoMethod(_app(self),MUIM_Application_PushMethod,(ULONG)_app(self),3,MUIM_Set,MPA_Bar,(ULONG)bar);
 240         }
 241     }
 242
 243     return TRUE;
 244 }
 245
 246 /***********************************************************************/
 247
 248 static Object *
 249 findInterface(Object *self,long unit)
 250 {
 251     struct List *l;
 252     Object      *cstate;
 253     Object      *child;
 254
 255     get(self,MUIA_Group_ChildList,&l);
 256     cstate = (Object *)l->lh_Head;
 257
 258     while (child = NextObject(&cstate))
 259     {
 260         long u;
 261
 262         if (get(child,MPA_If_Unit,&u) && (u==unit))
 263             return child;
 264     }
 265
 266     return NULL;
 267 }
 268
 269 /***********************************************************************/
 270
 271 static Object *
 272 findNextChild(Object *self,Object *from,struct MiamiPanelIfGroupClass_DATA *data)
 273 {
 274     struct List *l;
 275     Object      *cstate;
 276     Object      *child, *space;
 277     ULONG       next;
 278
 279     get(self,MUIA_Group_ChildList,&l);
 280     cstate = (Object *)l->lh_Head;
 281     space = data->space;
 282     next = 0;
 283
 284     while (child = NextObject(&cstate))
 285     {
 286         if (child==from) next = 1;
 287         else if (next && child!=space) return child;
 288     }
 289
 290     return NULL;
 291 }
 292
 293 /***********************************************************************/
 294
 295 static void
 296 addInterface(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_AddInterface *message)
 297 {
 298     Object           *child, *bar;
 299     struct MPS_Prefs *prefs;
 300
 301     if (data->children)
 302         bar = RectangleObject,
 303             MUIA_Weight,         0,
 304             MUIA_Rectangle_HBar, TRUE,
 305             MUIA_FixHeightTxt,   "X",
 306         End;
 307     else bar = NULL;
 308
 309     get(_app(self),MPA_Prefs,&prefs);
 310
 311     if (child = NewObject(MiamiPanelBaseIntern->mpb_ifGroupClass->mcc_Class,
 312                 NULL,
 313             MUIA_ObjectID,    MAKE_ID('i','f',(message->unit & 0xF0),(message->unit & 0xF)),
 314             MUIA_ContextMenu, data->cmenu,
 315             MPA_Show,         data->show,
 316             MPA_If_Unit,      message->unit,
 317             MPA_If_Name,      message->name,
 318             MPA_If_State,     message->state,
 319             MPA_If_Ontime,    message->ontime,
 320             MPA_If_Speed,     message->speed,
 321             MPA_Prefs,        prefs,
 322                         TAG_DONE))
 323     {
 324         DoSuperMethod(CLASS,self,MUIM_Group_InitChange);
 325
 326         DoSuperMethod(CLASS,self,OM_REMMEMBER,(ULONG)data->space);
 327
 328         if (bar) DoSuperMethod(CLASS,self,OM_ADDMEMBER,(ULONG)bar);
 329         DoSuperMethod(CLASS,self,OM_ADDMEMBER,(ULONG)child);
 330
 331         DoSuperMethod(CLASS,self,OM_ADDMEMBER,(ULONG)data->space);
 332
 333         DoSuperMethod(CLASS,self,MUIM_Group_ExitChange);
 334         data->children++;
 335     }
 336     else if (bar) MUI_DisposeObject(bar);
 337 }
 338
 339 /***********************************************************************/
 340
 341 static void
 342 delInterface(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_DelInterface *message)
 343 {
 344     Object *child;
 345
 346     if (child = findInterface(self,message->unit))
 347     {
 348         register Object *next;
 349
 350         DoSuperMethod(CLASS,self,MUIM_Group_InitChange);
 351
 352         if (next = findNextChild(self, child, data))
 353         {
 354             DoSuperMethod(CLASS,self,OM_REMMEMBER,(ULONG)next);
 355             MUI_DisposeObject(next);
 356         }
 357
 358         DoSuperMethod(CLASS,self,OM_REMMEMBER,(ULONG)child);
 359         MUI_DisposeObject(child);
 360
 361         DoSuperMethod(CLASS,self,MUIM_Group_ExitChange);
 362
 363         data->children--;
 364     }
 365 }
 366
 367 /***********************************************************************/
 368
 369 static void
 370 setInterfaceState(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_SetInterfaceState *message)
 371 {
 372     Object *child;
 373
 374     if (child = findInterface(self,message->unit))
 375         SetAttrs(child,MPA_If_State,  message->state,
 376                        MPA_If_Ontime, message->ontime,
 377                        TAG_DONE);
 378 }
 379
 380 /***********************************************************************/
 381
 382 static void
 383 setInterfaceSpeed(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_SetInterfaceSpeed *message)
 384 {
 385     Object *child;
 386
 387     if (child = findInterface(self,message->unit))
 388         set(child,MPA_If_Speed,message->speed);
 389 }
 390
 391 /***********************************************************************/
 392
 393 static void
 394 interfaceReport(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_InterfaceReport *message)
 395 {
 396     Object *child;
 397
 398     if (child = findInterface(self,message->unit))
 399         SetAttrs(child,MPA_If_Rate,    message->rate,
 400                        MPA_If_Now,     message->now,
 401                        MPA_If_Traffic, (ULONG)&message->total,
 402                        TAG_DONE);
 403 }
 404
 405 /***********************************************************************/
 406
 407 static void
 408 refreshName(struct IClass *CLASS,Object *self,struct MiamiPanelIfGroupClass_DATA *data,struct MPS_Msg_RefreshName *message)
 409 {
 410     Object *child;
 411
 412     if (child = findInterface(self,message->unit))
 413         set(child,MPA_If_Name,message->name);
 414 }
 415
 416 /***********************************************************************/
 417
 418 static ULONG
 419 MUIPC_IfGroup__MPM_IfGroup_HandleEvent(struct IClass *CLASS,Object *self,Msg message)
 420 {
 421     struct MiamiPanelIfGroupClass_DATA    *data = INST_DATA(CLASS,self);
 422     struct MPS_Msg *mpsg;
 423     ULONG          res;
 424
 425     res = 0;
 426
 427     while (mpsg = (struct MPS_Msg *)GetMsg(MiamiPanelBaseIntern->mpb_port))
 428     {
 429         res++;
 430
 431         switch (mpsg->type)
 432         {
 433             case MPV_Msg_Type_Cleanup:
 434                 DoMethod(_app(self),MUIM_Application_PushMethod,(ULONG)_app(self),2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
 435                 break;
 436
 437             case MPV_Msg_Type_AddInterface:
 438                 addInterface(CLASS,self,data,(APTR)mpsg);
 439                 break;
 440
 441             case MPV_Msg_Type_DelInterface:
 442                 delInterface(CLASS,self,data,(APTR)mpsg);
 443                 break;
 444
 445             case MPV_Msg_Type_SetInterfaceState:
 446                 setInterfaceState(CLASS,self,data,(APTR)mpsg);
 447                 break;
 448
 449             case MPV_Msg_Type_SetInterfaceSpeed:
 450                 setInterfaceSpeed(CLASS,self,data,(APTR)mpsg);
 451                 break;
 452
 453             case MPV_Msg_Type_InterfaceReport:
 454                 interfaceReport(CLASS,self,data,(APTR)mpsg);
 455                 break;
 456
 457             case MPV_Msg_Type_RefreshName:
 458                 refreshName(CLASS,self,data,(APTR)mpsg);
 459                 break;
 460
 461             case MPV_Msg_Type_ToFront:
 462             {
 463                 ULONG iconified;
 464
 465                 get(_app(self),MUIA_Application_Iconified,&iconified);
 466                 if (iconified) set(_app(self),MUIA_Application_Iconified,FALSE);
 467                 else
 468                     if (data->flags & FLG_Setup) set(_win(self),MUIA_Window_Open,TRUE);
 469                     else DisplayBeep(0);
 470                 break;
 471             }
 472
 473             case MPV_Msg_Type_InhibitRefresh:
 474             {
 475                 struct MPS_Msg_InhibitRefresh *m = (struct MPS_Msg_InhibitRefresh *)mpsg;
 476
 477                 if (m->val)
 478                 {
 479                     if (!data->refresh++)
 480                         DoMethod(self,MUIM_Group_InitChange);
 481                 }
 482                 else
 483                     if (data->refresh && !--data->refresh)
 484                         DoMethod(self,MUIM_Group_ExitChange);
 485                 break;
 486             }
 487
 488             default:
 489                 break;
 490         }
 491
 492         if (mpsg->flags & MPV_Msg_Flags_Reply) ReplyMsg((struct Message *)mpsg);
 493         else freeMsg(mpsg, MiamiPanelBaseIntern);
 494     }
 495
 496     return res;
 497 }
 498
 499 /***********************************************************************/
 500
 501 static ULONG
 502 MUIPC_IfGroup__MPM_IfGroup_GrabIFList(struct IClass *CLASS,Object *self,Msg message)
 503 {
 504     struct List      *l;
 505     Object           *cstate;
 506     Object           *child;
 507     struct MPS_Prefs *prefs;
 508
 509     get(_app(self),MPA_Prefs,&prefs);
 510     freeIFList(prefs, MiamiPanelBaseIntern);
 511
 512     get(self,MUIA_Group_ChildList,&l);
 513     cstate = (Object *)l->lh_Head;
 514
 515     while (child = NextObject(&cstate))
 516     {
 517         UBYTE  *name;
 518         ULONG  scale;
 519
 520         if (get(child,MPA_If_Name,&name))
 521         {
 522             get(child,MPA_If_Scale,&scale);
 523             createIFNode(prefs,name,scale, MiamiPanelBaseIntern);
 524         }
 525     }
 526
 527     return NULL;
 528 }
 529
 530 /***********************************************************************/
 531
 532 BOOPSI_DISPATCHER(IPTR, MUIPC_IfGroup_Dispatcher, CLASS, self, message)
 533 {
 534     switch (message->MethodID)
 535     {
 536         case OM_NEW:                  return MUIPC_IfGroup__OM_NEW(CLASS,self,(APTR)message);
 537         case OM_SET:                  return MUIPC_IfGroup__OM_SET(CLASS,self,(APTR)message);
 538         case OM_DISPOSE:              return MUIPC_IfGroup__OM_DISPOSE(CLASS,self,(APTR)message);
 539         case MUIM_Setup:              return MUIPC_IfGroup__MUIM_Setup(CLASS,self,(APTR)message);
 540         case MUIM_Cleanup:            return MUIPC_IfGroup__MUIM_Cleanup(CLASS,self,(APTR)message);
 541         case MUIM_Show:               return MUIPC_IfGroup__MUIM_Show(CLASS,self,(APTR)message);
 542         case MPM_IfGroup_HandleEvent: return MUIPC_IfGroup__MPM_IfGroup_HandleEvent(CLASS,self,(APTR)message);
 543         case MPM_IfGroup_GrabIFList:  return MUIPC_IfGroup__MPM_IfGroup_GrabIFList(CLASS,self,(APTR)message);
 544         default:                      return DoSuperMethodA(CLASS,self,message);
 545     }
 546         return 0;
 547 }
 548 BOOPSI_DISPATCHER_END
 549
 550 /***********************************************************************/
 551
 552 static ULONG defScales[] =
 553 {
 554     6000,
 555     12000,
 556     32000,
 557     64000,
 558     128000,
 559     256000,
 560     512000,
 561     1024000,
 562     0
 563 };
 564
 565 struct TagItem scales[] =
 566 {
 567     TAG_SCALE_1,     6000,
 568     TAG_SCALE_2,    12000,
 569     TAG_SCALE_3,    32000,
 570     TAG_SCALE_4,    64000,
 571     TAG_SCALE_5,   128000,
 572     TAG_SCALE_6,   256000,
 573     TAG_SCALE_7,   512000,
 574     TAG_SCALE_8,  1024000,
 575     TAG_DONE
 576 };
 577
 578 static UBYTE scaleStrings[TAG_SCALE_LAST-TAG_SCALE-1][64];
 579
 580 ULONG
 581 MUIPC_IfGroup_ClassInit(struct MiamiPanelBase_intern *MiamiPanelBase)
 582 {
 583         MiamiPanelBaseIntern = MiamiPanelBase;
 584     if (MiamiPanelBaseIntern->mpb_ifGroupClass = MUI_CreateCustomClass(NULL, MUIC_Virtgroup,NULL, sizeof(struct MiamiPanelIfGroupClass_DATA), MUIPC_IfGroup_Dispatcher))
 585     {
 586         struct NewMenu *nm;
 587         struct TagItem *t;
 588         UBYTE          *scaleFmt;
 589         BPTR           file;
 590         ULONG          *ids;
 591         int            i;
 592
 593     for (i = 0, ids = defScales; *ids; ids++, i++) scales[i].ti_Data = *ids;
 594
 595         if (file = Open("MIAMI:Libs/MUI.MiamiPanel.scales",MODE_OLDFILE))
 596         {
 597             UBYTE buf[32];
 598
 599             i = 0;
 600
 601             while (FGets(file,buf,sizeof(buf)))
 602             {
 603                 UBYTE *s;
 604
 605                 for (s = buf; *s && *s!='\n' && *s!='\r'; s++);
 606                 *s = 0;
 607
 608                 if (!*buf || *buf==';') continue;
 609
 610                 scales[i++].ti_Data = atoi(buf);
 611                 if (i==TAG_SCALE_LAST-TAG_SCALE-1) break;
 612             }
 613
 614             Close(file);
 615         }
 616
 617         scaleFmt = __(MSG_IFGroup_CItem_ScaleFmt);
 618
 619         for (i = 0, t = scales; t->ti_Tag!=TAG_DONE; i++, t++)
 620             snprintf(scaleStrings[i],sizeof(scaleStrings[i]),scaleFmt,t->ti_Data/1000);
 621
 622         for (ids = cMenuIDs, nm = cMenu ; nm->nm_Type!=NM_END; nm++)
 623             if (nm->nm_Label!=NM_BARLABEL)
 624                 if (((ULONG)nm->nm_UserData>TAG_SCALE) && ((ULONG)nm->nm_UserData<TAG_SCALE_LAST))
 625                     nm->nm_Label = scaleStrings[(ULONG)nm->nm_UserData-TAG_SCALE-1];
 626                 else nm->nm_Label = __(*ids++);
 627
 628         return TRUE;
 629     }
 630
 631     return FALSE;
 632 }
 633
 634 /***********************************************************************/