home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / source / netnwscd.sit / CGroupList.c < prev    next >
Text File  |  1990-10-16  |  4KB  |  193 lines
  1. /*
  2.  * CGroupList
  3.  *
  4.  *     SUPERCLASS = CListWind
  5.  * Copyright ⌐ Tom Bereiter, 1990
  6.  */
  7.  
  8. #include <Commands.h>
  9. #include <CBartender.h>
  10. #include "CArticleList.h"
  11. #include "CGroupList.h"
  12.  
  13. #define    WINDnogoaway        501        /* Resource ID for WIND template with no 'go away' */
  14.  
  15. #define    cmdSubsGroups    1040L
  16. #define    cmdAllGroups    1041L
  17. #define    cmdAddGroup        1042L
  18. #define    cmdDelGroup        1043L
  19.  
  20. extern CBartender *gBartender;
  21. extern short        gClicks;            /* Click counter, = 1 single click    */
  22.  
  23. char subsmsg[]="Subscribed News Groups";
  24. char allmsg[]="All News Groups";
  25.  
  26. void    CGroupList::IGroupList(void)
  27. {
  28.     CListWind::IListWind(WINDnogoaway, subsmsg, 80, 24);
  29.     ReDo();
  30. }
  31.  
  32. void CGroupList::DoCommand(long theCommand)
  33. {
  34.     Boolean wantActive = TRUE;
  35.     Boolean remove = FALSE;
  36.     bitmap_t *bm;
  37.     grp_t *gp;
  38.     char *msg;
  39.     int i;
  40.     
  41.     switch (theCommand) {
  42.  
  43.     case cmdSubsGroups:
  44.         wantActive = FALSE;
  45.         /* FALL THROUGH */
  46.     case cmdAllGroups:
  47.         if (allActive != wantActive) {
  48.             allActive = wantActive;
  49.             msg = allActive ? allmsg : subsmsg;
  50.             CtoPstr(msg);
  51.             itsWindow->SetTitle((StringPtr)msg);
  52.             PtoCstr(msg);
  53.             ReDo();
  54.         }
  55.         break;
  56.         
  57.     case cmdDelGroup:
  58.         if (!allActive) {
  59.             bm = itsPane->GetSelect(nsgrps);
  60.             for (i=0,gp=grp_head; i<nsgrps; i++,gp=gp->next)
  61.                 if (Btst(bm, i)) {
  62.                     gp->flags = G_INACT;
  63.                     rm_sgrp(gp);
  64.                     itsPane->DelLine(i, 1);
  65.                 }
  66.             DisposPtr(bm);
  67.             break;
  68.         }
  69.         remove = TRUE;
  70.         /* FALL THROUGH */
  71.         
  72.     case cmdAddGroup:
  73.         bm = itsPane->GetSelect(ngrps);
  74.         for (i=0; i<ngrps; i++)
  75.             if (Btst(bm, i)) {
  76.                 gp = &grps[i];
  77.                 if (remove) {
  78.                     gp->flags = G_INACT;
  79.                     rm_sgrp(gp);
  80.                 }
  81.                 else {
  82.                     gp->flags = G_SUB;
  83.                     gp->subindex = 32000;    /* a big number */
  84.                     add_sgrp(gp);
  85.                 }
  86.                 ReDoLine(gp);
  87.             }
  88.         DisposPtr(bm);
  89.         break;
  90.         
  91.     default:
  92.         inherited::DoCommand(theCommand);
  93.         break;
  94.     }
  95. }
  96.  
  97. void CGroupList::UpdateMenus()
  98. {
  99.     inherited::UpdateMenus();
  100.     gBartender->DisableCmd(cmdClose);
  101.     
  102.     gBartender->EnableCmd(cmdSubsGroups);
  103.     gBartender->CheckMarkCmd(cmdSubsGroups, !allActive);
  104.     gBartender->EnableCmd(cmdAllGroups);
  105.     gBartender->CheckMarkCmd(cmdAllGroups, allActive);
  106.     if (allActive)
  107.         gBartender->EnableCmd(cmdAddGroup);
  108.     gBartender->EnableCmd(cmdDelGroup);
  109. }
  110.  
  111. void CGroupList::Dawdle(long *maxSleep)
  112. {
  113. }
  114.  
  115. void CGroupList::ReDo()
  116. {
  117.     grp_t *gp;
  118.     char buf[100];
  119.     int i;
  120.  
  121.     Enab(0);
  122.     
  123.     if (allActive) {
  124.         for (gp=grps; gp < &grps[ngrps]; gp++) {
  125.             mkgline(gp, TRUE, buf);
  126.             itsPane->AddLine(buf);
  127.         }
  128.     }
  129.     else {
  130.         for (gp=grp_head; gp; gp=gp->next) {
  131.             mkgline(gp, FALSE, buf);
  132.             itsPane->AddLine(buf);
  133.         }
  134.     }
  135.     Enab(1);
  136. }
  137.  
  138. void CGroupList::ReDoLine(grp_t *line_gp)
  139. {
  140.     grp_t *gp;
  141.     int n;
  142.     char buf[100];
  143.     
  144.     if (allActive)
  145.         n = line_gp - grps;
  146.     else {
  147.         for (gp=grp_head,n=0; gp; gp=gp->next,n++)
  148.             if (gp == line_gp)
  149.                 break;
  150.     }
  151.     mkgline(line_gp, allActive, buf);
  152.     itsPane->SetLine(n, buf);
  153. }
  154.  
  155. mkgline(grp_t *gp, Boolean all, char *buf)
  156. {
  157.     char c;
  158.  
  159.     c = (all && (gp->flags & G_SUB)) ? '+' : ' ';
  160.     sprintf(buf,"%5ld  %c %.90s", gp->unread, c, gp->gname);
  161. }
  162.  
  163.  
  164. void CGroupList::ClickLine(int line)
  165. {
  166.     grp_t *gp;
  167.     int n;
  168.     CArticleList *al;
  169.  
  170.     if (line < 0 || line >= ngrps)
  171.         return;
  172.  
  173.     if (gClicks == 2 && lastclickline == line) {
  174.         if (allActive)
  175.             gp = &grps[line];
  176.         else {
  177.             for (gp=grp_head,n=0; gp; gp=gp->next,n++)
  178.                 if (n == line)
  179.                     break;
  180.         }
  181.         /* build article headers */
  182.         al = new(CArticleList);
  183.         al->IArticleList(this, gp);
  184.         al->TmpMsg("reading headings...");
  185.  
  186.         igroup(gp);
  187.         ReDoLine(gp);        /* may have changed */
  188.         
  189.         al->ReDo();
  190.     }
  191.     lastclickline = line;
  192. }
  193.