home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / mac / source / luschsrc.sit / window.c.bin / window.c
Encoding:
C/C++ Source or Header  |  1990-01-26  |  10.6 KB  |  542 lines  |  [TEXT/KAHL]
  1.  /********************************************************************************
  2.  *    window.c
  3.  *
  4.  *    Window Management Package
  5.  *
  6.  *    Written by Paco Xander Nathan
  7.  *    ⌐1990, Motorola Inc.  Public domain source code.
  8.  ********************************************************************************/
  9.  
  10. #include "applic.h"
  11. #include "window.h"
  12. #include "dialog.h"
  13. #include "context.h"
  14. #include "document.h"
  15. #include "error.h"
  16. #include "text.h"
  17. #include "list.h"
  18.  
  19. #include "test.h"
  20.  
  21.  
  22. #define MAXPTRS    50
  23.  
  24.  
  25. typedef struct  {
  26.     short count;
  27.     WindowPtr wind[MAXPTRS];
  28. } WindPtrList;
  29.  
  30.  
  31. /* Local Data Structures
  32.  */
  33. static WindPtrList
  34.     windList;
  35.  
  36.  
  37. /* External Data Structures
  38.  */
  39. WindowPtr
  40.     wPtrText = NULL, 
  41.     wPtrTest = NULL,
  42.     wPtrGnos = NULL;
  43.  
  44. Rect 
  45.     dragArea,
  46.     growArea;
  47.     
  48. Boolean
  49.     windTrip = FALSE;
  50.  
  51.  
  52. /* Local Function Prototypes
  53.  */
  54. #ifdef PROTOTYPES
  55. void WindInvalGrow (WindowPtr theWindow);
  56. #endif
  57.  
  58.  
  59. /* Invalidate the grow box and scroll bar rectangles for the given window
  60.  */
  61. static void
  62. WindInvalGrow (theWindow)
  63.     register WindowPtr theWindow;
  64. {
  65.     Rect inval;
  66.     
  67.     /* Invalidate the verticle scroll
  68.      */
  69.     inval = theWindow->portRect;
  70.     inval.left = inval.right - 16;
  71.     InvalRect(&inval);
  72.  
  73.     /* Invalidate the horizontal scroll
  74.      */
  75.     inval = theWindow->portRect;
  76.     inval.top = inval.bottom - 16;
  77.     InvalRect(&inval);
  78. }
  79.  
  80.  
  81. /* Check if the front window is a modeless dialog that belongs to our application
  82.  */
  83. Boolean
  84. WindIsDlog (theWindow)
  85.     register WindowPtr theWindow;
  86. {
  87.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  88.  
  89.     return (theWindow != NULL) && (((WindowPeek) theWindow)->windowKind >= 0) && (infoPtr->kind == wkDlog);
  90. }
  91.  
  92.  
  93. /* Check if the front window belongs to our application
  94.  */
  95. Boolean
  96. WindIsApp (theWindow)
  97.     register WindowPtr theWindow;
  98. {
  99.     return (theWindow != NULL) && (((WindowPeek) theWindow)->windowKind >= 0);
  100. }
  101.  
  102.  
  103. /* Check if the front window belongs to a DA
  104.  */
  105. Boolean
  106. WindIsDA (theWindow)
  107.     register WindowPtr theWindow;
  108. {
  109.     return (theWindow != NULL) && (((WindowPeek) theWindow)->windowKind < 0);
  110. }
  111.  
  112.  
  113. /* Resize the window
  114.  */
  115. void
  116. WindGrow (theWindow, theEvent)
  117.     register WindowPtr theWindow;
  118.     register EventRecord *theEvent;
  119. {
  120.     GrafPtr savePort;
  121.     register long newSize;
  122.     register short newH, newV;
  123.  
  124.     GetPort(&savePort);
  125.     SetPort(theWindow);
  126.  
  127.     if (newSize = GrowWindow(theWindow, theEvent->where, &growArea)) {
  128.         newV = Max(HiWord(newSize), 20);
  129.         newH = Max(LoWord(newSize), 20);
  130.  
  131.         /* Resize the window, adjust window dimensions
  132.          */
  133.         SizeWindow(theWindow, newH, newV, TRUE);
  134.         WindAdjust(theWindow);
  135.         InvalRect(&theWindow->portRect);
  136.     }
  137.  
  138.     SetPort(savePort);
  139. }
  140.  
  141.  
  142. /* Zoom the window in or out
  143.  */
  144. void
  145. WindZoom (theWindow, thePart)
  146.     register WindowPtr theWindow;
  147.     register short thePart;
  148. {
  149.     GrafPtr savePort;
  150.  
  151.     GetPort(&savePort);
  152.     SetPort(theWindow);
  153.  
  154.     /* Zoom the window and adjust the window rect dimensions
  155.      */
  156.     HideWindow(theWindow);
  157.  
  158.     ZoomWindow(theWindow, thePart, TRUE);
  159.     WindAdjust(theWindow);
  160.     /* WindInvalGrow(theWindow); */
  161.  
  162.     ShowWindow(theWindow);
  163.     SetPort(savePort);
  164. }
  165.  
  166.  
  167. /* Reposition a window in the center of the screen
  168.  */
  169. void
  170. WindCenter (theWindow)
  171.     register WindowPtr theWindow;
  172. { 
  173.     register short hWind, vWind, hScrn, vScrn;
  174.  
  175.     hScrn = screenBits.bounds.right - screenBits.bounds.left;
  176.     vScrn = screenBits.bounds.bottom - screenBits.bounds.top;
  177.  
  178.     hWind = theWindow->portRect.right - theWindow->portRect.left;
  179.     vWind = theWindow->portRect.bottom - theWindow->portRect.top;
  180.  
  181.     /* Reset the horizontal and the vertical position
  182.      */
  183.     MoveWindow(theWindow, (hScrn - hWind) / 2, ((vScrn - vWind) / 3) + MBarHeight, FALSE);
  184. }
  185.  
  186.  
  187. /* Moves and sizes window to new location
  188.  */
  189. void 
  190. WindPlace (theWindow, left, top, right, bottom)
  191.     register WindowPtr theWindow;
  192.     register short left, top, right, bottom;
  193. {
  194.     /* Move window to a specified location in global coordinates
  195.      */
  196.     MoveWindow(theWindow, left, top, FALSE);
  197.     SizeWindow(theWindow, right - left, bottom - top, TRUE);
  198.     WindAdjust(theWindow);
  199. }
  200.  
  201.  
  202. /* Stacks windows diagonally based on constraint rect
  203.  */
  204. void
  205. WindTileStack ()
  206. {
  207.     register WORD width, height, vStagger, hStagger, i, j;
  208.     register WindowPtr theWindow = FrontWindow();
  209.     register WORD numWindows = 0;
  210.     GrafPtr savePort;
  211.  
  212.     GetPort(&savePort);
  213.  
  214.     /* Now we take a trip through the looking glass to build the list of
  215.      * OUR windows
  216.      */
  217.     while (theWindow != NULL) {
  218.         if (((WindowPeek) theWindow)->visible)
  219.                 windList.wind[numWindows++] = theWindow;
  220.  
  221.         theWindow = (WindowPtr) ((WindowPeek) theWindow)->nextWindow;
  222.     }
  223.  
  224.     if ((numWindows > 1) && (numWindows <= MAXPTRS)) {
  225.         height = (dragArea.bottom - dragArea.top) / 2;
  226.         width = (dragArea.right - dragArea.left) / 2;
  227.         vStagger = (height / (numWindows - 1)) + 1;
  228.         hStagger = (width / (numWindows - 1)) + 1;
  229.     
  230.         for (i = numWindows - 1; i >= 0; i--) {
  231.             if (theWindow = windList.wind[i]) {        
  232.                 SetPort(theWindow);
  233.                 WindActivate(theWindow, FALSE);
  234.  
  235.                 j = numWindows - i - 1;
  236.                 MoveWindow(theWindow, dragArea.left + (hStagger * j), dragArea.top + (vStagger * j) + 20, FALSE);
  237.             }
  238.         }
  239.         
  240.         SelectWindow(theWindow);
  241.     }
  242.     
  243.     /* Thank you for coming, see you later
  244.      */
  245.     windTrip = FALSE;
  246.     SetPort(savePort);
  247. }
  248.  
  249.  
  250. /* Draw an application window - switch on particular window to draw all the fancy
  251.  * bells and whistles
  252.  */
  253. void
  254. WindReDraw (theWindow)
  255.     register WindowPtr theWindow;
  256. {
  257.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  258.  
  259.     /* Determine which kind of window this is, then lock and update
  260.      */
  261.     switch(infoPtr->kind) {
  262.     case wkText:
  263.         TEUpdate(&theWindow->portRect, infoPtr->item.text.teHdl);
  264.         DrawControls(theWindow);
  265.         break;
  266.  
  267.     case wkList:
  268.         ListDraw(theWindow, TRUE);
  269.         break;
  270.         
  271.     default:
  272.         break;
  273.     }
  274. }
  275.  
  276.  
  277. /* Update a window
  278.  */
  279. void
  280. WindUpdate (theWindow)
  281.     register WindowPtr theWindow;
  282. {
  283.     GrafPtr savePort;
  284.  
  285.     GetPort(&savePort);
  286.     SetPort(theWindow);
  287.  
  288.     BeginUpdate(theWindow);
  289.  
  290.     if (!EmptyRgn(theWindow->visRgn)) {
  291.         ClipRect(&theWindow->portRect);
  292.         EraseRect(&theWindow->portRect);
  293.  
  294.         WindReDraw(theWindow);
  295.         /* DrawGrowIcon(theWindow); */
  296.  
  297.         /* Specially handle custom windows
  298.          */
  299.         if (theWindow == wPtrTest)
  300.             TestDraw();
  301.     }
  302.  
  303.     EndUpdate(theWindow);
  304.     SetPort(savePort);
  305. }
  306.  
  307.  
  308. /* Handle an activate/deactivate event
  309.  */
  310. void
  311. WindActivate (theWindow, isActive)
  312.     register WindowPtr theWindow;
  313.     register Boolean isActive;
  314. {
  315.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  316.     GrafPtr savePort;
  317.  
  318.     GetPort(&savePort);
  319.     SetPort(theWindow);
  320.  
  321.     /* Determine which kind of window this is, then lock and activate/deactivate
  322.      */
  323.     switch(infoPtr->kind) {
  324.     case wkText:
  325.         TextActivate(isActive, theWindow);
  326.         break;
  327.  
  328.     case wkList:
  329.         LActivate(isActive, infoPtr->item.list);
  330.         break;
  331.         
  332.     default:
  333.         break;
  334.     }
  335.  
  336.     /* Redraw the grow box
  337.      */
  338.     /* WindInvalGrow(theWindow); */
  339.  
  340.     SetPort(savePort);
  341. }
  342.  
  343.     
  344. /* Determine which kind of window to adjust
  345.  */
  346. void
  347. WindAdjust (theWindow)
  348.     register WindowPtr theWindow;
  349. {
  350.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  351.  
  352.     switch (infoPtr->kind) {
  353.     case wkText:
  354.         TextAdjust(theWindow);
  355.         break;
  356.  
  357.     case wkList:
  358.         ListAdjust(theWindow);
  359.         break;
  360.  
  361.     default:
  362.         break;
  363.     }
  364.  
  365.     /* Reset cliprect to new size.
  366.      */
  367.     ClipRect(&(theWindow->portRect));
  368. }
  369.  
  370.  
  371. /* Decide how to handle a mouse click in the content of a window
  372.  */
  373. void
  374. WindContent (theWindow, theEvent)
  375.     register WindowPtr theWindow;
  376.     register EventRecord *theEvent;
  377. {
  378.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  379.     GrafPtr savePort;
  380.     Point thePoint;
  381.  
  382.     /* Convert to global coordinates
  383.      */
  384.     GetPort(&savePort);
  385.     SetPort(theWindow);
  386.  
  387.     thePoint = theEvent->where;
  388.     GlobalToLocal(&thePoint);    
  389.  
  390.     if (theWindow == wPtrTest)
  391.         TestClick(thePoint);
  392.  
  393.     switch (infoPtr->kind) {
  394.     case wkText:
  395.         /* Click in one of the text windows
  396.          */
  397.         TextContent(theWindow, theEvent->modifiers, thePoint);
  398.         break;
  399.         
  400.     case wkList:
  401.         /* Click in one of the list windows
  402.          */
  403.         ListContent(theWindow, theEvent->modifiers, thePoint);
  404.         break;
  405.         
  406.     default:
  407.         break;
  408.     }
  409.     
  410.     SetPort(savePort);
  411. }
  412.  
  413.  
  414. /* Open or close a window context, depending on how "pleaseOpen" is set
  415.  */
  416. void 
  417. WindSwitch (theWindow, pleaseOpen)
  418.     register WindowPtr theWindow;
  419.     register Boolean pleaseOpen;
  420. {
  421.     register WindowPtr frontWind = FrontWindow();
  422.  
  423.     /* Open/Close the specified window
  424.      */
  425.     if (pleaseOpen) {
  426.         if (!((WindowPeek) theWindow)->visible) {
  427.             ShowHide(theWindow, TRUE);
  428.             windTrip = TRUE;
  429.         }
  430.  
  431.         if (theWindow != frontWind)
  432.             SelectWindow(theWindow);
  433.     }
  434.     else {
  435.         if (((WindowPeek) theWindow)->visible) {
  436.             WindActivate(theWindow, FALSE);
  437.             ShowHide(theWindow, FALSE);
  438.             windTrip = TRUE;
  439.         }
  440.     }
  441. }
  442.  
  443.  
  444. /* Allocate a new window based on the specified window template
  445.  */
  446. WindowPtr
  447. WindAllocate (windID, isActive)
  448.     register short windID;
  449.     register Boolean isActive;
  450. {
  451.     register WindowPtr theWindow;
  452.     register InfoPtr infoPtr;
  453.     register Rect bounds;
  454.     static short offset = 0;
  455.     GrafPtr savePort;
  456.  
  457.     /* Create the window record from the window template resources
  458.      */
  459.     if (laMachine.hasColor)
  460.         theWindow = (WindowPtr) GetNewCWindow(windID, NULL, -1L);
  461.     else
  462.         theWindow = (WindowPtr) GetNewWindow(windID, NULL, -1L);
  463.     
  464.     if (theWindow) {
  465.         GetPort(&savePort);
  466.         SetPort(theWindow);
  467.  
  468.         if (infoPtr = (InfoPtr) ErrNewPtr(sizeof(InfoRecord))) {
  469.         infoPtr->kind = wkNone;
  470.             infoPtr->active = isActive;
  471.             infoPtr->dirty = infoPtr->named = FALSE;
  472.             SetWRefCon(theWindow, (long) infoPtr);
  473.  
  474.             offset += 10;
  475.             bounds.left = dragArea.left + offset;
  476.             bounds.top = dragArea.top + offset + 30;
  477.             bounds.right = bounds.left + (theWindow->portRect.right - theWindow->portRect.left);
  478.             bounds.bottom = bounds.top + (theWindow->portRect.bottom - theWindow->portRect.top);
  479.             WindPlace(theWindow, bounds.left, bounds.top, bounds.right, bounds.bottom);
  480.         }
  481.         else {
  482.             DisposeWindow(theWindow);
  483.             theWindow = NULL;
  484.         }
  485.  
  486.         SetPort(savePort);
  487.     }
  488.     
  489.     return theWindow;
  490. }
  491.  
  492.  
  493. /* Close the specified window
  494.  */
  495. void
  496. WindClose (theWindow)
  497.     register WindowPtr theWindow;
  498. {
  499.     register InfoPtr infoPtr = (InfoPtr) GetWRefCon(theWindow);
  500.  
  501.     if ((theWindow == wPtrText) || (theWindow == dPtrAnal))
  502.         WindSwitch(theWindow, FALSE);
  503.     else if (theWindow == wPtrTest)
  504.         WindZapPort(theWindow, FALSE);
  505.     else if (infoPtr->kind == wkText) {
  506.         /* Deallocate a text window
  507.          */
  508.         DocClose(theWindow);
  509.         WindZapPort(theWindow, FALSE);
  510.         TEDispose(infoPtr->item.text.teHdl);
  511.         DisposeControl(infoPtr->item.text.scroll);
  512.         DisposPtr(infoPtr);
  513.         DisposeWindow(theWindow);
  514.     }
  515.     else if (infoPtr->kind == wkList) {
  516.         /* Deallocate a list window
  517.          */
  518.         WindZapPort(theWindow, FALSE);
  519.         LDispose(infoPtr->item.list);
  520.         DisposPtr(infoPtr);
  521.         DisposeWindow(theWindow);
  522.     }
  523.     else if (infoPtr->kind == wkDlog) {
  524.         /* Deallocate a modeless dialog window
  525.          */
  526.         DlogDispose(theWindow);
  527.     }
  528. }
  529.  
  530.  
  531. /* Zap the specified port open or closed
  532.  */
  533. void
  534. WindZapPort (wind, up)
  535.     register WindowPtr wind;
  536.     register Boolean up;
  537. {
  538.     /* Can't give it all away...
  539.      */
  540.     ShowHide(wind, up);
  541. }
  542.