home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 458.lha / PublicScreenX / Source / psx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-30  |  9.4 KB  |  426 lines
  1. /**********************************************************************/
  2. /*                    PSX main loop, entrance, etc                    */
  3. /**********************************************************************/
  4.  
  5. #include "psx.h"
  6. #include <libraries/gadtools.h>
  7. #include <Exec/memory.h>
  8.  
  9. static struct Remember *ScreenListRemember;
  10. static char OnPubScreenName[MAXPUBSCREENNAME];
  11.  
  12. struct PubNode
  13.     {
  14.     struct Node Node;
  15.     char Data[1];
  16.     };
  17.  
  18. char *ScreenNamePointers[255];
  19. ULONG GlobalModes;
  20.  
  21. void MemCleanup(void) {}
  22.  
  23. /**********************************************************************/
  24. /*              Build the list of public screens in RAM               */
  25. /**********************************************************************/
  26. void
  27. BuildScreenList(void)
  28. {
  29. struct List *PubList;
  30. struct Node *PubNode;
  31. struct PubNode *Node;
  32. int Num=0;
  33.  
  34. PubList=LockPubScreenList();
  35.  
  36. NewList(&ScreenList);
  37. if (ScreenListRemember)
  38.     {
  39.     FreeRemember(&ScreenListRemember, TRUE);
  40.     ScreenListRemember=0;
  41.     }
  42.  
  43. for (PubNode=PubList->lh_Head; PubNode->ln_Succ; PubNode=PubNode->ln_Succ)
  44.     {
  45.     Node = (struct PubNode *)AllocRemember(&ScreenListRemember, sizeof(struct Node)+strlen(PubNode->ln_Name)+2, MEMF_CLEAR);
  46.     if (Node==0) 
  47.         {
  48.         UnlockPubScreenList();
  49.         exit(160);
  50.         };
  51.  
  52.     Node->Node.ln_Name = &Node->Data[0];
  53.     ScreenNamePointers[Num++]=&Node->Data[0];
  54.     strcpy(&Node->Data[0], PubNode->ln_Name);
  55.  
  56.     if (strcmp(ScreenNamePointers[Num-1], CurPubScreenName)==0)
  57.         ListViewTags[9]=Num-1;
  58.  
  59.     AddTail(&ScreenList, Node);
  60.     }
  61.  
  62. UnlockPubScreenList();
  63. }
  64.  
  65.  
  66. /**********************************************************************/
  67. /* Release any public screen that we've locked to put the window on.  */
  68. /**********************************************************************/
  69. void
  70. ReleasePublicScreen(void)
  71. {
  72. if (Screen)
  73.     {
  74.     UnlockPubScreen(OnPubScreenName, Screen);
  75.     };
  76. }
  77.  
  78. /**********************************************************************/
  79. /*              Find a public screen for PSX to open on.              */
  80. /**********************************************************************/
  81. void
  82. FindPublicScreen(void)
  83. {
  84. strcpy(OnPubScreenName, CurPubScreenName);
  85. Screen=LockPubScreen(CurPubScreenName);
  86. if (Screen==NULL)
  87.     {
  88.     GetDefaultPubScreen(OnPubScreenName);
  89.     strcpy(CurPubScreenName, OnPubScreenName);
  90.     Screen=LockPubScreen(OnPubScreenName);
  91.     };
  92. }
  93.  
  94. /**********************************************************************/
  95. /*        Init the PSX Window on the currently selected screen        */
  96. /**********************************************************************/
  97. struct Window *
  98. OpenPSXWindow(void)
  99. {
  100. /** If the CurPubScreenName is Null then open on Workbench **/
  101. ULONG TopBorder;
  102. int WinHeight;
  103.  
  104. TAttr=Screen->Font;
  105. FontY=TAttr->ta_YSize;
  106. TopBorder=Screen->WBorTop;
  107. VI=(APTR)GetVisualInfoA((struct Screen *)Screen, TAG_DONE);
  108.  
  109. BuildScreenList();
  110.  
  111. GadList=NULL;
  112. WinHeight=CreatePSXGadgets(&GadList, VI, TopBorder, TAttr);
  113. if (WinHeight==0)
  114.     exit(150);
  115.  
  116. Window = OpenWindowTags( NULL,
  117.         WA_Left,    WIN_LEFT,
  118.         WA_Top,        WIN_TOP,
  119.         WA_Width,    WIN_WIDTH,
  120.         WA_Height,    WinHeight,
  121.         WA_IDCMP,      GADGETUP|CLOSEWINDOW|BUTTONIDCMP|LISTVIEWIDCMP|REFRESHWINDOW,
  122.         WA_Activate,    TRUE,
  123.         WA_CloseGadget,    TRUE,
  124.         WA_DepthGadget,    TRUE,
  125.         WA_DragBar,    TRUE,
  126.         WA_RMBTrap,    TRUE,
  127.         WA_Title,    "PSX Public Screen Tool",
  128.         WA_SimpleRefresh, TRUE,
  129.         WA_PubScreenName, CurPubScreenName,
  130.         TAG_END
  131.         );
  132.  
  133. if (!Window) return(FALSE);
  134.  
  135. /** Set screen font **/
  136.  
  137. TAttr=Screen->Font;
  138. ScreenFont=(struct TextFont *)OpenFont(TAttr);
  139. SetFont(Window->RPort, ScreenFont);
  140.  
  141. /** Internal size variables **/
  142.  
  143. ILeft=Window->BorderLeft;
  144. ITop=Window->BorderTop;
  145. IRight=(Window->Width-ILeft)-(Window->BorderRight+1);
  146. IBottom=(Window->Height-ITop)-(Window->BorderBottom+1);
  147. IWidth=IRight-ILeft;
  148. IHeight=ITop-IBottom;
  149.  
  150. /** GadTools Init **/
  151.  
  152. AddGList(Window, GadList, -1, -1, NULL);
  153. RefreshGList(GadList, Window, NULL, -1);
  154. GT_RefreshWindow(Window, NULL);
  155.  
  156. GlobalModes=SetPubScreenModes(0);
  157. SetPubScreenModes(GlobalModes);
  158.  
  159. GT_SetGadgetAttrs(ShanghaiGad, Window, 0, GTCY_Active, GlobalModes&SHANGHAI?0:1, TAG_DONE);
  160. GT_SetGadgetAttrs(PopGad, Window, 0, GTCY_Active, GlobalModes&POPPUBSCREEN?0:1, TAG_DONE);
  161.  
  162. return(Window);
  163. }
  164.  
  165.  
  166.  
  167.  
  168. /**********************************************************************/
  169. /*          Shut down the PSX Window, free anything involved          */
  170. /**********************************************************************/
  171. void
  172. ClosePSXWindow(void)
  173. {
  174. if (Window)
  175.     CloseWindow(Window);
  176. if (VI)
  177.     FreeVisualInfo(VI);
  178. if (GadList)
  179.     FreeGadgets(GadList);
  180.  
  181. VI=0;
  182. Window=0;
  183. GadList=0;
  184. }
  185.  
  186.  
  187.  
  188.  
  189. /**********************************************************************/
  190. /*          Cleanup-style exit routine, closes windows, etc           */
  191. /**********************************************************************/
  192. void
  193. ExitRoutine(void)
  194. {
  195. ClosePSXWindow();
  196. ReleasePublicScreen();
  197. if (ScreenListRemember)
  198.     FreeRemember(&ScreenListRemember, TRUE);
  199. ScreenListRemember=0;
  200. CloseLibraries();
  201. }
  202.  
  203.  
  204.  
  205. /**********************************************************************/
  206. /*                         The main PSX Loop                          */
  207. /**********************************************************************/
  208. void
  209. MainLoop(void)
  210. {
  211. int Keepgoing=TRUE;
  212. struct IntuiMessage *Message;
  213. ULONG Class, Code;
  214. struct Screen *ToClose;
  215. int Result;
  216.  
  217. GetDefaultPubScreen(CurPubScreenName);
  218. FindPublicScreen();
  219.  
  220. if (OpenPSXWindow()==FALSE)
  221.     exit(101);
  222.  
  223. SetMessage("PSX V1.0, by Steve Tibbett");
  224.  
  225. ScreenToFront(Screen);
  226.  
  227. while (Keepgoing)
  228.     {
  229.     struct Gadget *Gad;
  230.     ULONG GadID;
  231.  
  232.     Message=(struct IntuiMessage *)GT_GetIMsg(Window->UserPort);
  233.     if (Message==FALSE)
  234.         {
  235.         WaitPort(Window->UserPort);
  236.         continue;
  237.         };
  238.  
  239.     Class=Message->Class;
  240.     Code=Message->Code;
  241.     Gad=Message->IAddress;
  242.     GadID=Gad->GadgetID;
  243.  
  244.     GT_ReplyIMsg((struct IntuiMessage *)Message);
  245.  
  246.     switch (Class)
  247.         {
  248.         case GADGETUP:
  249.             switch (GadID)
  250.                 {
  251.                 case GADID_OPENSCREEN:
  252.                     SetMessage("");
  253.                     OpenNewPublicScreen();
  254.                     break;
  255.  
  256.                 case GADID_CLOSESCREEN:
  257.                     ToClose=LockPubScreen(CurPubScreenName);
  258.                     
  259.                     if (ToClose==0) 
  260.                         {
  261.                         SetMessage("Unable to lock screen.");
  262.                         break;
  263.                         };
  264.                     
  265.                     if ((ToClose->Flags&SCREENTYPE)==WBENCHSCREEN)
  266.                         {
  267.                         SetMessage("Cannot close the workbench screen!");
  268.                         UnlockPubScreen(CurPubScreenName, ToClose);
  269.                         break;
  270.                         };
  271.  
  272.                     UnlockPubScreen(CurPubScreenName, ToClose);
  273.  
  274.                     ClosePSXWindow();
  275.                     ReleasePublicScreen();
  276.  
  277.                     if (ToClose)
  278.                         Result=CloseScreen(ToClose);
  279.                         else Result=FALSE;
  280.  
  281.                     FindPublicScreen();
  282.                     OpenPSXWindow();
  283.                     ScreenToFront(Screen);
  284.  
  285.                     if (Result==FALSE)
  286.                         SetMessage("Unable to close screen.");
  287.                         else SetMessage("Screen closed.");
  288.                     break;    
  289.                         
  290.                 case GADID_SCREENLIST:
  291.                     strcpy(CurPubScreenName, ScreenNamePointers[Code]);
  292.                     SetMessage("");
  293.                     break;
  294.  
  295.                 case GADID_MOVEPSX:
  296.                     ClosePSXWindow();
  297.                     ReleasePublicScreen();
  298.                     FindPublicScreen();
  299.                     OpenPSXWindow();
  300.                     ScreenToFront(Screen);
  301.                     SetMessage("PSX relocated.");
  302.                     break;
  303.  
  304.                 case GADID_QUIT:
  305.                     exit(0);
  306.     
  307.                 case GADID_MAKEDEFAULT:
  308.                     strcpy(MessageText, "'");
  309.                     strcat(MessageText, CurPubScreenName);
  310.                     strcat(MessageText, "' now the Default Public Screen");
  311.                     SetDefaultPubScreen(CurPubScreenName);
  312.                     SetMessage(NULL);
  313.                     break;
  314.             
  315.                 case GADID_REFRESH:
  316.                     ListViewTags[1]=-1;
  317.                     GT_SetGadgetAttrsA(LVGad, Window, 0, (struct TagItem *)ListViewTags);
  318.                     ListViewTags[1]=(ULONG)&ScreenList;
  319.                     BuildScreenList();
  320.                     GT_SetGadgetAttrsA(LVGad, Window, 0, (struct TagItem *)ListViewTags);
  321.                     SetMessage("Screen list refreshed.");
  322.                     break;
  323.  
  324.                 case GADID_SHANGHAI:
  325.                     if (Code)
  326.                         GlobalModes&=~SHANGHAI;
  327.                         else GlobalModes|=SHANGHAI;
  328.                     SetPubScreenModes(GlobalModes);
  329.                     break;
  330.  
  331.                 case GADID_POP:
  332.                     if (Code)
  333.                         GlobalModes&=~POPPUBSCREEN;
  334.                         else GlobalModes|=POPPUBSCREEN;
  335.                     SetPubScreenModes(GlobalModes);
  336.                     break;
  337.                 };
  338.             break;
  339.  
  340.         case CLOSEWINDOW:
  341.             exit(0);
  342.  
  343.         case REFRESHWINDOW:
  344.             GT_BeginRefresh(Window);
  345.             GT_EndRefresh(Window, TRUE);
  346.             break;
  347.         default:    
  348.             break;
  349.         };    
  350.     };
  351. }
  352.  
  353.  
  354.  
  355. /**********************************************************************/
  356. /*                 PSX enters and exits through here                  */
  357. /**********************************************************************/
  358. int
  359. main(int argc, char **argv)
  360. {
  361. struct RDArgs *RA;
  362. ULONG Args[12];
  363.  
  364. if (OpenLibraries(36)==FALSE)
  365.     {
  366.     PutStr("Unable to open 2.0+ libraries.\n");
  367.     CloseLibraries();
  368.     exit(20);
  369.     };
  370.  
  371. onexit(ExitRoutine);
  372.  
  373. GlobalModes=SetPubScreenModes(0);
  374. SetPubScreenModes(GlobalModes);
  375. setmem(Args, 10*sizeof(ULONG), 0);
  376.  
  377. if (argc<2)
  378.     MainLoop();
  379.     else
  380.     {
  381.     RA=ReadArgs("OPEN/K,CLOSE/K,HIRES/S,LACE/S,DEPTH/N,MAKEDEFAULT/S,SHANGHAI/S,NOSHANGHAI/S,POP/S,NOPOP/S,TOFRONT/K,TOBACK/K", &Args[0], NULL);
  382.  
  383.     if (RA)
  384.         {
  385.         if (Args[0])        // Open
  386.             {
  387.             CLIOpenNewPublicScreen(Args[0], Args[2], Args[3], Args[4], Args[5]);
  388.             };
  389.  
  390.         if (Args[1])        // Close
  391.             {
  392.             CLIClosePublicScreen(Args[1]);
  393.             };
  394.  
  395.         if (Args[6])
  396.             GlobalModes|=SHANGHAI;
  397.         if (Args[7])
  398.             GlobalModes&=~SHANGHAI;
  399.         if (Args[8])
  400.             GlobalModes|=POPPUBSCREEN;
  401.         if (Args[9])
  402.             GlobalModes&=~POPPUBSCREEN;        
  403.  
  404.         if (Args[10])
  405.             {
  406.             struct Screen *Screen=LockPubScreen((char *)Args[10]);
  407.             if (Screen) ScreenToFront(Screen);
  408.             UnlockPubScreen((UBYTE *)Args[10], Screen);
  409.             };
  410.  
  411.         if (Args[11])
  412.             {
  413.             struct Screen *Screen=LockPubScreen((char *)Args[11]);
  414.             if (Screen) ScreenToBack(Screen);
  415.             UnlockPubScreen((UBYTE *)Args[1], Screen);
  416.             };
  417.         
  418.         SetPubScreenModes(GlobalModes);
  419.  
  420.         FreeArgs(RA);
  421.         } else PutStr("Bad args.\n");
  422.     };
  423.  
  424. exit(0);
  425. }
  426.