home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 3 / CDPDIII.bin / pd / utilities / editors / jed / src / jed.lha / pubman.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-02  |  6.1 KB  |  315 lines
  1.  
  2. /*
  3.  * PUBMAN.C
  4.  * (c) 1992 J.Harper
  5.  *
  6.  * Public Screen Manager.
  7.  *
  8.  * usage:
  9.  *    pubman {<command>}
  10.  */
  11.  
  12. #include <exec/ports.h>
  13. #include <exec/memory.h>
  14. #include <intuition/screens.h>
  15. #include <graphics/displayinfo.h>
  16. #include <clib/exec_protos.h>
  17. #include <clib/intuition_protos.h>
  18. #include <stdio.h>
  19. #include <string.h>
  20.  
  21. __stkargs VOID     LockAddr(LONG *);    /* These 2 are DICE specific */
  22. __stkargs VOID     UnlockAddr(LONG *);
  23.  
  24.       VOID     usage(VOID);
  25.       STRPTR savestring(STRPTR);
  26.       VOID     NewList(struct List *);
  27.       VOID     exit(LONG);
  28.  
  29. typedef struct
  30. {
  31.     struct MsgPort psm_Port;
  32.     struct List       psm_Screens;
  33.     ULONG       psm_DisplayID;
  34.     UWORD       psm_Width;
  35.     UWORD       psm_Height;
  36.     LONG       psm_Depth;
  37.     LONG       psm_Lock[2];
  38. } PSM;
  39.  
  40. typedef struct
  41. {
  42.     struct Node       sn_Node;
  43.     struct Screen *sn_Screen;
  44. } SNODE;
  45.  
  46. const UBYTE NoMem[]   = "error: no memory";
  47. const UBYTE PSMPort[] = "PSMPort";
  48.  
  49. LONG
  50. main(LONG ac, STRPTR *av)
  51. {
  52.     PSM *me;
  53.     LONG rc = 0;
  54.     if(ac == 1)
  55.     {
  56.     usage();
  57.     exit(5);
  58.     }
  59.     Forbid();
  60.     if(!(me = (PSM *)FindPort(PSMPort)))
  61.     {
  62.     struct Screen wbcopy;
  63.     if(!(me = AllocMem(sizeof(PSM), MEMF_CLEAR | MEMF_PUBLIC)))
  64.     {
  65.         Permit();
  66.         puts(NoMem);
  67.         exit(10);
  68.     }
  69.     if(!(me->psm_Port.mp_Node.ln_Name = savestring(PSMPort)))
  70.     {
  71.         FreeMem(me, sizeof(PSM));
  72.         Permit();
  73.         puts(NoMem);
  74.         exit(10);
  75.     }
  76.     me->psm_Port.mp_Node.ln_Pri  = 1;
  77.     me->psm_Port.mp_Node.ln_Type = NT_MSGPORT;
  78.     me->psm_Port.mp_Flags         = PA_IGNORE;
  79.     NewList(&me->psm_Screens);
  80.     me->psm_DisplayID         = HIRES_KEY;
  81.     me->psm_Depth             = 2;
  82.     if(GetScreenData(&wbcopy, sizeof(struct Screen), WBENCHSCREEN, NULL))
  83.     {
  84.         me->psm_Width = wbcopy.Width;
  85.         me->psm_Height = wbcopy.Height;
  86.     }
  87.     else
  88.     {
  89.         me->psm_Width = 640;
  90.         me->psm_Height = 256;
  91.     }
  92.     AddPort(&me->psm_Port);
  93.     }
  94.     Permit();
  95.     LockAddr(me->psm_Lock);
  96.  
  97.     ac--;
  98.     av++;
  99.     while(ac && !rc)
  100.     {
  101.     STRPTR cmd = *av;
  102.     switch(((*cmd++) << 8) | (*cmd++))
  103.     {
  104.         case 'li':
  105.         struct PubScreenNode *psn;
  106.         psn = (struct PubScreenNode *)(LockPubScreenList()->lh_Head);
  107.         while(psn->psn_Node.ln_Succ)
  108.         {
  109.             printf("%s (%ld visitors)\n", psn->psn_Node.ln_Name, psn->psn_VisitorCount);
  110.             psn = (struct PubScreenNode *)psn->psn_Node.ln_Succ;
  111.         }
  112.         UnlockPubScreenList();
  113.         break;
  114.         case 'dp':
  115.         if(*cmd)
  116.             SetDefaultPubScreen(cmd);
  117.         else
  118.         {
  119.             UBYTE buff[MAXPUBSCREENNAME];
  120.             GetDefaultPubScreen(buff);
  121.             puts(buff);
  122.         }
  123.         break;
  124.         case 'md':
  125.         UWORD modes = SetPubScreenModes(0);
  126.         switch(*cmd++)
  127.         {
  128.             case 's':
  129.             if(*cmd == '+')
  130.                 modes |= SHANGHAI;
  131.             else
  132.                 modes &= ~SHANGHAI;
  133.             break;
  134.             case 'p':
  135.             if(*cmd == '+')
  136.                 modes |= POPPUBSCREEN;
  137.             else
  138.                 modes &= ~POPPUBSCREEN;
  139.             break;
  140.             default:
  141.             printf("%lx\n", modes);
  142.             break;
  143.         }
  144.         SetPubScreenModes(modes);
  145.         break;
  146.         case 'di':
  147.         if(*cmd)
  148.         {
  149.             APTR dummy;
  150.             me->psm_DisplayID = strtol(cmd, &dummy, 0);
  151.         }
  152.         else
  153.             printf("%lx\n", me->psm_DisplayID);
  154.         break;
  155.         case 'de':
  156.         if(*cmd)
  157.         {
  158.             APTR dummy;
  159.             me->psm_Depth = strtol(cmd, &dummy, 0);
  160.         }
  161.         else
  162.             printf("%lx\n", me->psm_Depth);
  163.         break;
  164.         case 'si':
  165.         if(*cmd)
  166.         {
  167.             STRPTR ptr;
  168.             me->psm_Width = strtol(cmd, &ptr, 0);
  169.             me->psm_Height = strtol(ptr + 1, &ptr, 0);
  170.         }
  171.         else
  172.             printf("%lx/%lx\n", me->psm_Width, me->psm_Height);
  173.         break;
  174.         case 'op':
  175.         if(*cmd)
  176.         {
  177.             SNODE *sn;
  178.             static UWORD penarray[] = { ~0 };
  179.             ULONG error;
  180.             if(!(sn = AllocMem(sizeof(SNODE), MEMF_PUBLIC | MEMF_CLEAR)))
  181.             {
  182.             puts(NoMem);
  183.             rc = 5;
  184.             continue;
  185.             }
  186.             if(!(sn->sn_Node.ln_Name = savestring(cmd)))
  187.             {
  188.             FreeMem(sn, sizeof(SNODE));
  189.             puts(NoMem);
  190.             rc = 5;
  191.             continue;
  192.             }
  193.             if(!(sn->sn_Screen = OpenScreenTags(NULL,
  194.             SA_Width, me->psm_Width,
  195.             SA_Height, me->psm_Height,
  196.             SA_Depth, me->psm_Depth,
  197.             SA_DisplayID, me->psm_DisplayID,
  198.             SA_Overscan, OSCAN_TEXT,
  199.             SA_Title, sn->sn_Node.ln_Name,
  200.             SA_AutoScroll, TRUE,
  201.             SA_PubName, sn->sn_Node.ln_Name,
  202.             SA_Pens, penarray,
  203.             SA_ErrorCode, &error,
  204.             TAG_END)))
  205.             {
  206.             FreeVec(sn->sn_Node.ln_Name);
  207.             FreeMem(sn, sizeof(SNODE));
  208.             switch(error)
  209.             {
  210.                 case OSERR_NOMONITOR:
  211.                 puts("error: monitor not available");
  212.                 break;
  213.                 case OSERR_NOCHIPS:
  214.                 puts("error: newer custom chips are required");
  215.                 break;
  216.                 case OSERR_NOMEM:
  217.                 puts(NoMem);
  218.                 break;
  219.                 case OSERR_NOCHIPMEM:
  220.                 puts("error: no chip memory");
  221.                 break;
  222.                 case OSERR_PUBNOTUNIQUE:
  223.                 puts("error: screen of that name already exists");
  224.                 break;
  225.                 case OSERR_UNKNOWNMODE:
  226.                 puts("error: unknown display mode");
  227.                 break;
  228.                 default:
  229.                 puts("error: can't open screen");
  230.                 break;
  231.             }
  232.             rc = 10;
  233.             continue;
  234.             }
  235.             AddTail(&me->psm_Screens, &sn->sn_Node);
  236.             PubScreenStatus(sn->sn_Screen, 0);
  237.         }
  238.         break;
  239.         case 'cl':
  240.         if(*cmd)
  241.         {
  242.             SNODE *sn;
  243.             if(sn = (SNODE *)FindName(&me->psm_Screens, cmd))
  244.             {
  245.             if(PubScreenStatus(sn->sn_Screen, PSNF_PRIVATE) & 1)
  246.             {
  247.                 Remove(&sn->sn_Node);
  248.                 CloseScreen(sn->sn_Screen);
  249.                 FreeVec(sn->sn_Node.ln_Name);
  250.                 FreeMem(sn, sizeof(SNODE));
  251.             }
  252.             else
  253.             {
  254.                 puts("error: visitor windows open on screen");
  255.                 rc = 5;
  256.             }
  257.             }
  258.             else
  259.             {
  260.             puts("error: no screen of that name");
  261.             rc = 5;
  262.             }
  263.         }
  264.         break;
  265.         default:
  266.         puts("error: unknown command");
  267.         usage();
  268.         rc = 10;
  269.     }
  270.     ac--;
  271.     av++;
  272.     }
  273.     UnlockAddr(me->psm_Lock);
  274.     exit(rc);
  275. }
  276.  
  277. VOID
  278. usage(VOID)
  279. {
  280.     puts("usage: pubman {<command>}");
  281.     puts("command:");
  282.     puts("\tli");
  283.     puts("\tdp[name]");
  284.     puts("\tmd[s+|s-|p+|p-]");
  285.     puts("\tdi[display ID #]");
  286.     puts("\tde[bpl #]");
  287.     puts("\tsi[w/h]");
  288.     puts("\top<name>");
  289.     puts("\tcl<name>");
  290. }
  291.  
  292. STRPTR
  293. savestring(STRPTR str1)
  294. {
  295.     STRPTR str2;
  296.     if(str2 = AllocVec(strlen(str1) + 1, MEMF_PUBLIC))
  297.     strcpy(str2, str1);
  298.     return(str2);
  299. }
  300.  
  301. struct Screen *
  302. OpenScreenTags(struct NewScreen *ns, ULONG tag1)
  303. {
  304.     return(OpenScreenTagList(ns, (struct TagItem *)&tag1));
  305. }
  306.  
  307. VOID
  308. NewList(struct List *list)
  309. {
  310.     list->lh_Head = (struct Node *)&list->lh_Tail;
  311.     list->lh_Tail = NULL;
  312.     list->lh_TailPred = (struct Node *)&list->lh_Head;
  313. }
  314.  
  315.