home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / yak-1.59.lha / Yak-1.59 / Src / LastActiveWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-08  |  3.9 KB  |  226 lines
  1. /*
  2.  * LastActiveWindow.c
  3.  *
  4.  * Routines to make Yak remember last active window on screen already visited
  5.  * Part of Yak.
  6.  *
  7.  * Gael Marziou, 6/94.
  8.  */
  9. #include <exec/types.h>
  10. #include <intuition/intuition.h>
  11. #include <intuition/intuitionbase.h>
  12. #include <proto/exec.h>
  13. #include <proto/intuition.h>
  14.  
  15. #include "code.h"
  16.  
  17.  
  18. #define SCREEN_ARRAY_SIZE 10
  19.  
  20. struct {
  21.     struct Screen *Screen;
  22.     struct Window *Window;
  23. } ScreenArray[SCREEN_ARRAY_SIZE];
  24.  
  25.  
  26. /* Find a screen in our list */
  27.  
  28. UBYTE
  29. FoundScreenInList( struct Screen *Screen)
  30. {
  31.     UBYTE i=0;
  32.  
  33.     /* Try to found a screen that matches ours */
  34.     while ((ScreenArray[i].Screen  != Screen) && 
  35.            (i<SCREEN_ARRAY_SIZE-1))
  36.     {
  37.         i++;
  38.     }
  39.  
  40.     if ((i == SCREEN_ARRAY_SIZE - 1) && 
  41.         (ScreenArray[i].Screen  != Screen))
  42.     {
  43.         i = SCREEN_ARRAY_SIZE;
  44.     }
  45.     return(i);
  46. }
  47.  
  48. /* Try to find dead screens in our list in order to provide some space 
  49.  * If it succeeds, it will return a free index in ScreenArray otherwise 
  50.  * it will return SCREEN_ARRAY_SIZE.
  51.  */
  52.  
  53. UBYTE 
  54. GarbageCollectorScreenArray(void)
  55. {
  56.     struct Screen *scr;
  57.     UBYTE i;
  58.     ULONG lock;
  59.     BOOL  Lost;
  60.     UBYTE result = SCREEN_ARRAY_SIZE;
  61.  
  62.     lock = LockIBase(0);
  63.  
  64.     for (i=0; i<SCREEN_ARRAY_SIZE-1 ; i++)
  65.     {
  66.         Lost = TRUE;
  67.         for (scr = FS; scr && Lost ; scr = scr->NextScreen)
  68.         {
  69.             Lost = (scr != ScreenArray[i].Screen);
  70.         }
  71.         if (Lost)
  72.         {
  73.             /* Remove dead screen */
  74.             ScreenArray[i].Screen = NULL;
  75.             result = i;
  76.         }
  77.     }
  78.     UnlockIBase(lock);
  79.     return(result);
  80. }
  81.  
  82.  
  83. /* Store active window of current screen */
  84.  
  85. void
  86. RememberActiveWindow(void)
  87. {
  88.     ULONG lock;
  89.     struct Window *win;
  90.     UBYTE i;
  91.  
  92.     lock = LockIBase(0);
  93.     win = AW;
  94.     UnlockIBase(lock);
  95.  
  96.     if (win)
  97.     {
  98.         i = FoundScreenInList(win->WScreen);
  99.         if (i < SCREEN_ARRAY_SIZE)
  100.         {
  101.             ScreenArray[i].Window = win; 
  102.         }
  103.         else
  104.         {
  105.             /* Our screen hasn't been yet visited so add it to our list */
  106.             i = FoundScreenInList(NULL);
  107.             if (i == SCREEN_ARRAY_SIZE)
  108.             {
  109.                 /* We haven't found a free space, try to free some */
  110.                 i = GarbageCollectorScreenArray();
  111.             }
  112.             if (i < SCREEN_ARRAY_SIZE)
  113.             {
  114.                 /* We have found a free space */
  115.                 ScreenArray[i].Screen = win->WScreen;
  116.                 ScreenArray[i].Window = win; 
  117.             }
  118.         }
  119.     }
  120. }
  121.  
  122.  
  123. /* Returns a pointer on active window of last time we visit this screen 
  124.  * if possible.
  125.  */
  126.  
  127. struct Window 
  128. *LastActiveWindow(struct Screen *CurrentScreen)
  129. {
  130.     struct Window *win;
  131.     UBYTE i;
  132.  
  133.     if (CurrentScreen)
  134.     {
  135.         /* default */
  136.         win = CurrentScreen->FirstWindow;
  137.  
  138.         i = FoundScreenInList(CurrentScreen);    
  139.         if (i < SCREEN_ARRAY_SIZE)
  140.         {
  141.             /* Is our window still alive or still on our screen ? */
  142.             for (win = CurrentScreen->FirstWindow; win ; win = win->NextWindow)
  143.             {
  144.                 if (win == ScreenArray[i].Window)
  145.                     break;
  146.             }
  147.             if (!win) 
  148.                 win = CurrentScreen->FirstWindow;
  149.         }
  150.     }
  151.     else
  152.     {
  153.         win = NULL;
  154.     }
  155.     return(win);
  156. }
  157.  
  158.  
  159.  
  160.  
  161. #ifdef DEBUG_LAW
  162.  
  163. /* Well it has been debugged but who knows, it can help in the future */
  164.  
  165.  
  166. void
  167. main(void)
  168. {
  169.     char c = 0;
  170.     struct Screen *scr;
  171.     ULONG i;
  172.     ULONG lock;
  173.     
  174.     while(c!='q')
  175.     {
  176.         scanf("%c",&c);
  177.         switch (c)
  178.         {
  179.           case 'r':    
  180.             for (i=0; i<SCREEN_ARRAY_SIZE; i++)
  181.             {
  182.                 printf("i = %d\n",i);
  183.                 if (ScreenArray[i].Screen)
  184.                 {
  185.                     printf("ScreenArray[%d].Screen = %d\n",i,ScreenArray[i].Screen);
  186.                     if (ScreenArray[i].Window->Title)
  187.                         printf("ScreenArray[%d].Window->Title = %s\n",i,ScreenArray[i].Window->Title);
  188.                 }
  189.             }
  190.             break;
  191.  
  192.           case 'c':
  193.             lock = LockIBase(0);
  194.             scr = FS;
  195.             UnlockIBase(lock);
  196.             
  197.             RememberActiveWindow();
  198.             ScreenToFront(scr->NextScreen);
  199.             Delay(200);
  200.             RememberActiveWindow();
  201.             break;
  202.  
  203.           case 'g': 
  204.             GarbageCollectorScreenArray();
  205.             break;
  206.  
  207.           case 'a':
  208.             scanf("%d",&i);
  209.             if (LastActiveWindow(ScreenArray[i].Screen))
  210.             {
  211.                 if (LastActiveWindow(ScreenArray[i].Screen)->Title)
  212.                     printf("LastActiveWindow(ScreenArray[%d].Screen)->Title = %s\n",i,LastActiveWindow(ScreenArray[i].Screen)->Title);
  213.             }
  214.             else
  215.             {
  216.                 printf("NULL\n");
  217.             }
  218.             break;
  219.         }
  220.     }
  221.  
  222. }
  223.  
  224. #endif
  225.  
  226.