home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / vibrant / vibslate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-05  |  91.1 KB  |  3,500 lines  |  [TEXT/R*ch]
  1. /*   vibslate.c
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE
  5. *            National Center for Biotechnology Information (NCBI)
  6. *
  7. *  This software/database is a "United States Government Work" under the
  8. *  terms of the United States Copyright Act.  It was written as part of
  9. *  the author's official duties as a United States Government employee and
  10. *  thus cannot be copyrighted.  This software/database is freely available
  11. *  to the public for use. The National Library of Medicine and the U.S.
  12. *  Government do not place any restriction on its use or reproduction.
  13. *  We would, however, appreciate having the NCBI and the author cited in
  14. *  any work or product based on this material
  15. *
  16. *  Although all reasonable efforts have been taken to ensure the accuracy
  17. *  and reliability of the software and data, the NLM and the U.S.
  18. *  Government do not and cannot warrant the performance or results that
  19. *  may be obtained by using this software or data. The NLM and the U.S.
  20. *  Government disclaim all warranties, express or implied, including
  21. *  warranties of performance, merchantability or fitness for any particular
  22. *  purpose.
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  vibslate.c
  27. *
  28. * Author:  Jonathan Kans
  29. *
  30. * Version Creation Date:   7/1/91
  31. *
  32. * $Revision: 2.20 $
  33. *
  34. * File Description: 
  35. *       Vibrant slate (universal drawing environment) functions
  36. *
  37. * Modifications:  
  38. * --------------------------------------------------------------------------
  39. * Date     Name        Description of modification
  40. * -------  ----------  -----------------------------------------------------
  41. *
  42. *
  43. * ==========================================================================
  44. */
  45.  
  46. #include <vibtypes.h>
  47. #include <vibprocs.h>
  48. #include <vibincld.h>
  49.  
  50. #ifdef WIN_MAC
  51. #define Nlm_SlateTool Nlm_Handle
  52. #endif
  53.  
  54. #ifdef WIN_MSWIN
  55. #define Nlm_SlateTool HWND
  56. #endif
  57.  
  58. #ifdef WIN_MOTIF
  59. #define Nlm_SlateTool Widget
  60. #endif
  61.  
  62. typedef  struct  Nlm_slatedata {
  63.   Nlm_SlateTool    handle;
  64.   Nlm_BaR          vScrollBar;
  65.   Nlm_BaR          hScrollBar;
  66.   Nlm_Handle       rowHandles;
  67.   Nlm_Handle       colHandles;
  68.   Nlm_Int2         numRows;
  69.   Nlm_Int2         numCols;
  70.   Nlm_Boolean      border;
  71.   Nlm_Int2         barRows;
  72.   Nlm_Int2         vBefore;
  73.   Nlm_Int2         vAfter;
  74.   Nlm_SltScrlProc  vAction;
  75.   Nlm_SltCharProc  keyProc;
  76.   Nlm_Boolean      hasFocus;
  77. } Nlm_SlateData;
  78.  
  79. typedef  struct  Nlm_paneldata {
  80.   Nlm_PnlClckProc  click;
  81.   Nlm_PnlClckProc  drag;
  82.   Nlm_PnlClckProc  hold;
  83.   Nlm_PnlClckProc  release;
  84.   Nlm_PnlActnProc  draw;
  85.   Nlm_Int2         extra;
  86.   Nlm_PnlActnProc  reset;
  87.   Nlm_PaneL        prev;
  88. } Nlm_PanelData;
  89.  
  90. /* 
  91. *  Panel data is on top of a slate record to allow simple and
  92. *  autonomous panels (such as repeat buttons) to be implemented
  93. *  as single entities.
  94. */
  95.  
  96. typedef  struct  Nlm_panelslaterec {
  97.   Nlm_BoxRec     boxR;
  98.   Nlm_SlateData  slate;
  99.   Nlm_PanelData  panel;
  100. } Nlm_PanelRec, Nlm_SlateRec, PNTR Nlm_PnlPtr, PNTR Nlm_SltPtr;
  101.  
  102. typedef  struct  Nlm_offsetrec {
  103.   Nlm_Int2  offset;
  104.   Nlm_Int2  height;
  105. } Nlm_OffsetRec, PNTR Nlm_OfsPtr;
  106.  
  107. typedef struct Nlm_displaydata {
  108.   Nlm_Boolean  active;
  109.   Nlm_Boolean  changed;
  110.   Nlm_VoidPtr  buffer;
  111.   Nlm_Int2     offset;
  112.   Nlm_Int2     visLines;
  113.   Nlm_PoinT    cursorPos;
  114. } Nlm_DisplayData;
  115.  
  116. typedef struct Nlm_displayrec {
  117.   Nlm_PanelRec     panelR;
  118.   Nlm_DisplayData  display;
  119. } Nlm_DisplayRec, PNTR Nlm_DspPtr;
  120.  
  121. #define screenBufSize 100
  122.  
  123. static Nlm_GphPrcsPtr   gphprcsptr = NULL;
  124.  
  125. static Nlm_GphPrcsPtr   slateProcs;
  126. static Nlm_GphPrcsPtr   panelProcs;
  127. static Nlm_GphPrcsPtr   displayProcs;
  128.  
  129. static Nlm_SlatE        currentSlate = NULL;
  130.  
  131. static Nlm_SlatE        recentSlate = NULL;
  132. static Nlm_SlateData    recentSlateData;
  133.  
  134. static Nlm_SlatE        recentlyClickedSlate = NULL;
  135. static Nlm_Int4         lastClickTime = 0;
  136.  
  137. static Nlm_PaneL        recentlyClickedPanel = NULL;
  138.  
  139. static Nlm_DisplaY      recentDisplay = NULL;
  140. static Nlm_DisplayData  recentDisplayData;
  141.  
  142. static Nlm_Uint2        charCount;
  143. static Nlm_Uint2        screenPos;
  144. static Nlm_Char         screenBfr [screenBufSize];
  145.  
  146. static Nlm_Int2         disphght;
  147. static Nlm_FonT         dispfont;
  148.  
  149. #ifdef WIN_MSWIN
  150. static Nlm_Char         slateclass [32];
  151. static Nlm_Boolean      handlechar;
  152. static Nlm_SlateTool    slateTimer;
  153. static Nlm_Boolean      slateTimerUsed = FALSE;
  154. #endif
  155.  
  156. #ifdef WIN_MOTIF
  157. static XtIntervalId     slateTimer;
  158. static Nlm_Boolean      slateTimerUsed = FALSE;
  159. static Nlm_PoinT        currentMousePos;
  160. #endif
  161.  
  162. static void Nlm_LoadSlateData (Nlm_SlatE s, Nlm_SlateTool hdl,
  163.                                Nlm_BaR vsb, Nlm_BaR hsb,
  164.                                Nlm_Handle rhdl, Nlm_Handle chdl,
  165.                                Nlm_Int2 nrws, Nlm_Int2 ncls,
  166.                                Nlm_Boolean bdr, Nlm_Int2 barrws,
  167.                                Nlm_Int2 vbfr, Nlm_Int2 vaftr,
  168.                                Nlm_SltScrlProc vact, Nlm_SltCharProc key,
  169.                                Nlm_Boolean fcs)
  170.  
  171. {
  172.   Nlm_SltPtr     sp;
  173.   Nlm_SlateData  PNTR sptr;
  174.  
  175.   if (s != NULL) {
  176.     sp = (Nlm_SltPtr) Nlm_HandLock (s);
  177.     sptr = &(sp->slate);
  178.     sptr->handle = hdl;
  179.     sptr->vScrollBar = vsb;
  180.     sptr->hScrollBar = hsb;
  181.     sptr->rowHandles = rhdl;
  182.     sptr->colHandles = chdl;
  183.     sptr->numRows = nrws;
  184.     sptr->numCols = ncls;
  185.     sptr->border = bdr;
  186.     sptr->barRows = barrws;
  187.     sptr->vBefore = vbfr;
  188.     sptr->vAfter = vaftr;
  189.     sptr->vAction = vact;
  190.     sptr->keyProc = key;
  191.     sptr->hasFocus = fcs;
  192.     Nlm_HandUnlock (s);
  193.     recentSlate = NULL;
  194.   }
  195. }
  196.  
  197. static void Nlm_SetSlateData (Nlm_SlatE s, Nlm_SlateData * sdata)
  198.  
  199. {
  200.   Nlm_SltPtr  sp;
  201.  
  202.   if (s != NULL && sdata != NULL) {
  203.     sp = (Nlm_SltPtr) Nlm_HandLock (s);
  204.     sp->slate = *sdata;
  205.     Nlm_HandUnlock (s);
  206.     recentSlate = s;
  207.     recentSlateData = *sdata;
  208.   }
  209. }
  210.  
  211. static void Nlm_GetSlateData (Nlm_SlatE s, Nlm_SlateData * sdata)
  212.  
  213. {
  214.   Nlm_SltPtr  sp;
  215.  
  216.   if (s != NULL && sdata != NULL) {
  217.     if (s == recentSlate && NLM_RISKY) {
  218.       *sdata = recentSlateData;
  219.     } else {
  220.       sp = (Nlm_SltPtr) Nlm_HandLock (s);
  221.       *sdata = sp->slate;
  222.       Nlm_HandUnlock (s);
  223.       recentSlate = s;
  224.       recentSlateData = *sdata;
  225.     }
  226.   }
  227. }
  228.  
  229. static void Nlm_LoadPanelData (Nlm_PaneL p, Nlm_PnlClckProc clk,
  230.                                Nlm_PnlClckProc drg, Nlm_PnlClckProc hld,
  231.                                Nlm_PnlClckProc rls, Nlm_PnlActnProc drw,
  232.                                Nlm_Int2 xtra, Nlm_PnlActnProc rst,
  233.                                Nlm_PaneL prv)
  234.  
  235. {
  236.   Nlm_PnlPtr     pp;
  237.   Nlm_PanelData  PNTR pptr;
  238.  
  239.   if (p != NULL) {
  240.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  241.     pptr = &(pp->panel);
  242.     pptr->click = clk;
  243.     pptr->drag = drg;
  244.     pptr->hold = hld;
  245.     pptr->release = rls;
  246.     pptr->draw = drw;
  247.     pptr->extra = xtra;
  248.     pptr->reset = rst;
  249.     pptr->prev = prv;
  250.     Nlm_HandUnlock (p);
  251.   }
  252. }
  253.  
  254. #ifdef DCLAP
  255. extern void Nlm_ClearPanelData (Nlm_PaneL p)
  256. {
  257.     /* clean out panel pointers so damn Xwindow callbacks stop calling dead subviews 
  258.         for draw updates in dead windows @! */
  259.   Nlm_PnlPtr     pp;
  260.   Nlm_PanelData  PNTR pptr;
  261.   if (p != NULL) {
  262.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  263.     pptr = &(pp->panel);
  264.     pptr->click = NULL;
  265.     pptr->drag = NULL;
  266.     pptr->hold = NULL;
  267.     pptr->release = NULL;
  268.     pptr->draw = NULL;
  269.     pptr->extra = 0; /*NULL; -- dgg */
  270.     pptr->reset = NULL;
  271.     pptr->prev = NULL;
  272.     Nlm_HandUnlock (p);
  273.   }
  274. }
  275.  
  276. #endif
  277.  
  278. static void Nlm_SetPanelData (Nlm_PaneL p, Nlm_PanelData * pdata)
  279.  
  280. {
  281.   Nlm_PnlPtr  pp;
  282.  
  283.   if (p != NULL && pdata != NULL) {
  284.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  285.     pp->panel = *pdata;
  286.     Nlm_HandUnlock (p);
  287.   }
  288. }
  289.  
  290. static void Nlm_GetPanelData (Nlm_PaneL p, Nlm_PanelData * pdata)
  291.  
  292. {
  293.   Nlm_PnlPtr  pp;
  294.  
  295.   if (p != NULL && pdata != NULL) {
  296.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  297.     *pdata = pp->panel;
  298.     Nlm_HandUnlock (p);
  299.   }
  300. }
  301.  
  302. static void Nlm_LoadDisplayData (Nlm_DisplaY d, Nlm_Boolean actv,
  303.                                  Nlm_Boolean chgd, Nlm_VoidPtr bufr,
  304.                                  Nlm_Int2 off, Nlm_Int2 vis,
  305.                                  Nlm_PoinT pos)
  306.  
  307. {
  308.   Nlm_DisplayData  PNTR ddptr;
  309.   Nlm_DspPtr       dp;
  310.  
  311.   if (d != NULL) {
  312.     dp = (Nlm_DspPtr) Nlm_HandLock (d);
  313.     ddptr = &(dp->display);
  314.     ddptr->active = actv;
  315.     ddptr->changed = chgd;
  316.     ddptr->buffer = bufr;
  317.     ddptr->offset = off;
  318.     ddptr->visLines = vis;
  319.     ddptr->cursorPos = pos;
  320.     Nlm_HandUnlock (d);
  321.     recentDisplay = NULL;
  322.   }
  323. }
  324.  
  325. static void Nlm_SetDisplayData (Nlm_DisplaY d, Nlm_DisplayData * ddata)
  326.  
  327. {
  328.   Nlm_DspPtr  dp;
  329.  
  330.   if (d != NULL && ddata != NULL) {
  331.     dp = (Nlm_DspPtr) Nlm_HandLock (d);
  332.     dp->display = *ddata;
  333.     Nlm_HandUnlock (d);
  334.     recentDisplay = d;
  335.     recentDisplayData = *ddata;
  336.   }
  337. }
  338.  
  339. static void Nlm_GetDisplayData (Nlm_DisplaY d, Nlm_DisplayData * ddata)
  340.  
  341. {
  342.   Nlm_DspPtr  dp;
  343.  
  344.   if (d != NULL && ddata != NULL) {
  345.     if (d == recentDisplay && NLM_RISKY) {
  346.       *ddata = recentDisplayData;
  347.     } else {
  348.       dp = (Nlm_DspPtr) Nlm_HandLock (d);
  349.       *ddata = dp->display;
  350.       Nlm_HandUnlock (d);
  351.       recentDisplay = d;
  352.       recentDisplayData = *ddata;
  353.     }
  354.   }
  355. }
  356.  
  357. extern void Nlm_SetPanelExtra (Nlm_PaneL p, Nlm_VoidPtr sptr)
  358.  
  359. {
  360.   Nlm_BytePtr  dst;
  361.   Nlm_Int2     extra;
  362.   Nlm_PnlPtr   pp;
  363.   Nlm_BytePtr  src;
  364.  
  365.   if (p != NULL && sptr != NULL) {
  366.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  367.     extra = pp->panel.extra;
  368.     dst = (Nlm_BytePtr) pp + sizeof (Nlm_PanelRec);
  369.     src = (Nlm_BytePtr) sptr;
  370.     while (extra > 0) {
  371.       *dst = *src;
  372.       dst++;
  373.       src++;
  374.       extra--;
  375.     }
  376.     Nlm_HandUnlock (p);
  377.   }
  378. }
  379.  
  380. extern void Nlm_GetPanelExtra (Nlm_PaneL p, Nlm_VoidPtr sptr)
  381.  
  382. {
  383.   Nlm_BytePtr  dst;
  384.   Nlm_Int2     extra;
  385.   Nlm_PnlPtr   pp;
  386.   Nlm_BytePtr  src;
  387.  
  388.   if (p != NULL && sptr != NULL) {
  389.     pp = (Nlm_PnlPtr) Nlm_HandLock (p);
  390.     extra = pp->panel.extra;
  391.     src = (Nlm_BytePtr) pp + sizeof (Nlm_PanelRec);
  392.     dst = (Nlm_BytePtr) sptr;
  393.     while (extra > 0) {
  394.       *dst = *src;
  395.       dst++;
  396.       src++;
  397.       extra--;
  398.     }
  399.     Nlm_HandUnlock (p);
  400.   }
  401. }
  402.  
  403. static Nlm_SlateTool Nlm_GetSlateHandle (Nlm_SlatE s)
  404.  
  405. {
  406.   Nlm_SlateData  sdata;
  407.  
  408.   Nlm_GetSlateData (s, &sdata);
  409.   return sdata.handle;
  410. }
  411.  
  412. extern Nlm_BaR Nlm_GetSlateVScrollBar (Nlm_SlatE s)
  413.  
  414. {
  415.   Nlm_SlateData  sdata;
  416.  
  417.   Nlm_GetSlateData (s, &sdata);
  418.   return sdata.vScrollBar;
  419. }
  420.  
  421. extern Nlm_BaR Nlm_GetSlateHScrollBar (Nlm_SlatE s)
  422.  
  423. {
  424.   Nlm_SlateData  sdata;
  425.  
  426.   Nlm_GetSlateData (s, &sdata);
  427.   return sdata.hScrollBar;
  428. }
  429.  
  430. static Nlm_Handle Nlm_GetSlateRowHandles (Nlm_SlatE s)
  431.  
  432. {
  433.   Nlm_SlateData  sdata;
  434.  
  435.   Nlm_GetSlateData (s, &sdata);
  436.   return sdata.rowHandles;
  437. }
  438.  
  439. static Nlm_Handle Nlm_GetSlateColHandles (Nlm_SlatE s)
  440.  
  441. {
  442.   Nlm_SlateData  sdata;
  443.  
  444.   Nlm_GetSlateData (s, &sdata);
  445.   return sdata.colHandles;
  446. }
  447.  
  448. static Nlm_Int2 Nlm_GetSlateNumRows (Nlm_SlatE s)
  449.  
  450. {
  451.   Nlm_SlateData  sdata;
  452.  
  453.   Nlm_GetSlateData (s, &sdata);
  454.   return sdata.numRows;
  455. }
  456.  
  457. static Nlm_Int2 Nlm_GetSlateNumCols (Nlm_SlatE s)
  458.  
  459. {
  460.   Nlm_SlateData  sdata;
  461.  
  462.   Nlm_GetSlateData (s, &sdata);
  463.   return sdata.numCols;
  464. }
  465.  
  466. static Nlm_Boolean Nlm_GetSlateBorder (Nlm_SlatE s)
  467.  
  468. {
  469.   Nlm_SlateData  sdata;
  470.  
  471.   Nlm_GetSlateData (s, &sdata);
  472.   return sdata.border;
  473. }
  474.  
  475. /* dgg -- fix for content drawing erasing border frame */
  476. static void Nlm_DrawSlateBorder (Nlm_SlatE s)
  477. {
  478.     Nlm_RecT     r;
  479.   if (Nlm_GetSlateBorder( s)) {
  480.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  481.       Nlm_InsetRect( &r, -1, -1); /* needs an outset so content draw dosn't wipe it out */
  482.     Nlm_FrameRect (&r);
  483.     }
  484. }
  485.  
  486. /* dgg -- lets turn off that border sometimes */
  487.  
  488. extern void Nlm_SetSlateBorder (Nlm_SlatE s, Nlm_Boolean turnon)
  489.  
  490. {
  491.   Nlm_SlateData  sdata;
  492.  
  493.   Nlm_GetSlateData (s, &sdata);
  494.   sdata.border = turnon;
  495.   Nlm_SetSlateData (s, &sdata);
  496. }
  497.  
  498. static Nlm_SltCharProc Nlm_GetSlateCharProc (Nlm_SlatE s)
  499.  
  500. {
  501.   Nlm_SlateData  sdata;
  502.  
  503.   Nlm_GetSlateData (s, &sdata);
  504.   return sdata.keyProc;
  505. }
  506.  
  507. extern void Nlm_SetSlateChar (Nlm_SlatE s, Nlm_SltCharProc chr)
  508.  
  509. {
  510.   Nlm_SlateData  sdata;
  511.  
  512.   Nlm_GetSlateData (s, &sdata);
  513.   sdata.keyProc = chr;
  514.   Nlm_SetSlateData (s, &sdata);
  515. }
  516.  
  517. static Nlm_Boolean Nlm_SlateHasFocus (Nlm_SlatE s)
  518.  
  519. {
  520.   Nlm_SlateData  sdata;
  521.  
  522.   Nlm_GetSlateData (s, &sdata);
  523.   return sdata.hasFocus;
  524. }
  525.  
  526. static void Nlm_ChangeSlateFocus (Nlm_SlatE s, Nlm_Boolean fcs)
  527.  
  528. {
  529.   Nlm_SlateData  sdata;
  530.  
  531.   Nlm_GetSlateData (s, &sdata);
  532.   sdata.hasFocus = fcs;
  533.   Nlm_SetSlateData (s, &sdata);
  534. }
  535.  
  536. static Nlm_PnlClckProc Nlm_GetPanelClick (Nlm_PaneL p)
  537.  
  538. {
  539.   Nlm_PanelData  pdata;
  540.  
  541.   Nlm_GetPanelData (p, &pdata);
  542.   return pdata.click;
  543. }
  544.  
  545. static Nlm_PnlClckProc Nlm_GetPanelDrag (Nlm_PaneL p)
  546.  
  547. {
  548.   Nlm_PanelData  pdata;
  549.  
  550.   Nlm_GetPanelData (p, &pdata);
  551.   return pdata.drag;
  552. }
  553.  
  554. static Nlm_PnlClckProc Nlm_GetPanelHold (Nlm_PaneL p)
  555.  
  556. {
  557.   Nlm_PanelData  pdata;
  558.  
  559.   Nlm_GetPanelData (p, &pdata);
  560.   return pdata.hold;
  561. }
  562.  
  563. static Nlm_PnlClckProc Nlm_GetPanelRelease (Nlm_PaneL p)
  564.  
  565. {
  566.   Nlm_PanelData  pdata;
  567.  
  568.   Nlm_GetPanelData (p, &pdata);
  569.   return pdata.release;
  570. }
  571.  
  572. static Nlm_PnlActnProc Nlm_GetPanelDraw (Nlm_PaneL p)
  573.  
  574. {
  575.   Nlm_PanelData  pdata;
  576.  
  577.   Nlm_GetPanelData (p, &pdata);
  578.   return pdata.draw;
  579. }
  580.  
  581. static void Nlm_SetPanelPrev (Nlm_PaneL p, Nlm_PaneL prv)
  582.  
  583. {
  584.   Nlm_PanelData  pdata;
  585.  
  586.   Nlm_GetPanelData (p, &pdata);
  587.   pdata.prev = prv;
  588.   Nlm_SetPanelData (p, &pdata);
  589. }
  590.  
  591. static Nlm_PaneL Nlm_GetPanelPrev (Nlm_PaneL p)
  592.  
  593. {
  594.   Nlm_PanelData  pdata;
  595.  
  596.   Nlm_GetPanelData (p, &pdata);
  597.   return pdata.prev;
  598. }
  599.  
  600. static Nlm_Int2 Nlm_GetDisplayVisLines (Nlm_DisplaY d)
  601.  
  602. {
  603.   Nlm_DisplayData  ddata;
  604.  
  605.   Nlm_GetDisplayData (d, &ddata);
  606.   return ddata.visLines;
  607. }
  608.  
  609. static void Nlm_SetCursorPos (Nlm_DisplaY d, Nlm_PoinT pt)
  610.  
  611. {
  612.   Nlm_DisplayData  ddata;
  613.  
  614.   Nlm_GetDisplayData (d, &ddata);
  615.   ddata.cursorPos = pt;
  616.   Nlm_SetDisplayData (d, &ddata);
  617. }
  618.  
  619. static void Nlm_GetCursorPos (Nlm_DisplaY d, Nlm_PointPtr pt)
  620.  
  621. {
  622.   Nlm_DisplayData  ddata;
  623.  
  624.   Nlm_GetDisplayData (d, &ddata);
  625.   *pt = ddata.cursorPos;
  626. }
  627.  
  628. static Nlm_PaneL Nlm_CreateReverseLinks (Nlm_SlatE s)
  629.  
  630. {
  631.   Nlm_PaneL  last;
  632.   Nlm_PaneL  n;
  633.   Nlm_PaneL  p;
  634.  
  635.   p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  636.   Nlm_SetPanelPrev (p, NULL);
  637.   last = p;
  638.   while (p != NULL) {
  639.     n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  640.     if (n != NULL) {
  641.       Nlm_SetPanelPrev (n, p);
  642.       last = n;
  643.     }
  644.     p = n;
  645.   }
  646.   return last;
  647. }
  648.  
  649. #ifdef WIN_MAC
  650. static Nlm_Boolean Nlm_SlateClick (Nlm_GraphiC s, Nlm_PoinT pt)
  651.  
  652. {
  653.   Nlm_PnlClckProc  clk;
  654.   Nlm_Int4         delta;
  655.   Nlm_PnlClckProc  drg;
  656.   Nlm_Int2         hOffset;
  657.   Nlm_BaR          hsb;
  658.   Nlm_PoinT        mpt;
  659.   Nlm_PaneL        n;
  660.   Nlm_Int4         newtime;
  661.   Nlm_Boolean      notInside;
  662.   Nlm_Int4         oldtime;
  663.   Nlm_PoinT        opt;
  664.   Nlm_PaneL        p;
  665.   Nlm_PanelData    pdata;
  666.   Nlm_PnlClckProc  prs;
  667.   Nlm_RecT         r;
  668.   Nlm_PnlClckProc  rls;
  669.   Nlm_Boolean      rsult;
  670.   Nlm_RecT         sr;
  671.   Nlm_Int4         ticks;
  672.   Nlm_Int2         vOffset;
  673.   Nlm_BaR          vsb;
  674.  
  675.   ticks = Nlm_ComputerTime ();
  676.   rsult = FALSE;
  677.   Nlm_GetRect (s, &r);
  678.   Nlm_GetRect (s, &sr);
  679.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  680.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  681.   if (vsb != NULL) {
  682.     r.right += Nlm_vScrollBarWidth;
  683.   }
  684.   if (hsb != NULL) {
  685.     r.bottom += Nlm_hScrollBarHeight;
  686.   }
  687.   if (Nlm_PtInRect (pt, &r)) {
  688.     if ((Nlm_SlatE) s == recentlyClickedSlate) {
  689.       delta = ticks - lastClickTime;
  690.       if (delta <= GetDblTime ()) {
  691.         Nlm_dblClick = TRUE;
  692.       }
  693.     }
  694.     lastClickTime = ticks;
  695.     recentlyClickedSlate = (Nlm_SlatE) s;
  696.     recentlyClickedPanel = NULL;
  697.     if (vsb != NULL) {
  698.       r.right -= Nlm_vScrollBarWidth;
  699.     }
  700.     if (hsb != NULL) {
  701.       r.bottom -= Nlm_hScrollBarHeight;
  702.     }
  703.     if (vsb != NULL && Nlm_DoClick ((Nlm_GraphiC) vsb, pt)) {
  704.       Nlm_dblClick = FALSE;
  705.       recentlyClickedSlate = NULL;
  706.     } else if (hsb != NULL && Nlm_DoClick ((Nlm_GraphiC) hsb, pt)) {
  707.       Nlm_dblClick = FALSE;
  708.       recentlyClickedSlate = NULL;
  709.     } else if (Nlm_PtInRect (pt, &r)) {
  710.       Nlm_SelectFont (Nlm_systemFont);
  711.       Nlm_ResetDrawingTools ();
  712.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  713.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  714.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  715.         p = (Nlm_PaneL) s;
  716.         recentlyClickedPanel = p;
  717.         clk = Nlm_GetPanelClick (p);
  718.         if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p) && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  719.           Nlm_ClipRect (&sr);
  720.           clk (p, pt);
  721.           Nlm_Update ();
  722.         }
  723.       } else {
  724.         p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  725.         notInside = TRUE;
  726.         while (p != NULL && notInside) {
  727.           n = Nlm_GetPanelPrev (p);
  728.           Nlm_GetPanelData (p, &pdata);
  729.           if (pdata.click != NULL || pdata.drag != NULL ||
  730.               pdata.hold != NULL || pdata.release != NULL) {
  731.             Nlm_GetRect ((Nlm_GraphiC) p, &r);
  732.             Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  733.             Nlm_OffsetRect (&r, -hOffset, -vOffset);
  734.             if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  735.                 Nlm_GetVisible ((Nlm_GraphiC) p)) {
  736.               recentlyClickedPanel = p;
  737.               notInside = FALSE;
  738.               clk = Nlm_GetPanelClick (p);
  739.               if (clk != NULL) {
  740.                 Nlm_ClipRect (&sr);
  741.                 clk (p, pt);
  742.                 Nlm_Update ();
  743.               }
  744.             }
  745.           }
  746.           p = n;
  747.         }
  748.       }
  749.       if (recentlyClickedPanel != NULL) {
  750.         p = recentlyClickedPanel;
  751.         mpt = pt;
  752.         oldtime = Nlm_ComputerTime ();
  753.         drg = Nlm_GetPanelDrag (p);
  754.         prs = Nlm_GetPanelHold (p);
  755.         while (StillDown () && recentlyClickedPanel != NULL) {
  756.           opt = mpt;
  757.           newtime = Nlm_ComputerTime ();
  758.           Nlm_MousePosition (&mpt);
  759.           if (Nlm_EqualPt (opt, mpt)) {
  760.             if (prs != NULL && newtime >= oldtime + 6) {
  761.               Nlm_ResetDrawingTools ();
  762.               Nlm_ClipRect (&sr);
  763.               prs (p, mpt);
  764.               oldtime += 6;
  765.             }
  766.           } else {
  767.             if (drg != NULL) {
  768.               Nlm_ResetDrawingTools ();
  769.               Nlm_ClipRect (&sr);
  770.               drg (p, mpt);
  771.             }
  772.           }
  773.           Nlm_Update ();
  774.           Nlm_ProcessTimerEvent ();
  775.         }
  776.         rls = Nlm_GetPanelRelease (p);
  777.         if (rls != NULL && recentlyClickedPanel != NULL) {
  778.           Nlm_MousePosition (&mpt);
  779.           Nlm_ResetDrawingTools ();
  780.           Nlm_ClipRect (&sr);
  781.           rls (p, mpt);
  782.         }
  783.       }
  784.       Nlm_SelectFont (Nlm_systemFont);
  785.       Nlm_ResetDrawingTools ();
  786.       Nlm_ResetClip ();
  787.       rsult = TRUE;
  788.     }
  789.   }
  790.   return rsult;
  791. }
  792.  
  793. static Nlm_Boolean Nlm_SlateKey (Nlm_GraphiC s, Nlm_Char ch)
  794.  
  795. {
  796.   Nlm_Boolean      act;
  797.   Nlm_SltCharProc  keyProc;
  798.   Nlm_Boolean      rsult;
  799.  
  800.   rsult = FALSE;
  801.   act = Nlm_SlateHasFocus ((Nlm_SlatE) s);
  802.   if (act && ! Nlm_cmmdKey) {
  803.     if (ch != '\0') {
  804.       keyProc = Nlm_GetSlateCharProc ((Nlm_SlatE) s);
  805.       if (keyProc != NULL) {
  806.         keyProc ((Nlm_SlatE) s, ch);
  807.         rsult = TRUE;
  808.       }
  809.     }
  810.   }
  811.   return rsult;
  812. }
  813. #endif
  814.  
  815. #ifdef WIN_MSWIN
  816. static Nlm_Boolean Nlm_SlateCommand (Nlm_GraphiC s)
  817.  
  818. {
  819.   return FALSE;
  820. }
  821. #endif
  822.  
  823. #ifdef WIN_MOTIF
  824. static void Nlm_SlateCallback (Nlm_GraphiC s)
  825.  
  826. {
  827. }
  828. #endif
  829.  
  830. #ifdef WIN_MAC
  831. static void Nlm_DrawSlate (Nlm_GraphiC s)
  832.  
  833. {
  834.   Nlm_PnlActnProc  drw;
  835.   Nlm_BaR          hsb;
  836.   Nlm_PaneL        n;
  837.   Nlm_PaneL        p;
  838.   Nlm_PanelData    pdata;
  839.   Nlm_RecT         r;
  840.   Nlm_BaR          vsb;
  841.  
  842.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  843.     Nlm_GetRect (s, &r);
  844.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  845.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  846.     if (vsb != NULL) {
  847.       r.right += Nlm_vScrollBarWidth;
  848.     }
  849.     if (hsb != NULL) {
  850.       r.bottom += Nlm_hScrollBarHeight;
  851.     }
  852.     if (Nlm_RectInRgn (&r, Nlm_updateRgn)) {
  853.       if (vsb != NULL) {
  854.         Nlm_DoDraw ((Nlm_GraphiC) vsb);
  855.       }
  856.       if (hsb != NULL) {
  857.         Nlm_DoDraw ((Nlm_GraphiC) hsb);
  858.       }
  859. #ifndef DCLAP
  860.       Nlm_SelectFont (Nlm_systemFont);
  861. #endif
  862.       Nlm_ResetDrawingTools ();
  863.             Nlm_DrawSlateBorder( (Nlm_SlatE) s);
  864.       Nlm_GetRect (s, &r);
  865.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  866.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  867.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  868.         p = (Nlm_PaneL) s;
  869. /*
  870.         recentlyClickedPanel = p;
  871. */
  872.         drw = Nlm_GetPanelDraw (p);
  873.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  874.           Nlm_ClipRect (&r);
  875.           drw (p);
  876.           Nlm_ResetDrawingTools ();
  877.         }
  878.       } else {
  879.         p = (Nlm_PaneL) Nlm_GetChild (s);
  880.         while (p != NULL) {
  881.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  882.           drw = Nlm_GetPanelDraw (p);
  883.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  884.             Nlm_ClipRect (&r);
  885.             drw (p);
  886.             Nlm_ResetDrawingTools ();
  887.           }
  888.           p = n;
  889.         }
  890.       }
  891.       Nlm_ResetClip ();
  892.     }
  893.   }
  894. }
  895. #endif
  896.  
  897. static void Nlm_SlateVertScrollAction (Nlm_BaR sb, Nlm_SlatE s,
  898.                                        Nlm_Int2 newval, Nlm_Int2 oldval)
  899.  
  900. {
  901.   Nlm_SltScrlProc  actn;
  902.   Nlm_Int2         barRows;
  903.   Nlm_Int2         before;
  904.   Nlm_Int2         delta;
  905.   Nlm_Int2         height;
  906.   Nlm_Int2         i;
  907.   Nlm_Int2         last;
  908.   Nlm_Int2         limit;
  909.   Nlm_Int2         numRows;
  910.   Nlm_Int2         oldPgDn;
  911.   Nlm_OfsPtr       optr;
  912.   Nlm_Int2         pgDn;
  913.   Nlm_Int2         pgUp;
  914.   Nlm_RecT         r;
  915.   Nlm_Handle       rhdl;
  916.   Nlm_SlateData    sdata;
  917.  
  918.   if (s != NULL && oldval != newval) {
  919.     if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  920.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  921. #ifdef DCLAP
  922.            Nlm_InsetRect (&r, 1, 1);
  923.                 /* dgg -- why this 4pt inset?? it leaves other drawn contents hanging messy */
  924. #else
  925.       Nlm_InsetRect (&r, 4, 4);
  926. #endif
  927.       height = r.bottom - r.top;
  928.       Nlm_GetSlateData (s, &sdata);
  929.       numRows = sdata.numRows;
  930.       before = sdata.vBefore;
  931.       barRows = sdata.barRows;
  932.       if (newval >= before && newval <= before + barRows) {
  933.         newval -= before;
  934.         oldval -= before;
  935.         rhdl = sdata.rowHandles;
  936.         if (rhdl != NULL) {
  937.           optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  938.           i = newval + 1;
  939.           pgDn = 0;
  940.           while (i < numRows && optr [i].offset + optr [i].height -
  941.                  optr [newval].offset <= height) {
  942.             i++;
  943.             pgDn++;
  944.           }
  945.           i = newval - 1;
  946.           pgUp = 0;
  947.           while (i >= 0 && optr [newval].offset + optr [newval].height -
  948.                  optr [i].offset <= height) {
  949.             i--;
  950.             pgUp++;
  951.           }
  952.           delta = optr [oldval].offset - optr [newval].offset;
  953.           if (delta < 0) {
  954.             i = oldval + 1;
  955.             oldPgDn = 0;
  956.             while (i < numRows && optr [i].offset + optr [i].height -
  957.                    optr [oldval].offset <= height) {
  958.               i++;
  959.               oldPgDn++;
  960.             }
  961.             last = oldval + oldPgDn;
  962.             limit = r.top + optr [last].offset + optr [last].height  - optr [newval].offset;
  963.           } else if (delta > 0) {
  964.             last = newval + pgDn;
  965.             limit = r.top + optr [last].offset + optr [last].height  - optr [newval].offset;
  966.           }
  967.           Nlm_HandUnlock (rhdl);
  968.           Nlm_DoSelect ((Nlm_GraphiC) s, FALSE);
  969.           if (delta < 0 && -delta < height) {
  970.             Nlm_ScrollRect (&r, 0, delta);
  971.             r.top = limit;
  972.             Nlm_InsetRect (&r, -1, -1);
  973.             Nlm_InvalRect (&r);
  974.           } else if (delta > 0 && delta < height) {
  975.             Nlm_ScrollRect (&r, 0, delta);
  976.             r.top = limit;
  977.             Nlm_InsetRect (&r, -1, -1);
  978.             Nlm_InvalRect (&r);
  979.           } else {
  980.             Nlm_InsetRect (&r, -1, -1);
  981.             Nlm_InvalRect (&r);
  982.           }
  983.           if (pgUp < 1) {
  984.             pgUp = 1;
  985.           }
  986.           if (pgDn < 1) {
  987.             pgDn = 1;
  988.           }
  989.           Nlm_DoSetRange ((Nlm_GraphiC) sb, pgUp, pgDn, 0, FALSE);
  990.           Nlm_Update ();
  991.         }
  992.       } else {
  993.         actn = sdata.vAction;
  994.         if (actn != NULL) {
  995.           actn (sb, s, newval, oldval);
  996.         }
  997.       }
  998.     }
  999.   }
  1000. }
  1001.  
  1002. static void Nlm_SlateHorizScrollAction (Nlm_BaR sb, Nlm_SlatE s,
  1003.                                         Nlm_Int2 newval, Nlm_Int2 oldval)
  1004.  
  1005. {
  1006. }
  1007.  
  1008. static void Nlm_ShowSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1009.  
  1010. {
  1011.   Nlm_SlateTool  h;
  1012.   Nlm_BaR        hsb;
  1013.   Nlm_WindoW     tempPort;
  1014.   Nlm_BaR        vsb;
  1015.  
  1016.   if (setFlag) {
  1017.     Nlm_SetVisible (s, TRUE);
  1018.   }
  1019.   if (Nlm_GetVisible (s) && Nlm_AllParentsButWindowVisible (s)) {
  1020.     tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1021.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1022.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1023.     if (vsb != NULL) {
  1024.       Nlm_DoShow ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1025.     }
  1026.     if (hsb != NULL) {
  1027.       Nlm_DoShow ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1028.     }
  1029.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1030. #ifdef WIN_MAC
  1031.     Nlm_DoDraw (s);
  1032. #endif
  1033. #ifdef WIN_MSWIN
  1034.     ShowWindow (h, SW_SHOW);
  1035.     UpdateWindow (h);
  1036. #endif
  1037. #ifdef WIN_MOTIF
  1038.     XtManageChild (h);
  1039. #endif
  1040.     Nlm_RestorePort (tempPort);
  1041.   }
  1042. }
  1043.  
  1044. static void Nlm_ShowPanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1045.  
  1046. {
  1047.   Nlm_RecT    dr;
  1048.   Nlm_Int2    hOffset;
  1049.   Nlm_RecT    r;
  1050.   Nlm_SlatE   s;
  1051.   Nlm_RecT    sr;
  1052.   Nlm_Int2    vOffset;
  1053.   Nlm_WindoW  tempPort;
  1054.  
  1055.   if (setFlag) {
  1056.     Nlm_SetVisible (p, TRUE);
  1057.   }
  1058.   if (Nlm_GetVisible (p) && Nlm_AllParentsButWindowVisible (p)) {
  1059.     tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1060.     Nlm_GetRect (p, &r);
  1061.     Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  1062.     Nlm_OffsetRect (&r, -hOffset, -vOffset);
  1063.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1064.     Nlm_GetRect ((Nlm_GraphiC) s, &sr);
  1065.     Nlm_SectRect (&r, &sr, &dr);
  1066.     if (Nlm_RectInRect (&dr, &sr)) {
  1067.       Nlm_InsetRect (&dr, -1, -1);
  1068.       Nlm_InvalRect (&dr);
  1069.     }
  1070.     Nlm_RestorePort (tempPort);
  1071.   }
  1072. }
  1073.  
  1074. static void Nlm_HideSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1075.  
  1076. {
  1077.   Nlm_SlateTool  h;
  1078.   Nlm_BaR        hsb;
  1079.   Nlm_WindoW     tempPort;
  1080.   Nlm_BaR        vsb;
  1081. #ifdef WIN_MAC
  1082.   Nlm_RecT       r;
  1083. #endif
  1084.  
  1085.   if (setFlag) {
  1086.     Nlm_SetVisible (s, FALSE);
  1087.   }
  1088.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1089.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1090.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1091.   if (vsb != NULL) {
  1092.     Nlm_DoHide ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1093.   }
  1094.   if (hsb != NULL) {
  1095.     Nlm_DoHide ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1096.   }
  1097.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1098. #ifdef WIN_MAC
  1099.   if (Nlm_AllParentsButWindowVisible (s)) {
  1100.     Nlm_GetRect (s, &r);
  1101.     r.right += Nlm_vScrollBarWidth;
  1102.     r.bottom += Nlm_hScrollBarHeight;
  1103.     Nlm_InsetRect (&r, -1, -1);
  1104.     Nlm_EraseRect (&r);
  1105.     Nlm_ValidRect (&r);
  1106.   }
  1107. #endif
  1108. #ifdef WIN_MSWIN
  1109.   ShowWindow (h, SW_HIDE);
  1110.   UpdateWindow (h);
  1111. #endif
  1112. #ifdef WIN_MOTIF
  1113.   XtUnmanageChild (h);
  1114. #endif
  1115.   Nlm_RestorePort (tempPort);
  1116. }
  1117.  
  1118. static void Nlm_HidePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1119.  
  1120. {
  1121.   Nlm_RecT    dr;
  1122.   Nlm_Int2    hOffset;
  1123.   Nlm_RecT    r;
  1124.   Nlm_SlatE   s;
  1125.   Nlm_RecT    sr;
  1126.   Nlm_Int2    vOffset;
  1127.   Nlm_WindoW  tempPort;
  1128.  
  1129.   if (setFlag) {
  1130.     Nlm_SetVisible (p, FALSE);
  1131.   }
  1132.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1133.   if (Nlm_AllParentsButWindowVisible (p)) {
  1134.     Nlm_GetRect (p, &r);
  1135.     Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  1136.     Nlm_OffsetRect (&r, -hOffset, -vOffset);
  1137.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1138.     Nlm_GetRect ((Nlm_GraphiC) s, &sr);
  1139.     Nlm_SectRect (&r, &sr, &dr);
  1140.     if (Nlm_RectInRect (&dr, &sr)) {
  1141.       Nlm_InsetRect (&dr, -1, -1);
  1142.       Nlm_InvalRect (&dr);
  1143.     }
  1144.   }
  1145.   Nlm_RestorePort (tempPort);
  1146. }
  1147.  
  1148. static void Nlm_EnableSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1149.  
  1150. {
  1151.   Nlm_SlateTool  h;
  1152.   Nlm_BaR        hsb;
  1153.   Nlm_RecT       r;
  1154.   Nlm_WindoW     tempPort;
  1155.   Nlm_BaR        vsb;
  1156.  
  1157.   if (setFlag) {
  1158.     Nlm_SetEnabled (s, TRUE);
  1159.   }
  1160.   if (Nlm_GetEnabled (s) && Nlm_GetAllParentsEnabled (s)) {
  1161.     tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1162.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1163.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1164.     if (vsb != NULL) {
  1165.       Nlm_DoEnable ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1166.     }
  1167.     if (hsb != NULL) {
  1168.       Nlm_DoEnable ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1169.     }
  1170.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1171. #ifdef WIN_MSWIN
  1172.     EnableWindow (h, TRUE);
  1173. #endif
  1174. #ifdef WIN_MOTIF
  1175.     /*
  1176.     XtVaSetValues (h, XmNsensitive, TRUE, NULL);
  1177.     */
  1178. #endif
  1179.     if (setFlag) {
  1180.       if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  1181.         Nlm_DoSelect ((Nlm_GraphiC) s, FALSE);
  1182.         Nlm_GetRect (s, &r);
  1183.         Nlm_InsetRect (&r, 1, 1);
  1184.         Nlm_InvalRect (&r);
  1185.       }
  1186.     }
  1187.     Nlm_RestorePort (tempPort);
  1188.   }
  1189. }
  1190.  
  1191. static void Nlm_EnablePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1192.  
  1193. {
  1194.   Nlm_SlatE  s;
  1195.  
  1196.   if (setFlag) {
  1197.     Nlm_SetEnabled (p, TRUE);
  1198.   }
  1199.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1200.   Nlm_DoEnable ((Nlm_GraphiC) s, TRUE, savePort);
  1201. }
  1202.  
  1203. static void Nlm_DisableSlate (Nlm_GraphiC s, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1204.  
  1205. {
  1206.   Nlm_SlateTool  h;
  1207.   Nlm_BaR        hsb;
  1208.   Nlm_WindoW     tempPort;
  1209.   Nlm_BaR        vsb;
  1210.  
  1211.   if (setFlag) {
  1212.     Nlm_SetEnabled (s, FALSE);
  1213.   }
  1214.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1215.   vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1216.   hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1217.   if (vsb != NULL) {
  1218.     Nlm_DoDisable ((Nlm_GraphiC) vsb, TRUE, FALSE);
  1219.   }
  1220.   if (hsb != NULL) {
  1221.     Nlm_DoDisable ((Nlm_GraphiC) hsb, TRUE, FALSE);
  1222.   }
  1223.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1224. #ifdef WIN_MSWIN
  1225.   EnableWindow (h, FALSE);
  1226. #endif
  1227. #ifdef WIN_MOTIF
  1228.   /*
  1229.   XtVaSetValues (h, XmNsensitive, FALSE, NULL);
  1230.   */
  1231. #endif
  1232.   Nlm_RestorePort (tempPort);
  1233. }
  1234.  
  1235. static void Nlm_DisablePanel (Nlm_GraphiC p, Nlm_Boolean setFlag, Nlm_Boolean savePort)
  1236.  
  1237. {
  1238.   Nlm_SlatE  s;
  1239.  
  1240.   if (setFlag) {
  1241.     Nlm_SetEnabled (p, FALSE);
  1242.   }
  1243.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1244.   Nlm_DoDisable ((Nlm_GraphiC) s, TRUE, savePort);
  1245. }
  1246.  
  1247. static void Nlm_ResetSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1248.  
  1249. {
  1250.   Nlm_Handle       chdl;
  1251.   Nlm_BaR          hsb;
  1252.   Nlm_PaneL        n;
  1253.   Nlm_PoinT        npt;
  1254.   Nlm_PaneL        p;
  1255.   Nlm_PanelData    pdata;
  1256.   Nlm_RecT         r;
  1257.   Nlm_Handle       rhdl;
  1258.   Nlm_PnlActnProc  rst;
  1259.   Nlm_SlateData    sdata;
  1260.   Nlm_WindoW       tempPort;
  1261.   Nlm_BaR          vsb;
  1262.  
  1263.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1264.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1265.   rhdl = sdata.rowHandles;
  1266.   if (rhdl != NULL) {
  1267.     Nlm_HandFree (rhdl);
  1268.   }
  1269.   chdl = sdata.colHandles;
  1270.   if (chdl != NULL) {
  1271.     Nlm_HandFree (chdl);
  1272.   }
  1273.   sdata.rowHandles = NULL;
  1274.   sdata.colHandles = NULL;
  1275.   sdata.numRows = 0;
  1276.   sdata.numCols = 0;
  1277.   sdata.barRows = 0;
  1278.   sdata.vBefore = 0;
  1279.   sdata.vAfter = 0;
  1280.   sdata.vAction = NULL;
  1281.   Nlm_SetSlateData ((Nlm_SlatE) s, &sdata);
  1282.   vsb = sdata.vScrollBar;
  1283.   hsb = sdata.hScrollBar;
  1284.   if (vsb != NULL) {
  1285.     Nlm_DoReset ((Nlm_GraphiC) vsb, FALSE);
  1286.   }
  1287.   if (hsb != NULL) {
  1288.     Nlm_DoReset ((Nlm_GraphiC) hsb, FALSE);
  1289.   }
  1290.   Nlm_GetRect (s, &r);
  1291.   Nlm_InsetRect (&r, 4, 4);
  1292.   Nlm_LoadPt (&npt, r.left, r.top);
  1293.   Nlm_LoadBoxData ((Nlm_BoX) s, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1294.   Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1295.   if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1296.       pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1297.     p = (Nlm_PaneL) s;
  1298.     Nlm_GetRect ((Nlm_GraphiC) p, &r);
  1299.     Nlm_LoadPt (&npt, r.left, r.top);
  1300.     Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1301.     rst = pdata.reset;
  1302.     if (rst != NULL) {
  1303.       rst (p);
  1304.     }
  1305.   } else {
  1306.     p = (Nlm_PaneL) Nlm_GetChild (s);
  1307.     while (p != NULL) {
  1308.       n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1309.       Nlm_DoReset ((Nlm_GraphiC) p, FALSE);
  1310.       p = n;
  1311.     }
  1312.   }
  1313.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s) && Nlm_GetEnabled (s)) {
  1314.     Nlm_DoSelect (s, FALSE);
  1315.     Nlm_GetRect (s, &r);
  1316.     Nlm_InsetRect (&r, 1, 1);
  1317.     Nlm_EraseRect (&r);
  1318.     Nlm_ValidRect (&r);
  1319.   }
  1320.   Nlm_RestorePort (tempPort);
  1321. }
  1322.  
  1323. static void Nlm_ResetPanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1324.  
  1325. {
  1326.   Nlm_PoinT        npt;
  1327.   Nlm_PanelData    pdata;
  1328.   Nlm_RecT         r;
  1329.   Nlm_PnlActnProc  rst;
  1330.   Nlm_WindoW       tempPort;
  1331.  
  1332.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1333.   Nlm_GetRect (p, &r);
  1334.   Nlm_LoadPt (&npt, r.left, r.top);
  1335.   Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  1336.   Nlm_GetPanelData ((Nlm_PaneL) p, &pdata);
  1337.   rst = pdata.reset;
  1338.   if (rst != NULL) {
  1339.     rst ((Nlm_PaneL) p);
  1340.   }
  1341.   Nlm_RestorePort (tempPort);
  1342. }
  1343.  
  1344. static void Nlm_RemoveSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1345.  
  1346. {
  1347.   Nlm_Handle       chdl;
  1348.   Nlm_SlateTool    h;
  1349.   Nlm_BaR          hsb;
  1350.   Nlm_PaneL        n;
  1351.   Nlm_PaneL        p;
  1352.   Nlm_PanelData    pdata;
  1353.   Nlm_Handle       rhdl;
  1354.   Nlm_PnlActnProc  rst;
  1355.   Nlm_SlateData    sdata;
  1356.   Nlm_WindoW       tempPort;
  1357.   Nlm_BaR          vsb;
  1358.  
  1359.   recentSlate = NULL;
  1360.   recentlyClickedSlate = NULL;
  1361.   recentlyClickedPanel = NULL;
  1362. #ifdef WIN_MOTIF
  1363.   if (Nlm_currentXDisplay != NULL) {
  1364.     XSync (Nlm_currentXDisplay, FALSE);
  1365.   }
  1366.   if (slateTimerUsed) {
  1367.     slateTimerUsed = FALSE;
  1368.     XtRemoveTimeOut (slateTimer);
  1369.   }
  1370.   if (Nlm_currentXDisplay != NULL) {
  1371.     XSync (Nlm_currentXDisplay, FALSE);
  1372.   }
  1373. #endif
  1374.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1375.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1376.   rhdl = sdata.rowHandles;
  1377.   if (rhdl != NULL) {
  1378.     Nlm_HandFree (rhdl);
  1379.   }
  1380.   chdl = sdata.colHandles;
  1381.   if (chdl != NULL) {
  1382.     Nlm_HandFree (chdl);
  1383.   }
  1384.   vsb = sdata.vScrollBar;
  1385.   hsb = sdata.hScrollBar;
  1386.   if (vsb != NULL) {
  1387.     Nlm_DoRemove ((Nlm_GraphiC) vsb, FALSE);
  1388.   }
  1389.   if (hsb != NULL) {
  1390.     Nlm_DoRemove ((Nlm_GraphiC) hsb, FALSE);
  1391.   }
  1392.   Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1393.   if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1394.       pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1395.     p = (Nlm_PaneL) s;
  1396.     rst = pdata.reset;
  1397.     if (rst != NULL) {
  1398.       rst (p);
  1399.     }
  1400.   } else {
  1401.     p = (Nlm_PaneL) Nlm_GetChild (s);
  1402.     while (p != NULL) {
  1403.       n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1404.       Nlm_DoReset ((Nlm_GraphiC) p, FALSE);
  1405.       Nlm_DoRemove ((Nlm_GraphiC) p, FALSE);
  1406.       p = n;
  1407.     }
  1408.   }
  1409.   h = sdata.handle;
  1410. #ifdef WIN_MSWIN
  1411.   RemoveProp (h, (LPSTR) "Nlm_VibrantProp");
  1412.   DestroyWindow (h);
  1413. #endif
  1414. #ifdef WIN_MOTIF
  1415.   XtDestroyWidget (h);
  1416. #endif
  1417.   Nlm_RemoveLink (s);
  1418.   recentSlate = NULL;
  1419.   recentlyClickedSlate = NULL;
  1420.   recentlyClickedPanel = NULL;
  1421.   Nlm_RestorePort (tempPort);
  1422. }
  1423.  
  1424. static void Nlm_RemovePanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1425.  
  1426. {
  1427.   Nlm_WindoW  tempPort;
  1428.  
  1429.   tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1430.   Nlm_RemoveLink (p);
  1431.   Nlm_RestorePort (tempPort);
  1432. }
  1433.  
  1434. static void Nlm_SelectSlate (Nlm_GraphiC s, Nlm_Boolean savePort)
  1435.  
  1436. {
  1437. #ifdef WIN_MOTIF
  1438.   Pixel          color;
  1439.   Nlm_SlateTool  h;
  1440.   Nlm_RecT       r;
  1441.   Nlm_WindoW     w;
  1442.  
  1443.   w = Nlm_ParentWindow (s);
  1444.   if (Nlm_WindowHasBeenShown (w) && (! Nlm_IsWindowDying (w))) {
  1445.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1446.     Nlm_GetRect (s, &r);
  1447.     Nlm_XOffset = r.left;
  1448.     Nlm_YOffset = r.top;
  1449.     Nlm_currentXWindow = XtWindow (h);
  1450.     XtVaGetValues (h, XmNbackground, &color, 0);
  1451.     Nlm_XbackColor = color;
  1452.     XtVaGetValues (h, XmNforeground, &color, 0);
  1453.     Nlm_XforeColor = color;
  1454.   }
  1455. #endif
  1456. }
  1457.  
  1458. static void Nlm_SelectPanel (Nlm_GraphiC p, Nlm_Boolean savePort)
  1459.  
  1460. {
  1461. #ifdef WIN_MOTIF
  1462.   Pixel          color;
  1463.   Nlm_SlateTool  h;
  1464.   Nlm_RecT       r;
  1465.   Nlm_SlatE      s;
  1466.   Nlm_WindoW     w;
  1467.  
  1468.   w = Nlm_ParentWindow (p);
  1469.   if (Nlm_WindowHasBeenShown (w) && (! Nlm_IsWindowDying (w))) {
  1470.     s = (Nlm_SlatE) Nlm_GetParent (p);
  1471.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1472.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  1473.     Nlm_XOffset = r.left;
  1474.     Nlm_YOffset = r.top;
  1475.     Nlm_currentXWindow = XtWindow (h);
  1476.     XtVaGetValues (h, XmNbackground, &color, 0);
  1477.     Nlm_XbackColor = color;
  1478.     XtVaGetValues (h, XmNforeground, &color, 0);
  1479.     Nlm_XforeColor = color;
  1480.   }
  1481. #endif
  1482. }
  1483.  
  1484. static void Nlm_SetSlateOffset (Nlm_GraphiC s, Nlm_Int2 horiz,
  1485.                                 Nlm_Int2 vert, Nlm_Boolean savePort)
  1486.  
  1487. {
  1488.   Nlm_BaR        hsb;
  1489.   Nlm_SlateData  sdata;
  1490.   Nlm_WindoW     tempPort;
  1491.   Nlm_BaR        vsb;
  1492.  
  1493.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1494.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1495.   /*
  1496.   if (vert > sdata.barRows) {
  1497.     vert = sdata.barRows;
  1498.   }
  1499.   */
  1500.   vsb = sdata.vScrollBar;
  1501.   hsb = sdata.hScrollBar;
  1502.   if (vsb != NULL) {
  1503.     Nlm_DoSetValue ((Nlm_GraphiC) vsb, vert + sdata.vBefore, FALSE);
  1504.   }
  1505.   if (hsb != NULL) {
  1506.     Nlm_DoSetValue ((Nlm_GraphiC) hsb, horiz, FALSE);
  1507.   }
  1508.   Nlm_RestorePort (tempPort);
  1509. }
  1510.  
  1511. static void Nlm_GetSlateOffset (Nlm_GraphiC s, Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert)
  1512.  
  1513. {
  1514.   Nlm_BaR        hsb;
  1515.   Nlm_SlateData  sdata;
  1516.   Nlm_BaR        vsb;
  1517.  
  1518.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1519.   if (vert != NULL) {
  1520.     vsb = sdata.vScrollBar;
  1521.     if (vsb != NULL) {
  1522.       *vert = Nlm_DoGetValue ((Nlm_GraphiC) vsb) - sdata.vBefore;
  1523.     } else {
  1524.       *vert = 0;
  1525.     }
  1526.   }
  1527.   if (horiz != NULL) {
  1528.     hsb = sdata.hScrollBar;
  1529.     if (hsb != NULL) {
  1530.       *horiz = Nlm_DoGetValue ((Nlm_GraphiC) hsb);
  1531.     } else {
  1532.       *horiz = 0;
  1533.     }
  1534.   }
  1535. }
  1536.  
  1537. static void Nlm_GetPanelOffset (Nlm_GraphiC p,  Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert)
  1538.  
  1539. {
  1540.   Nlm_Int2       hOff;
  1541.   Nlm_Int2       numRows;
  1542.   Nlm_OfsPtr     optr;
  1543.   Nlm_Handle     rhdl;
  1544.   Nlm_SlatE      s;
  1545.   Nlm_SlateData  sdata;
  1546.   Nlm_Int2       vOff;
  1547.  
  1548.   s = (Nlm_SlatE) Nlm_GetParent (p);
  1549.   Nlm_DoGetOffset ((Nlm_GraphiC) s, &hOff, &vOff);
  1550.   if (vert != NULL) {
  1551.     Nlm_GetSlateData (s, &sdata);
  1552.     numRows = sdata.numRows;
  1553.     rhdl = sdata.rowHandles;
  1554.     if (rhdl != NULL && vOff > 0 && vOff < numRows) {
  1555.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  1556.       *vert = optr [vOff].offset;
  1557.       Nlm_HandUnlock (rhdl);
  1558.     } else {
  1559.       *vert = 0;
  1560.     }
  1561.   }
  1562.   if (horiz != NULL) {
  1563.     *horiz = 0;
  1564.   }
  1565. }
  1566.  
  1567. static void Nlm_InvalSlate (Nlm_GraphiC s)
  1568.  
  1569. {
  1570.   Nlm_BaR   hsb;
  1571.   Nlm_RecT  r;
  1572.   Nlm_BaR   vsb;
  1573.  
  1574.   if (Nlm_GetVisible (s) && Nlm_GetAllParentsVisible (s)) {
  1575.     Nlm_GetRect (s, &r);
  1576.     vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1577.     hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1578.     if (vsb != NULL) {
  1579.       r.right += Nlm_vScrollBarWidth;
  1580.     }
  1581.     if (hsb != NULL) {
  1582.       r.bottom += Nlm_hScrollBarHeight;
  1583.     }
  1584.     Nlm_InsetRect (&r, -1, -1);
  1585.     Nlm_InvalRect (&r);
  1586.   }
  1587. }
  1588.  
  1589. static void Nlm_SetSlatePosition (Nlm_GraphiC s, Nlm_RectPtr r, Nlm_Boolean savePort)
  1590.  
  1591. {
  1592.   Nlm_Int2       deltaX;
  1593.   Nlm_Int2       deltaY;
  1594.   Nlm_SlateTool  h;
  1595.   Nlm_BaR        hsb;
  1596.   Nlm_RecT       oldRect;
  1597.   Nlm_PaneL      p;
  1598.   Nlm_RecT       pr;
  1599.   Nlm_RecT       sr;
  1600.   Nlm_WindoW     tempPort;
  1601.   Nlm_BaR        vsb;
  1602.  
  1603.   if (r != NULL) {
  1604.     Nlm_DoGetPosition (s, &oldRect);
  1605.     if (! Nlm_EqualRect (r, &oldRect)) {
  1606.       tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1607.       sr = *r;
  1608.       deltaX = sr.left - oldRect.left;
  1609.       deltaY = sr.top - oldRect.top;
  1610.       vsb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) s);
  1611.       hsb = Nlm_GetSlateHScrollBar ((Nlm_SlatE) s);
  1612.       h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1613. #ifdef WIN_MAC
  1614.       Nlm_InvalSlate (s);
  1615.       if (vsb != NULL) {
  1616.         sr.right -= Nlm_vScrollBarWidth;
  1617.       }
  1618.       if (hsb != NULL) {
  1619.         sr.bottom -= Nlm_hScrollBarHeight;
  1620.       }
  1621.       Nlm_SetRect (s, &sr);
  1622.       Nlm_InvalSlate (s);
  1623. #endif
  1624. #ifdef WIN_MSWIN
  1625.       if (vsb != NULL) {
  1626.         sr.right -= Nlm_vScrollBarWidth;
  1627.       }
  1628.       if (hsb != NULL) {
  1629.         sr.bottom -= Nlm_hScrollBarHeight;
  1630.       }
  1631.       Nlm_SetRect (s, &sr);
  1632.       if (h != NULL) {
  1633.         MoveWindow (h, sr.left, sr.top, sr.right - sr.left, sr.bottom - sr.top, TRUE);
  1634.       }
  1635. #endif
  1636. #ifdef WIN_MOTIF
  1637. #ifdef DCLAP
  1638. /* dgg -- why aren't these corrections in motif also ? */
  1639.       if (vsb != NULL) {
  1640.         sr.right -= Nlm_vScrollBarWidth;
  1641.       }
  1642.       if (hsb != NULL) {
  1643.         sr.bottom -= Nlm_hScrollBarHeight;
  1644.       }
  1645.       XtVaSetValues (h,
  1646.                      XmNx, (Position) sr.left,
  1647.                      XmNy, (Position) sr.top,
  1648.                      XmNwidth, (Dimension) (sr.right - sr.left + 1),
  1649.                      XmNheight, (Dimension) (sr.bottom - sr.top + 1),
  1650.                      NULL);
  1651.       Nlm_SetRect (s, &sr);
  1652. #else
  1653.       XtVaSetValues (h,
  1654.                      XmNx, (Position) r->left,
  1655.                      XmNy, (Position) r->top,
  1656.                      XmNwidth, (Dimension) (r->right - r->left + 1),
  1657.                      XmNheight, (Dimension) (r->bottom - r->top + 1), 
  1658.                      NULL);
  1659.       Nlm_SetRect (s, &sr);
  1660. #endif
  1661.  
  1662. #endif
  1663.       p = (Nlm_PaneL) Nlm_GetChild (s);
  1664.       while (p != NULL) {
  1665.         Nlm_DoGetPosition ((Nlm_GraphiC) p, &pr);
  1666.         Nlm_OffsetRect (&pr, deltaX, deltaY);
  1667.         Nlm_DoSetPosition ((Nlm_GraphiC) p, &pr, FALSE);
  1668.         p = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  1669.       }
  1670. #ifdef WIN_MSWIN
  1671.       if (h != NULL) {
  1672.         UpdateWindow (h);
  1673.       }
  1674. #endif
  1675.       if (vsb != NULL) {
  1676.         Nlm_GetRect (s, &sr);
  1677.         sr.left = sr.right;
  1678.         sr.right += Nlm_vScrollBarWidth;
  1679.         Nlm_DoSetPosition ((Nlm_GraphiC) vsb, &sr, FALSE);
  1680.       }
  1681.       if (hsb != NULL) {
  1682.         Nlm_GetRect (s, &sr);
  1683.         sr.top = sr.bottom;
  1684.         sr.bottom += Nlm_hScrollBarHeight;
  1685.         Nlm_DoSetPosition ((Nlm_GraphiC) hsb, &sr, FALSE);
  1686.       }
  1687.       Nlm_RestorePort (tempPort);
  1688.     }
  1689.   }
  1690. }
  1691.  
  1692. static void Nlm_SetPanelPosition (Nlm_GraphiC p, Nlm_RectPtr r, Nlm_Boolean savePort)
  1693.  
  1694. {
  1695.   Nlm_RecT    oldRect;
  1696.   Nlm_WindoW  tempPort;
  1697.  
  1698.   if (r != NULL) {
  1699.     Nlm_DoGetPosition (p, &oldRect);
  1700.     if (! Nlm_EqualRect (r, &oldRect)) {
  1701.       tempPort = Nlm_SavePortIfNeeded (p, savePort);
  1702.       Nlm_SetRect (p, r);
  1703.       Nlm_RestorePort (tempPort);
  1704.     }
  1705.   }
  1706. }
  1707.  
  1708. static void Nlm_GetSlatePosition (Nlm_GraphiC s, Nlm_RectPtr r)
  1709.  
  1710. {
  1711.   if (r != NULL) {
  1712.     Nlm_GetRect (s, r);
  1713.     if (Nlm_GetSlateVScrollBar ((Nlm_SlatE) s) != NULL) {
  1714.       r->right += Nlm_vScrollBarWidth;
  1715.     }
  1716.     if (Nlm_GetSlateHScrollBar ((Nlm_SlatE) s) != NULL) {
  1717.       r->bottom += Nlm_hScrollBarHeight;
  1718.     }
  1719.   }
  1720. }
  1721.  
  1722. static void Nlm_GetPanelPosition (Nlm_GraphiC p, Nlm_RectPtr r)
  1723.  
  1724. {
  1725.   if (r != NULL) {
  1726.     Nlm_GetRect (p, r);
  1727.   }
  1728. }
  1729.  
  1730. static void Nlm_AdjustSlate (Nlm_GraphiC a, Nlm_RectPtr r,
  1731.                              Nlm_Boolean align, Nlm_Boolean savePort)
  1732.  
  1733. {
  1734.   Nlm_SlatE  s;
  1735.  
  1736.   s = (Nlm_SlatE) Nlm_GetParent (a);
  1737.   Nlm_RecordRect ((Nlm_GraphiC) s, r);
  1738.   Nlm_NextPosition ((Nlm_GraphiC) s, r);
  1739. }
  1740.  
  1741. static void Nlm_SetSlateRange (Nlm_GraphiC s, Nlm_Int2 pgUp,
  1742.                                Nlm_Int2 pgDn, Nlm_Int2 max,
  1743.                                Nlm_Boolean savePort)
  1744.  
  1745. {
  1746.   Nlm_BaR        sb;
  1747.   Nlm_SlateData  sdata;
  1748.   Nlm_WindoW     tempPort;
  1749.  
  1750.   tempPort = Nlm_SavePortIfNeeded (s, savePort);
  1751.   Nlm_GetSlateData ((Nlm_SlatE) s, &sdata);
  1752.   if (max > sdata.barRows) {
  1753.     sdata.barRows = max;
  1754.     Nlm_SetSlateData ((Nlm_SlatE) s, &sdata);
  1755.   }
  1756.   sb = sdata.vScrollBar;
  1757.   if (sb != NULL) {
  1758.     Nlm_DoSetRange ((Nlm_GraphiC) sb, pgUp, pgDn, max, FALSE);
  1759.   }
  1760.   Nlm_RestorePort (tempPort);
  1761. }
  1762.  
  1763. static void Nlm_NextScreenLine (Nlm_DisplaY d)
  1764.  
  1765. {
  1766.   Nlm_RecT   p;
  1767.   Nlm_PoinT  pt;
  1768.   Nlm_RecT   r;
  1769.  
  1770.   Nlm_GetCursorPos (d, &pt);
  1771.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  1772.   Nlm_InsetRect (&r, 4, 4);
  1773.   p = r;
  1774. #ifdef WIN_MSWIN
  1775.   r.bottom -= disphght;
  1776. #endif
  1777.   while (pt.y + disphght >= r.bottom) {
  1778.     Nlm_ScrollRect (&p, 0, -disphght);
  1779.     pt.y -= disphght;
  1780.   }
  1781.   if (pt.y + disphght >= r.bottom) {
  1782.     Nlm_ScrollRect (&p, 0, -disphght);
  1783.   } else {
  1784.     pt.y += disphght;
  1785.   }
  1786.   pt.x = r.left;
  1787.   Nlm_SetCursorPos (d, pt);
  1788. }
  1789.  
  1790. static void Nlm_PaintOneCharacter (Nlm_DisplaY d, Nlm_Char ch)
  1791.  
  1792. {
  1793.   Nlm_PoinT  nx;
  1794.   Nlm_PoinT  pt;
  1795.   Nlm_RecT   r;
  1796.  
  1797.   Nlm_GetCursorPos (d, &pt);
  1798.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  1799.   Nlm_InsetRect (&r, 4, 4);
  1800.   nx = pt;
  1801.   nx.x += Nlm_CharWidth (ch);
  1802. #ifdef WIN_MSWIN
  1803.   nx.y -= disphght;
  1804. #endif
  1805.   if (Nlm_PtInRect (pt, &r) && Nlm_PtInRect (nx, &r)) {
  1806.   } else {
  1807.     screenPos = 0;
  1808.     Nlm_NextScreenLine (d);
  1809.   }
  1810.   Nlm_GetCursorPos (d, &pt);
  1811.   nx = pt;
  1812.   nx.x += Nlm_CharWidth (ch);
  1813.   if (Nlm_PtInRect (pt, &r) && Nlm_PtInRect (nx, &r)) {
  1814.     Nlm_MoveTo (pt.x, pt.y);
  1815.     Nlm_PaintChar (ch);
  1816.     Nlm_SetCursorPos (d, nx);
  1817.     if (screenPos < screenBufSize) {
  1818.       screenBfr [screenPos] = ch;
  1819.     }
  1820.     screenPos++;
  1821.   }
  1822. }
  1823.  
  1824. static void Nlm_EraseLastChar (Nlm_DisplaY d)
  1825.  
  1826. {
  1827.   Nlm_Char   ch;
  1828.   Nlm_PoinT  pt;
  1829.  
  1830.   if (screenPos > 0) {
  1831.     screenPos--;
  1832.     if (screenPos < screenBufSize) {
  1833.       Nlm_GetCursorPos (d, &pt);
  1834.       ch = screenBfr [screenPos];
  1835.       pt.x -= Nlm_CharWidth (ch);
  1836.       Nlm_MoveTo (pt.x, pt.y);
  1837.       Nlm_SetCursorPos (d, pt);
  1838.       Nlm_InvertMode ();
  1839.       Nlm_PaintOneCharacter (d, ch);
  1840.       Nlm_MoveTo (pt.x, pt.y);
  1841.       Nlm_SetCursorPos (d, pt);
  1842.       screenPos--;
  1843.       Nlm_CopyMode ();
  1844.     }
  1845.   }
  1846. }
  1847.  
  1848. static void Nlm_PaintOrFormatChar (Nlm_GraphiC d, Nlm_Char ch, Nlm_Boolean savePort)
  1849.  
  1850. {
  1851.   Nlm_PoinT   pt;
  1852.   Nlm_RecT    r;
  1853.   Nlm_WindoW  tempPort;
  1854. #ifdef WIN_MAC
  1855.   PenState    state;
  1856. #endif
  1857.  
  1858.   if (Nlm_GetVisible (d) && Nlm_AllParentsButWindowVisible (d)) {
  1859.     tempPort = Nlm_SavePortIfNeeded (d, savePort);
  1860.     Nlm_DoSelect (d, FALSE);
  1861. #ifdef WIN_MAC
  1862.     GetPenState (&state);
  1863.     PenNormal ();
  1864. #endif
  1865.     Nlm_SelectFont (dispfont);
  1866.     switch (ch) {
  1867.       case '\n':
  1868.         screenPos = 0;
  1869.         Nlm_NextScreenLine ((Nlm_DisplaY) d);
  1870.         break;
  1871.       case '\r':
  1872. #ifndef WIN_MSWIN
  1873.         screenPos = 0;
  1874.         Nlm_NextScreenLine ((Nlm_DisplaY) d);
  1875. #endif
  1876.         break;
  1877.       case '\t':
  1878.         do {
  1879.           Nlm_PaintOneCharacter ((Nlm_DisplaY) d, ' ');
  1880.         } while ((screenPos % 8) != 0);
  1881.         break;
  1882.       case '\b':
  1883.         if (screenPos > 0) {
  1884.           Nlm_EraseLastChar ((Nlm_DisplaY) d);
  1885.         }
  1886.         break;
  1887.       case '\f':
  1888.         screenPos = 0;
  1889.         Nlm_GetRect (d, &r);
  1890.         Nlm_LoadPt (&pt, r.left, r.top + disphght);
  1891.         Nlm_SetCursorPos ((Nlm_DisplaY) d, pt);
  1892.         Nlm_InsetRect (&r, 2, 2);
  1893.         Nlm_EraseRect (&r);
  1894.         break;
  1895.       case '\7':
  1896.         Nlm_Beep ();
  1897.         break;
  1898.       default:
  1899.         if (ch >= ' ') {
  1900.           Nlm_PaintOneCharacter ((Nlm_DisplaY) d, ch);
  1901.         }
  1902.         break;
  1903.     }
  1904. #ifdef WIN_MAC
  1905.     SetPenState (&state);
  1906. #endif
  1907. #ifndef DCLAP
  1908.     Nlm_SelectFont (Nlm_systemFont);
  1909. #endif
  1910.     Nlm_RestorePort (tempPort);
  1911.   }
  1912. }
  1913.  
  1914. static void Nlm_SelectDisplay (Nlm_GraphiC d, Nlm_Boolean savePort)
  1915.  
  1916. {
  1917.   Nlm_WindoW  w;
  1918.  
  1919.   if (Nlm_WindowHasBeenShown (Nlm_ParentWindow (d))) {
  1920.     w = Nlm_GetParentWindow (d);
  1921.     Nlm_SetWindowCharDisplay (w, (Nlm_DisplaY) d);
  1922.   }
  1923. }
  1924.  
  1925. #ifdef WIN_MOTIF
  1926. #define MOUSE_DOWN 1
  1927. #define MOUSE_MOVE 2
  1928. #define MOUSE_UP   3
  1929.  
  1930. static void Nlm_SlateTimer (XtPointer client_data, XtIntervalId *id)
  1931.  
  1932. {
  1933.   Nlm_PaneL        p;
  1934.   Nlm_PnlClckProc  prs;
  1935.   Nlm_PoinT        pt;
  1936.   Nlm_SlatE        s;
  1937.  
  1938.   if (slateTimerUsed) {
  1939.     s = (Nlm_SlatE) client_data;
  1940.     pt = currentMousePos;
  1941.     if ((Nlm_SlatE) s == recentlyClickedSlate &&
  1942.         recentlyClickedSlate != NULL && recentlyClickedPanel != NULL) {
  1943.       p = recentlyClickedPanel;
  1944.       Nlm_DoSelect ((Nlm_GraphiC) p, FALSE);
  1945.       prs = Nlm_GetPanelHold (p);
  1946.       if (prs != NULL) {
  1947.         Nlm_ResetDrawingTools ();
  1948.         prs (p, pt);
  1949.       }
  1950.     }
  1951.     slateTimer = XtAppAddTimeOut (Nlm_appContext, 50, Nlm_SlateTimer, (XtPointer) s);
  1952.     slateTimerUsed = TRUE;
  1953.   }
  1954. }
  1955.  
  1956. static void Nlm_SlateClick (Nlm_SlatE s, Nlm_PoinT pt, Nlm_Int2 mouseAction)
  1957.  
  1958. {
  1959.   Nlm_PnlClckProc  clk;
  1960.   Nlm_PnlClckProc  drg;
  1961.   Nlm_SlateTool    h;
  1962.   Nlm_Int2         hOffset;
  1963.   Nlm_PaneL        n;
  1964.   Nlm_Boolean      notInside;
  1965.   Nlm_PaneL        p;
  1966.   Nlm_PanelData    pdata;
  1967.   Nlm_PnlClckProc  prs;
  1968.   Nlm_RecT         r;
  1969.   Nlm_PnlClckProc  rls;
  1970.   Nlm_Int2         vOffset;
  1971.   Nlm_Int2         x;
  1972.   Nlm_Int2         y;
  1973.  
  1974.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  1975.   currentMousePos = pt;
  1976.   switch (mouseAction) {
  1977.     case MOUSE_DOWN:
  1978.       slateTimer = XtAppAddTimeOut (Nlm_appContext, 50, Nlm_SlateTimer, (XtPointer) s);
  1979.       slateTimerUsed = TRUE;
  1980.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  1981.       recentlyClickedSlate = (Nlm_SlatE) s;
  1982.       recentlyClickedPanel = NULL;
  1983.       Nlm_SelectFont (Nlm_systemFont);
  1984.       Nlm_ResetDrawingTools ();
  1985.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  1986.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  1987.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  1988.         p = (Nlm_PaneL) s;
  1989.         recentlyClickedPanel = p;
  1990.         clk = Nlm_GetPanelClick (p);
  1991.         if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p)
  1992.             && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  1993.           clk (p, pt);
  1994.           Nlm_Update ();
  1995.         }
  1996.       } else {
  1997.         p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  1998.         notInside = TRUE;
  1999.         while (p != NULL && notInside) {
  2000.           n = Nlm_GetPanelPrev (p);
  2001.           Nlm_GetPanelData (p, &pdata);
  2002.           if (pdata.click != NULL || pdata.drag != NULL ||
  2003.               pdata.hold != NULL || pdata.release != NULL) {
  2004.             Nlm_GetRect ((Nlm_GraphiC) p, &r);
  2005.             Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  2006.             Nlm_OffsetRect (&r, -hOffset, -vOffset);
  2007.             if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  2008.                 Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2009.               recentlyClickedPanel = p;
  2010.               notInside = FALSE;
  2011.               clk = Nlm_GetPanelClick (p);
  2012.               if (clk != NULL) {
  2013.                 clk (p, pt);
  2014.                 Nlm_Update ();
  2015.               }
  2016.             }
  2017.           }
  2018.           p = n;
  2019.         }
  2020.       }
  2021.       break;
  2022.     case MOUSE_MOVE:
  2023.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2024.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  2025.         p = recentlyClickedPanel;
  2026.         drg = Nlm_GetPanelDrag (p);
  2027.         if (drg != NULL) {
  2028.           Nlm_ResetDrawingTools ();
  2029.           drg (p, pt);
  2030.         }
  2031.       }
  2032.       break;
  2033.     case MOUSE_UP:
  2034.       if (slateTimerUsed) {
  2035.         XtRemoveTimeOut (slateTimer);
  2036.       }
  2037.       slateTimerUsed = FALSE;
  2038.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2039.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  2040.         p = recentlyClickedPanel;
  2041.         rls = Nlm_GetPanelRelease (p);
  2042.         if (rls != NULL) {
  2043.           Nlm_ResetDrawingTools ();
  2044.           rls (p, pt);
  2045.         }
  2046.       }
  2047.       Nlm_SelectFont (Nlm_systemFont);
  2048.       Nlm_ResetDrawingTools ();
  2049. /*
  2050.       recentlyClickedSlate = NULL;
  2051. */
  2052.       recentlyClickedPanel = NULL;
  2053.       break;
  2054.     default:
  2055.       break;
  2056.   }
  2057. }
  2058.  
  2059. static void Nlm_SlateClickCallback (Widget w, XEvent *ev,
  2060.                                     String *args, Cardinal *num_args)
  2061.  
  2062. {
  2063.   XButtonEvent  *event;
  2064.   Pixel         color;
  2065.   Nlm_Uint4     delta;
  2066.   Nlm_WindoW    newWindow;
  2067.   Nlm_WindoW    oldWindow;
  2068.   Nlm_PoinT     pt;
  2069.   XtPointer     ptr;
  2070.   Nlm_RecT      r;
  2071.   Nlm_SlatE     s;
  2072.   Nlm_Uint4     state;
  2073.   Window        tempWind;
  2074.   Nlm_Uint4     ticks;
  2075.  
  2076.   event = (XButtonEvent *) ev;
  2077.   XtVaGetValues (w, XmNuserData, &ptr, NULL);
  2078.   s = (Nlm_SlatE) ptr;
  2079.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetAllParentsEnabled ((Nlm_GraphiC) s)) {
  2080.     newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2081.     if (! Nlm_IsWindowDying (newWindow)) {
  2082.       oldWindow = Nlm_CurrentWindow ();
  2083.       if (oldWindow != newWindow) {
  2084.         Nlm_UseWindow (newWindow);
  2085.       }
  2086.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2087.       Nlm_XOffset = r.left;
  2088.       Nlm_YOffset = r.top;
  2089.       tempWind = Nlm_currentXWindow;
  2090.       Nlm_currentXWindow = XtWindow (w);
  2091.       XtVaGetValues (w, XmNbackground, &color, 0);
  2092.       Nlm_XbackColor = color;
  2093.       XtVaGetValues (w, XmNforeground, &color, 0);
  2094.       Nlm_XforeColor = color;
  2095.       pt.x = (Nlm_Int2) event->x + Nlm_XOffset;
  2096.       pt.y = (Nlm_Int2) event->y + Nlm_YOffset;
  2097.       Nlm_cmmdKey = FALSE;
  2098.       Nlm_ctrlKey = FALSE;
  2099.       Nlm_optKey = FALSE;
  2100.       Nlm_shftKey = FALSE;
  2101.       Nlm_dblClick = FALSE;
  2102.       state = event->state;
  2103.       if ((state &ControlMask) != 0) {
  2104.         Nlm_ctrlKey = TRUE;
  2105.       }
  2106.       if ((state &ShiftMask) != 0) {
  2107.         Nlm_shftKey = TRUE;
  2108.       }
  2109. #ifdef DCLAP
  2110.       if ((state & Mod1Mask) != 0) {
  2111.         Nlm_optKey = TRUE;
  2112.       }
  2113.       if ((state & Mod2Mask) != 0) {
  2114.         Nlm_cmmdKey = TRUE;
  2115.       }
  2116. #endif
  2117.       if (strcmp (args [0], "down") == 0) {
  2118.         ticks = (Nlm_Uint4) event->time;
  2119.         if (s == recentlyClickedSlate) {
  2120.           delta = ticks - (Nlm_Uint4) lastClickTime;
  2121.           if (delta <= (Nlm_Uint4) XtGetMultiClickTime (Nlm_currentXDisplay)) {
  2122.             Nlm_dblClick = TRUE;
  2123.           }
  2124.         }
  2125.         lastClickTime = (Nlm_Int4) ticks;
  2126.         Nlm_SlateClick (s, pt, MOUSE_DOWN);
  2127.       } else if (strcmp (args [0], "up") == 0) {
  2128.         Nlm_SlateClick (s, pt, MOUSE_UP);
  2129.       } else if (strcmp (args [0], "motion") == 0) {
  2130.         Nlm_SlateClick (s, pt, MOUSE_MOVE);
  2131.       }
  2132.       if (Nlm_currentXDisplay != NULL) {
  2133.         XSync (Nlm_currentXDisplay, FALSE);
  2134.       }
  2135.       Nlm_currentXWindow = tempWind;
  2136.       if (oldWindow != newWindow) {
  2137.         Nlm_UseWindow (oldWindow);
  2138.       }
  2139.     }
  2140.   }
  2141. }
  2142.  
  2143. static void Nlm_SlateKeyCallback (Widget w, XEvent *ev,
  2144.                                   String *args, Cardinal *num_args)
  2145.  
  2146. {
  2147.   XKeyEvent        *event;
  2148.   Nlm_Char         buffer [20];
  2149.   Nlm_Char         ch;
  2150.   int              charcount;
  2151.   XComposeStatus   compose;
  2152.   KeySym           keysym;
  2153.   Pixel            color;
  2154.   Nlm_Uint4        delta;
  2155.   Nlm_SltCharProc  keyProc;
  2156.   Nlm_WindoW       newWindow;
  2157.   Nlm_WindoW       oldWindow;
  2158.   XtPointer        ptr;
  2159.   Nlm_RecT         r;
  2160.   Nlm_SlatE        s;
  2161.   Nlm_Uint4        state;
  2162.   Window           tempWind;
  2163.  
  2164.   event = (XKeyEvent *) ev;
  2165.   XtVaGetValues (w, XmNuserData, &ptr, NULL);
  2166.   s = (Nlm_SlatE) ptr;
  2167.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetAllParentsEnabled ((Nlm_GraphiC) s)) {
  2168.     newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2169.     if (! Nlm_IsWindowDying (newWindow)) {
  2170.       oldWindow = Nlm_CurrentWindow ();
  2171.       if (oldWindow != newWindow) {
  2172.         Nlm_UseWindow (newWindow);
  2173.       }
  2174.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2175.       Nlm_XOffset = r.left;
  2176.       Nlm_YOffset = r.top;
  2177.       tempWind = Nlm_currentXWindow;
  2178.       Nlm_currentXWindow = XtWindow (w);
  2179.       XtVaGetValues (w, XmNbackground, &color, 0);
  2180.       Nlm_XbackColor = color;
  2181.       XtVaGetValues (w, XmNforeground, &color, 0);
  2182.       Nlm_XforeColor = color;
  2183.       Nlm_cmmdKey = FALSE;
  2184.       Nlm_ctrlKey = FALSE;
  2185.       Nlm_optKey = FALSE;
  2186.       Nlm_shftKey = FALSE;
  2187.       Nlm_dblClick = FALSE;
  2188.       state = event->state;
  2189.       if ((state &ControlMask) != 0) {
  2190.         Nlm_ctrlKey = TRUE;
  2191.       }
  2192.       if ((state & ShiftMask) != 0) {
  2193.         Nlm_shftKey = TRUE;
  2194.       }
  2195. #ifdef DCLAP
  2196.       if ((state & Mod1Mask) != 0) {
  2197.         Nlm_optKey = TRUE;
  2198.       }
  2199.       if ((state & Mod2Mask) != 0) {
  2200.         Nlm_cmmdKey = TRUE;
  2201.       }
  2202. #endif
  2203.       if (ev->type == KeyPress && strcmp (args [0], "key") == 0) {
  2204.         buffer [0] = '\0';
  2205.         charcount = XLookupString (&(ev->xkey), buffer, 20, &keysym, &compose);
  2206.         if (charcount >= 0 && charcount < 20) {
  2207.           buffer [charcount] = '\0';
  2208.         }
  2209.         keyProc = Nlm_GetSlateCharProc (s);
  2210.         if (keyProc != NULL) {
  2211.           ch = buffer [0];
  2212.           keyProc (s, ch);
  2213.         }
  2214.       }
  2215.       if (Nlm_currentXDisplay != NULL) {
  2216.         XSync (Nlm_currentXDisplay, FALSE);
  2217.       }
  2218.       Nlm_currentXWindow = tempWind;
  2219.       if (oldWindow != newWindow) {
  2220.         Nlm_UseWindow (oldWindow);
  2221.       }
  2222.     }
  2223.   }
  2224. }
  2225.  
  2226. static void Nlm_DrawSlate (Nlm_SlatE s)
  2227.  
  2228. {
  2229.   Nlm_PnlActnProc  drw;
  2230.   Nlm_SlateTool    h;
  2231.   Nlm_PaneL        n;
  2232.   Nlm_PaneL        p;
  2233.   Nlm_PanelData    pdata;
  2234.   Nlm_RecT         r;
  2235.  
  2236.   if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  2237.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  2238.     if (h != NULL) {
  2239.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2240. #ifndef DCLAP
  2241.       Nlm_SelectFont (Nlm_systemFont);
  2242. #endif
  2243.       Nlm_ResetDrawingTools ();
  2244.             Nlm_DrawSlateBorder( s);
  2245.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  2246.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  2247.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  2248.         p = (Nlm_PaneL) s;
  2249. /*
  2250.         recentlyClickedPanel = p;
  2251. */
  2252.         drw = Nlm_GetPanelDraw (p);
  2253.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2254.           drw (p);
  2255.           Nlm_ResetDrawingTools ();
  2256.         }
  2257.       } else {
  2258.         p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  2259.         while (p != NULL) {
  2260.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  2261.           drw = Nlm_GetPanelDraw (p);
  2262.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  2263.             drw (p);
  2264.             Nlm_ResetDrawingTools ();
  2265.           }
  2266.           p = n;
  2267.         }
  2268.       }
  2269.     }
  2270.   }
  2271. }
  2272.  
  2273. static void Nlm_ClipXRgn (Nlm_RegioN rgn)
  2274.  
  2275. {
  2276.   Nlm_RgnTool  ntool1;
  2277.   Nlm_RgnTool  ntool2;
  2278.  
  2279.   if (rgn != NULL && Nlm_currentXDisplay != NULL && Nlm_currentXGC != NULL) {
  2280.     ntool1 = XCreateRegion ();
  2281.     ntool2 = XCreateRegion ();
  2282.     XUnionRegion ((Nlm_RgnTool) rgn, ntool1, ntool2);
  2283.     XOffsetRegion (ntool2, -Nlm_XOffset, -Nlm_YOffset);
  2284.     XSetRegion (Nlm_currentXDisplay, Nlm_currentXGC, ntool2);
  2285.     if (Nlm_clpRgn != NULL) {
  2286.       XDestroyRegion ((Nlm_RgnTool) Nlm_clpRgn);
  2287.       Nlm_clpRgn = NULL;
  2288.     }
  2289.     Nlm_clpRgn = (Nlm_RegioN) XCreateRegion ();
  2290.     XUnionRegion ((Nlm_RgnTool) rgn, ntool1, (Nlm_RgnTool) Nlm_clpRgn);
  2291.     XOffsetRegion ((Nlm_RgnTool) Nlm_clpRgn, -Nlm_XOffset, -Nlm_YOffset);
  2292.     XDestroyRegion (ntool1);
  2293.     XDestroyRegion (ntool2);
  2294.   }
  2295. }
  2296.  
  2297. static void Nlm_SlateDrawCallback (Widget w, XtPointer client_data, XtPointer call_data)
  2298.  
  2299. {
  2300.   XmDrawingAreaCallbackStruct  *cbs;
  2301.   Pixel                        color;
  2302.   XEvent                       event;
  2303.   Nlm_WindoW                   newWindow;
  2304.   Nlm_WindoW                   oldWindow;
  2305.   Nlm_RecT                     r;
  2306.   Nlm_RegioN                   rgn1;
  2307.   Nlm_RegioN                   rgn2;
  2308.   Nlm_SlatE                    s;
  2309.   Nlm_RegioN                   tempRgn;
  2310.   Window                       tempWind;
  2311.  
  2312.   cbs = (XmDrawingAreaCallbackStruct *) call_data;
  2313.   s = (Nlm_SlatE) client_data;
  2314.   newWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2315.   if (! Nlm_IsWindowDying (newWindow)) {
  2316.     oldWindow = Nlm_CurrentWindow ();
  2317.     if (oldWindow != newWindow) {
  2318.       Nlm_UseWindow (newWindow);
  2319.     }
  2320.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2321.     Nlm_XOffset = r.left;
  2322.     Nlm_YOffset = r.top;
  2323.     tempWind = Nlm_currentXWindow;
  2324.     Nlm_currentXWindow = XtWindow (w);
  2325.     XtVaGetValues (w, XmNbackground, &color, 0);
  2326.     Nlm_XbackColor = color;
  2327.     XtVaGetValues (w, XmNforeground, &color, 0);
  2328.     Nlm_XforeColor = color;
  2329.     rgn1 = Nlm_CreateRgn ();
  2330.     event = (*(cbs->event));
  2331.     do {
  2332.       r.left = event.xexpose.x;
  2333.       r.top = event.xexpose.y;
  2334.       r.right = r.left + event.xexpose.width;
  2335.       r.bottom = r.top + event.xexpose.height;
  2336.       rgn2 = Nlm_CreateRgn ();
  2337.       Nlm_LoadRectRgn (rgn2, r.left, r.top, r.right, r.bottom);
  2338.       Nlm_UnionRgn (rgn1, rgn2, rgn1);
  2339.       Nlm_DestroyRgn (rgn2);
  2340.     } while (XCheckTypedWindowEvent (Nlm_currentXDisplay,
  2341.              Nlm_currentXWindow, Expose, &event));
  2342.     Nlm_OffsetRgn (rgn1, Nlm_XOffset, Nlm_YOffset);
  2343.     Nlm_ClipXRgn (rgn1);
  2344.     Nlm_DestroyRgn (rgn1);
  2345.     if (Nlm_updateRgn != NULL) {
  2346.       Nlm_DestroyRgn (Nlm_updateRgn);
  2347.     }
  2348.     Nlm_updateRgn = Nlm_CreateRgn ();
  2349.     tempRgn = Nlm_CreateRgn ();
  2350.     Nlm_UnionRgn (Nlm_clpRgn, tempRgn, Nlm_updateRgn);
  2351.     Nlm_DestroyRgn (tempRgn);
  2352.     XOffsetRegion ((Nlm_RgnTool) Nlm_updateRgn, Nlm_XOffset, Nlm_YOffset);
  2353.     Nlm_DrawSlate (s);
  2354.     if (Nlm_currentXDisplay != NULL && Nlm_currentXGC != NULL) {
  2355.       XSetClipMask (Nlm_currentXDisplay, Nlm_currentXGC, None);
  2356.       if (Nlm_clpRgn != NULL) {
  2357.         XDestroyRegion ((Nlm_RgnTool) Nlm_clpRgn);
  2358.         Nlm_clpRgn = NULL;
  2359.       }
  2360.     }
  2361.     if (Nlm_currentXDisplay != NULL) {
  2362.       XSync (Nlm_currentXDisplay, FALSE);
  2363.     }
  2364.     Nlm_currentXWindow = tempWind;
  2365.     if (oldWindow != newWindow) {
  2366.       Nlm_UseWindow (oldWindow);
  2367.     }
  2368.   }
  2369. }
  2370. #endif
  2371.  
  2372. static void Nlm_NewSlate (Nlm_SlatE s, Nlm_Boolean border,
  2373.                           Nlm_Boolean vScroll, Nlm_Boolean hScroll,
  2374.                           Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2375.                           Nlm_Int2 extra)
  2376.  
  2377. {
  2378.   Nlm_SlateTool   h;
  2379.   Nlm_BaR         hsb;
  2380.   Nlm_PoinT       npt;
  2381.   Nlm_RecT        r;
  2382.   Nlm_BaR         vsb;
  2383.   Nlm_WindowTool  wptr;
  2384. #ifdef WIN_MOTIF
  2385.   Cardinal        n;
  2386.   Arg             wargs [10];
  2387.   String          trans =
  2388.     "<Btn1Down>:     slate(down)   ManagerGadgetArm()  \n\
  2389.      <Btn1Up>:       slate(up)     ManagerGadgetActivate() \n\
  2390.      <Btn1Motion>:   slate(motion) ManagerGadgetButtonMotion() \n\
  2391.      <Key>:          piano(key)    ManagerGadgetActivate()";
  2392. #endif
  2393.  
  2394.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2395. #ifdef DCLAP
  2396.     Nlm_InsetRect( &r, 1, 1); /* for border outset */
  2397. #endif
  2398.   h = NULL;
  2399.   vsb = NULL;
  2400.   hsb = NULL;
  2401.   wptr = Nlm_ParentWindowPtr ((Nlm_GraphiC) s);
  2402. #ifdef WIN_MSWIN
  2403.   h = CreateWindow (slateclass, "", WS_CHILD,
  2404.                     r.left, r.top, r.right - r.left,
  2405.                     r.bottom - r.top, wptr, 0,
  2406.                     Nlm_currentHInst, NULL);
  2407.   if (h != NULL) {
  2408.     SetProp (h, (LPSTR) "Nlm_VibrantProp", (Nlm_HandleTool) s);
  2409.   }
  2410. #endif
  2411. #ifdef WIN_MOTIF
  2412.   n = 0;
  2413.   XtSetArg (wargs [n], XmNx, (Position) r.left); n++;
  2414.   XtSetArg (wargs [n], XmNy, (Position) r.top); n++;
  2415.   XtSetArg (wargs [n], XmNwidth, (Dimension) (r.right - r.left + 1)); n++;
  2416.   XtSetArg (wargs [n], XmNheight, (Dimension) (r.bottom - r.top + 1)); n++;
  2417.   XtSetArg (wargs [n], XmNmarginHeight, 0); n++;
  2418.   XtSetArg (wargs [n], XmNmarginWidth, 0); n++;
  2419.   XtSetArg (wargs [n], XmNborderWidth, (Dimension) 0); n++;
  2420.   XtSetArg (wargs [n], XmNtranslations, XtParseTranslationTable (trans)); n++;
  2421.   h = XtCreateManagedWidget ((String) "", xmDrawingAreaWidgetClass,
  2422.                              wptr, wargs, n);
  2423.   XtVaSetValues (h, XmNuserData, (XtPointer) s, NULL);
  2424.   XtAddCallback (h, XmNexposeCallback, Nlm_SlateDrawCallback, (XtPointer) s);
  2425.   if (NLM_QUIET) {
  2426.     if (Nlm_WindowHasBeenShown (Nlm_ParentWindow (s))) {
  2427.       XtRealizeWidget (h);
  2428.     }
  2429.   } else {
  2430.     XtRealizeWidget (h);
  2431.   }
  2432. #endif
  2433.   if (vScroll) {
  2434.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2435.     r.left = r.right;
  2436.     r.right += Nlm_vScrollBarWidth;
  2437.     if (vscrl != NULL) {
  2438.       vsb = Nlm_VertScrollBar ((Nlm_GraphiC) s, &r, (Nlm_ScrlProc) vscrl);
  2439.     } else {
  2440.       vsb = Nlm_VertScrollBar ((Nlm_GraphiC) s, &r,
  2441.                                (Nlm_ScrlProc) Nlm_SlateVertScrollAction);
  2442.     }
  2443.   }
  2444.   if (hScroll) {
  2445.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2446.     r.top = r.bottom;
  2447.     r.bottom += Nlm_hScrollBarHeight;
  2448.     if (hscrl != NULL) {
  2449.       hsb = Nlm_HorizScrollBar ((Nlm_GraphiC) s, &r, (Nlm_ScrlProc) hscrl);
  2450.     } else {
  2451.       hsb = Nlm_HorizScrollBar ((Nlm_GraphiC) s, &r,
  2452.                                 (Nlm_ScrlProc) Nlm_SlateHorizScrollAction);
  2453.     }
  2454.   }
  2455.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2456.   Nlm_InsetRect (&r, 4, 4);
  2457.   Nlm_LoadPt (&npt, r.left, r.top);
  2458.   Nlm_LoadBoxData ((Nlm_BoX) s, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  2459.   Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2460.   Nlm_LoadSlateData (s, h, vsb, hsb, NULL, NULL, 0, 0,
  2461.                      border, 0, 0, 0, NULL, NULL, FALSE);
  2462.   Nlm_LoadPanelData ((Nlm_PaneL) s, NULL, NULL, NULL, NULL, NULL, extra, NULL, NULL);
  2463. }
  2464.  
  2465. static void Nlm_NewPanel (Nlm_PaneL p, Nlm_PnlActnProc draw,
  2466.                           Nlm_Int2 extra, Nlm_PnlActnProc reset)
  2467.  
  2468. /*
  2469. *  MemNew already sets the extra data to NULL.  If the window is visible,
  2470. *  the draw request may occur before the extra data is initialized.
  2471. */
  2472.  
  2473. {
  2474.   Nlm_PoinT  npt;
  2475.   Nlm_RecT   r;
  2476.  
  2477.   Nlm_GetRect ((Nlm_GraphiC) p, &r);
  2478.   Nlm_LoadPt (&npt, r.left, r.top);
  2479.   Nlm_LoadBoxData ((Nlm_BoX) p, npt, npt, npt, npt.y, npt.x, 0, 0, 0, 0, 0, 0);
  2480.   Nlm_LoadPanelData (p, NULL, NULL, NULL, NULL, draw, extra, reset, NULL);
  2481. }
  2482.  
  2483. static void Nlm_NewDisplay (Nlm_DisplaY d)
  2484.  
  2485. {
  2486.   Nlm_PoinT   pos;
  2487.   Nlm_RecT    r;
  2488.   Nlm_Int2    vis;
  2489.   Nlm_WindoW  w;
  2490.  
  2491.   Nlm_GetRect ((Nlm_GraphiC) d, &r);
  2492.   Nlm_InsetRect (&r, 4, 4);
  2493.   Nlm_LoadPt (&pos, r.left, r.top + disphght);
  2494.   if (disphght > 0) {
  2495.     vis = (r.bottom - r.top + 1) / disphght;
  2496.   } else {
  2497.     vis = 0;
  2498.   }
  2499.   Nlm_LoadDisplayData (d, FALSE, FALSE, NULL, 0, vis, pos);
  2500.   w = Nlm_GetParentWindow ((Nlm_GraphiC) d);
  2501.   Nlm_SetWindowCharDisplay (w, d);
  2502. }
  2503.  
  2504. static Nlm_SlatE Nlm_CommonSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2505.                                   Nlm_Int2 height, Nlm_Boolean border,
  2506.                                   Nlm_Boolean vScroll, Nlm_Boolean hScroll,
  2507.                                   Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2508.                                   Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr)
  2509.  
  2510. {
  2511.   Nlm_GraphicData  gdata;
  2512.   Nlm_PoinT        npt;
  2513.   Nlm_RecT         r;
  2514.   Nlm_SlatE        s;
  2515.   Nlm_WindoW       tempPort;
  2516.  
  2517.   s = NULL;
  2518.   if (prnt != NULL) {
  2519.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2520.     Nlm_GetNextPosition ((Nlm_GraphiC) prnt, &npt);
  2521.     Nlm_SelectFont (Nlm_systemFont);
  2522.     Nlm_LoadRect (&r, npt.x, npt.y, npt.x+width, npt.y+height);
  2523.     s = (Nlm_SlatE) Nlm_CreateLink ((Nlm_GraphiC) prnt, &r, sizeof (Nlm_SlateRec) + extra, classPtr);
  2524.     if (s != NULL) {
  2525.       if (classPtr != NULL) {
  2526.         classPtr->ancestor = slateProcs;
  2527.       } else {
  2528.         Nlm_GetGraphicData ((Nlm_GraphiC) s, &gdata);
  2529.         gdata.classptr = slateProcs;
  2530.         Nlm_SetGraphicData ((Nlm_GraphiC) s, &gdata);
  2531.       }
  2532.       Nlm_NewSlate (s, border, vScroll, hScroll, vscrl, hscrl, extra);
  2533.       if (vScroll) {
  2534.         r.right += Nlm_vScrollBarWidth;
  2535.       }
  2536.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) s, &r, TRUE, FALSE);
  2537.       Nlm_DoShow ((Nlm_GraphiC) s, TRUE, FALSE);
  2538.     }
  2539.     Nlm_RestorePort (tempPort);
  2540.   }
  2541.   return s;
  2542. }
  2543.  
  2544. extern Nlm_SlatE Nlm_GeneralSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2545.                                    Nlm_Int2 height, Nlm_SltScrlProc scrl,
  2546.                                    Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr)
  2547.  
  2548. {
  2549.   Nlm_SlatE  s;
  2550.  
  2551.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2552.                        height*Nlm_stdLineHeight+8, TRUE,
  2553.                        TRUE, FALSE, scrl, NULL, extra, classPtr);
  2554.   return s;
  2555. }
  2556.  
  2557. extern Nlm_SlatE Nlm_ScrollSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2558.                                   Nlm_Int2 height)
  2559.  
  2560. {
  2561.   Nlm_SlatE  s;
  2562.  
  2563.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2564.                        height*Nlm_stdLineHeight+8, TRUE,
  2565.                        TRUE, FALSE, NULL, NULL, 0, NULL);
  2566.   return s;
  2567. }
  2568.  
  2569. extern Nlm_SlatE Nlm_NormalSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2570.                                   Nlm_Int2 height)
  2571.  
  2572. {
  2573.   Nlm_SlatE  s;
  2574.  
  2575.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2576.                        height*Nlm_stdLineHeight+8, TRUE,
  2577.                        FALSE, FALSE, NULL, NULL, 0, NULL);
  2578.   return s;
  2579. }
  2580.  
  2581. extern Nlm_SlatE Nlm_HiddenSlate (Nlm_GrouP prnt, Nlm_Int2 width,
  2582.                                   Nlm_Int2 height)
  2583.  
  2584. {
  2585.   Nlm_SlatE  s;
  2586.  
  2587.   s = Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2588.                        height*Nlm_stdLineHeight+8, FALSE,
  2589.                        FALSE, FALSE, NULL, NULL, 0, NULL);
  2590.   return s;
  2591. }
  2592.  
  2593. extern void Nlm_VirtualSlate (Nlm_SlatE s, Nlm_Int2 before,
  2594.                               Nlm_Int2 after, Nlm_SltScrlProc actn)
  2595.  
  2596. {
  2597.   Nlm_Handle     chdl;
  2598.   Nlm_Handle     rhdl;
  2599.   Nlm_BaR        sb;
  2600.   Nlm_SlateData  sdata;
  2601.  
  2602.   Nlm_GetSlateData (s, &sdata);
  2603.   rhdl = sdata.rowHandles;
  2604.   if (rhdl != NULL) {
  2605.     Nlm_HandFree (rhdl);
  2606.   }
  2607.   chdl = sdata.colHandles;
  2608.   if (chdl != NULL) {
  2609.     Nlm_HandFree (chdl);
  2610.   }
  2611.   sdata.rowHandles = NULL;
  2612.   sdata.colHandles = NULL;
  2613.   sdata.numRows = 0;
  2614.   sdata.numCols = 0;
  2615.   sdata.barRows = 0;
  2616.   sdata.vBefore = before;
  2617.   sdata.vAfter = after;
  2618.   sdata.vAction = actn;
  2619.   Nlm_SetSlateData (s, &sdata);
  2620.   sb = sdata.hScrollBar;
  2621.   if (sb != NULL) {
  2622.     Nlm_DoReset ((Nlm_GraphiC) sb, TRUE);
  2623.   }
  2624.   sb = sdata.vScrollBar;
  2625.   if (sb != NULL) {
  2626.     Nlm_DoReset ((Nlm_GraphiC) sb, TRUE);
  2627.   }
  2628. }
  2629.  
  2630. extern void Nlm_RegisterRow (Nlm_SlatE s, Nlm_Int2 position,
  2631.                              Nlm_Int2 height, Nlm_Int2 count)
  2632.  
  2633. {
  2634.   Nlm_Boolean    added;
  2635.   Nlm_Int2       after;
  2636.   Nlm_Int2       barmax;
  2637.   Nlm_Int2       before;
  2638.   Nlm_Int2       chunk;
  2639.   Nlm_Int2       numRows;
  2640.   Nlm_Int2       delta;
  2641.   Nlm_Int2       i;
  2642.   Nlm_OfsPtr     optr;
  2643.   Nlm_RecT       r;
  2644.   Nlm_Handle     rhdl;
  2645.   Nlm_BaR        sb;
  2646.   Nlm_SlateData  sdata;
  2647.   Nlm_WindoW     tempPort;
  2648.   Nlm_Int2       vis;
  2649.  
  2650.   if (s != NULL) {
  2651.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  2652.     Nlm_InsetRect (&r, 4, 4);
  2653.     Nlm_GetSlateData (s, &sdata);
  2654.     numRows = sdata.numRows;
  2655.     rhdl = sdata.rowHandles;
  2656.     added = FALSE;
  2657.     chunk = 128;
  2658.     delta = position - r.top;
  2659.     if (rhdl == NULL) {
  2660.       numRows = 1;
  2661.       rhdl = Nlm_HandNew (sizeof (Nlm_OffsetRec) * chunk);
  2662.       if (rhdl != NULL) {
  2663.         optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2664.         optr [numRows - 1].offset = delta;
  2665.         optr [numRows - 1].height = height;
  2666.         added = TRUE;
  2667.         Nlm_HandUnlock (rhdl);
  2668.       }
  2669.       delta += height;
  2670.       count--;
  2671.     }
  2672.     if (rhdl != NULL && count > 0) {
  2673.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2674.       for (i = 0; i < count; i++) {
  2675.         if (delta >= optr [numRows - 1].offset + optr [numRows - 1].height) {
  2676.           if (numRows % chunk == 0) {
  2677.             Nlm_HandUnlock (rhdl);
  2678.             rhdl = Nlm_HandMore (rhdl, sizeof (Nlm_OffsetRec) *
  2679.                                  (numRows / chunk + 1) * chunk);
  2680.             optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2681.           }
  2682.           numRows++;
  2683.           optr [numRows - 1].offset = delta;
  2684.           optr [numRows - 1].height = height;
  2685.           added = TRUE;
  2686.         } else if (delta == optr [numRows - 1].offset &&
  2687.                    height > optr [numRows - 1].height) {
  2688.           optr [numRows - 1].height = height;
  2689.           added = TRUE;
  2690.         }
  2691.         delta += height;
  2692.       }
  2693.       Nlm_HandUnlock (rhdl);
  2694.     }
  2695.     sdata.numRows = numRows;
  2696.     sdata.rowHandles = rhdl;
  2697.     Nlm_SetSlateData (s, &sdata);
  2698.     if (added) {
  2699.       optr = (Nlm_OfsPtr) Nlm_HandLock (rhdl);
  2700.       if (numRows > 1) {
  2701.         i = numRows - 2;
  2702.         vis = 0;
  2703.         while (i >= 0 && optr [numRows - 1].offset + optr [numRows - 1].height -
  2704.                optr [i].offset <= r.bottom - r.top) {
  2705.           i--;
  2706.           vis++;
  2707.         }
  2708.         barmax = numRows - vis - 1;
  2709.       } else {
  2710.         barmax = 0;
  2711.       }
  2712.       sdata.barRows = barmax;
  2713.       Nlm_SetSlateData (s, &sdata);
  2714.       i = 1;
  2715.       vis = 0;
  2716.       while (i < numRows && optr [i].offset + optr [i].height -
  2717.              optr [0].offset <= r.bottom - r.top) {
  2718.         i++;
  2719.         vis++;
  2720.       }
  2721.       Nlm_HandUnlock (rhdl);
  2722.       sb = sdata.vScrollBar;
  2723.       if (sb != NULL) {
  2724.         before = sdata.vBefore;
  2725.         after = sdata.vAfter;
  2726.         tempPort = Nlm_SavePort ((Nlm_GraphiC) s);
  2727.         Nlm_DoSetRange ((Nlm_GraphiC) sb, 1, vis, barmax + before + after, FALSE);
  2728.         if (before > 0) {
  2729.           Nlm_DoSetValue ((Nlm_GraphiC) sb, before, FALSE);
  2730.         }
  2731.         Nlm_RestorePort (tempPort);
  2732.       }
  2733.     }
  2734.   }
  2735. }
  2736.  
  2737. extern void Nlm_RegisterColumn (Nlm_SlatE s, Nlm_Int2 position,
  2738.                                 Nlm_Int2 width, Nlm_Int2 count)
  2739.  
  2740. {
  2741. }
  2742.  
  2743. extern void Nlm_SetPanelClick (Nlm_PaneL p, Nlm_PnlClckProc click,
  2744.                                Nlm_PnlClckProc drag, Nlm_PnlClckProc hold,
  2745.                                Nlm_PnlClckProc release)
  2746.  
  2747. {
  2748.   Nlm_PanelData  pdata;
  2749.  
  2750.   if (p != NULL) {
  2751.     Nlm_GetPanelData (p, &pdata);
  2752.     pdata.click = click;
  2753.     pdata.drag = drag;
  2754.     pdata.hold = hold;
  2755.     pdata.release = release;
  2756.     Nlm_SetPanelData (p, &pdata);
  2757.   }
  2758. }
  2759.  
  2760. extern Nlm_PaneL Nlm_GeneralPanel (Nlm_SlatE s, Nlm_PnlActnProc draw,
  2761.                                    Nlm_Int2 extra, Nlm_PnlActnProc reset,
  2762.                                    Nlm_GphPrcsPtr classPtr)
  2763.  
  2764. {
  2765.   Nlm_GraphicData  gdata;
  2766.   Nlm_PoinT        npt;
  2767.   Nlm_PaneL        p;
  2768.   Nlm_RecT         r;
  2769.   Nlm_WindoW       tempPort;
  2770.  
  2771.   p = NULL;
  2772.   if (s != NULL) {
  2773.     tempPort = Nlm_SavePort ((Nlm_GraphiC) s);
  2774.     Nlm_GetNextPosition ((Nlm_GraphiC) s, &npt);
  2775.     Nlm_SelectFont (Nlm_systemFont);
  2776.     Nlm_LoadRect (&r, npt.x, npt.y, npt.x, npt.y);
  2777.     p = (Nlm_PaneL) Nlm_CreateLink ((Nlm_GraphiC) s, &r, sizeof (Nlm_PanelRec) + extra, classPtr);
  2778.     if (p != NULL) {
  2779.       if (classPtr != NULL) {
  2780.         classPtr->ancestor = panelProcs;
  2781.       } else {
  2782.         Nlm_GetGraphicData ((Nlm_GraphiC) p, &gdata);
  2783.         gdata.classptr = panelProcs;
  2784.         Nlm_SetGraphicData ((Nlm_GraphiC) p, &gdata);
  2785.       }
  2786.       Nlm_NewPanel (p, draw, extra, reset);
  2787.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, &r, TRUE, FALSE);
  2788.       Nlm_DoShow ((Nlm_GraphiC) p, TRUE, FALSE);
  2789.     }
  2790.     Nlm_RestorePort (tempPort);
  2791.   }
  2792.   return p;
  2793. }
  2794.  
  2795. extern Nlm_PaneL Nlm_CustomPanel (Nlm_SlatE s, Nlm_PnlActnProc draw,
  2796.                                   Nlm_Int2 extra, Nlm_PnlActnProc reset)
  2797.  
  2798. {
  2799.   return (Nlm_GeneralPanel (s, draw, extra, reset, NULL));
  2800. }
  2801.  
  2802. extern Nlm_PaneL Nlm_AutonomousPanel (Nlm_GrouP prnt, Nlm_Int2 pixwidth,
  2803.                                       Nlm_Int2 pixheight, Nlm_PnlActnProc draw,
  2804.                                       Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl,
  2805.                                       Nlm_Int2 extra, Nlm_PnlActnProc reset,
  2806.                                       Nlm_GphPrcsPtr classPtr)
  2807.  
  2808. /*
  2809. *  Note that an autonomous panel is really a combination of slate and
  2810. *  panel in one object, and thus uses the slateProcs class function.
  2811. */
  2812.  
  2813. {
  2814.   Nlm_Boolean      border;
  2815.   Nlm_GraphicData  gdata;
  2816.   Nlm_Boolean      hScroll;
  2817.   Nlm_PoinT        npt;
  2818.   Nlm_PaneL        p;
  2819.   Nlm_RecT         r;
  2820.   Nlm_WindoW       tempPort;
  2821.   Nlm_Boolean      vScroll;
  2822.  
  2823.  
  2824.   p = NULL;
  2825.   if (prnt != NULL) {
  2826.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2827.     Nlm_GetNextPosition ((Nlm_GraphiC) prnt, &npt);
  2828.     Nlm_SelectFont (Nlm_systemFont);
  2829.     border = (Nlm_Boolean) (vscrl != NULL || hscrl != NULL);
  2830.     vScroll = (Nlm_Boolean) (vscrl != NULL);
  2831.     hScroll = (Nlm_Boolean) (hscrl != NULL);
  2832. #ifndef DCLAP
  2833.     /* dgg -- what the heck are these +8s for ?? */
  2834.     if (vScroll || hScroll) {
  2835.       Nlm_LoadRect (&r, npt.x, npt.y, npt.x+pixwidth+8, npt.y+pixheight+8);
  2836.     } else 
  2837. #endif
  2838.     {
  2839.       Nlm_LoadRect (&r, npt.x, npt.y, npt.x+pixwidth, npt.y+pixheight);
  2840.     }
  2841.     p = (Nlm_PaneL) Nlm_CreateLink ((Nlm_GraphiC) prnt, &r, sizeof (Nlm_PanelRec) + extra, classPtr);
  2842.     if (p != NULL) {
  2843.       if (classPtr != NULL) {
  2844.         classPtr->ancestor = slateProcs;
  2845.       } else {
  2846.         Nlm_GetGraphicData ((Nlm_GraphiC) p, &gdata);
  2847.         gdata.classptr = slateProcs;
  2848.         Nlm_SetGraphicData ((Nlm_GraphiC) p, &gdata);
  2849.       }
  2850.       Nlm_NewSlate ((Nlm_SlatE) p, border, vScroll, hScroll, vscrl, hscrl, extra);
  2851.       Nlm_NewPanel (p, draw, extra, reset);
  2852.       if (vScroll) {
  2853.         r.right += Nlm_vScrollBarWidth;
  2854.       }
  2855.       if (hScroll) {
  2856.         r.bottom += Nlm_hScrollBarHeight;
  2857.       }
  2858.       Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, &r, TRUE, FALSE);
  2859.       Nlm_DoShow ((Nlm_GraphiC) p, TRUE, FALSE);
  2860.     }
  2861.     Nlm_RestorePort (tempPort);
  2862.   }
  2863.   return p;
  2864. }
  2865.  
  2866. extern Nlm_PaneL Nlm_SimplePanel (Nlm_GrouP prnt, Nlm_Int2 pixwidth,
  2867.                                   Nlm_Int2 pixheight, Nlm_PnlActnProc draw)
  2868.  
  2869. {
  2870.   Nlm_PaneL  p;
  2871.  
  2872.   p = Nlm_AutonomousPanel (prnt, pixwidth, pixheight, draw, NULL, NULL, 0, NULL, NULL);
  2873.   return p;
  2874. }
  2875.  
  2876. extern void Nlm_RegisterRect (Nlm_PaneL p, Nlm_RectPtr r)
  2877.  
  2878. {
  2879.   Nlm_BoxData  bdata;
  2880.   Nlm_RecT     pr;
  2881.  
  2882.   if (p != NULL && r != NULL) {
  2883.     Nlm_RecordRect ((Nlm_GraphiC) p, r);
  2884.     Nlm_NextPosition ((Nlm_GraphiC) p, r);
  2885.     Nlm_GetRect ((Nlm_GraphiC) p, &pr);
  2886.     Nlm_GetBoxData ((Nlm_BoX) p, &bdata);
  2887.     pr.right = bdata.limitPoint.x;
  2888.     pr.bottom = bdata.limitPoint.y;
  2889.     Nlm_SetRect ((Nlm_GraphiC) p, &pr);
  2890.     Nlm_DoAdjustPrnt ((Nlm_GraphiC) p, r, TRUE, TRUE);
  2891.   }
  2892. }
  2893.  
  2894. static Nlm_DisplaY Nlm_CommonDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2895.                                       Nlm_Int2 height, Nlm_Boolean hidden,
  2896.                                       Nlm_Boolean scroll)
  2897.  
  2898. {
  2899.   Nlm_DisplaY  d;
  2900.   Nlm_WindoW   tempPort;
  2901.  
  2902.   d = NULL;
  2903.   if (prnt != NULL) {
  2904.     tempPort = Nlm_SavePort ((Nlm_GraphiC) prnt);
  2905.     dispfont = Nlm_programFont;
  2906.     Nlm_SelectFont (dispfont);
  2907.     disphght = Nlm_LineHeight ();
  2908.     if (hidden) {
  2909.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2910.                                          height*Nlm_stdLineHeight+8, FALSE,
  2911.                                          FALSE, FALSE, NULL, NULL,
  2912.                                          sizeof (Nlm_DisplayData), displayProcs);
  2913.     } else if (scroll) {
  2914.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2915.                                          height*Nlm_stdLineHeight+8, TRUE,
  2916.                                          TRUE, FALSE, NULL, NULL,
  2917.                                          sizeof (Nlm_DisplayData), displayProcs);
  2918.     } else {
  2919.       d = (Nlm_DisplaY) Nlm_CommonSlate (prnt, width*Nlm_stdCharWidth+8,
  2920.                                          height*Nlm_stdLineHeight+8, TRUE,
  2921.                                          FALSE, FALSE, NULL, NULL,
  2922.                                          sizeof (Nlm_DisplayData), displayProcs);
  2923.     }
  2924.     if (d != NULL) {
  2925.       Nlm_NewDisplay (d);
  2926.     }
  2927.     Nlm_SelectFont (Nlm_systemFont);
  2928.     Nlm_RestorePort (tempPort);
  2929.   }
  2930.   return d;
  2931. }
  2932.  
  2933. extern Nlm_DisplaY Nlm_NormalDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2934.                                       Nlm_Int2 height)
  2935.  
  2936. {
  2937.   return (Nlm_CommonDisplay (prnt, width, height, FALSE, FALSE));
  2938. }
  2939.  
  2940. extern Nlm_DisplaY Nlm_ScrollDisplay (Nlm_GrouP prnt, Nlm_Int2 width,
  2941.                                       Nlm_Int2 height)
  2942.  
  2943. {
  2944.   return (Nlm_CommonDisplay (prnt, width, height, FALSE, TRUE));
  2945. }
  2946.  
  2947. extern void Nlm_CaptureSlateFocus (Nlm_SlatE s)
  2948.  
  2949. {
  2950.   Nlm_WindoW     w;
  2951. #ifdef WIN_MSWIN
  2952.   Nlm_SlateTool  h;
  2953. #endif
  2954. #ifdef WIN_MOTIF
  2955.   Nlm_SlateTool  h;
  2956. #endif
  2957.  
  2958.   w = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  2959.   Nlm_DoLoseFocus ((Nlm_GraphiC) w, (Nlm_GraphiC) s, FALSE);
  2960.   Nlm_ChangeSlateFocus (s, TRUE);
  2961. #ifdef WIN_MSWIN
  2962.   h = Nlm_GetSlateHandle (s);
  2963.   if (h != NULL) {
  2964.     SetFocus (h);
  2965.   }
  2966. #endif
  2967. #ifdef WIN_MOTIF
  2968.   h = Nlm_GetSlateHandle (s);
  2969.   if (h != NULL) {
  2970.     XmProcessTraversal (h, XmTRAVERSE_CURRENT);
  2971.   }
  2972. #endif
  2973. }
  2974.  
  2975. static Nlm_GraphiC Nlm_SlateGainFocus (Nlm_GraphiC s, Nlm_Char ch, Nlm_Boolean savePort)
  2976.  
  2977. {
  2978.   Nlm_SltCharProc  keyProc;
  2979.   Nlm_GraphiC      rsult;
  2980.  
  2981.   rsult = NULL;
  2982.   keyProc = Nlm_GetSlateCharProc ((Nlm_SlatE) s);
  2983.   if (keyProc != NULL) {
  2984.     Nlm_ChangeSlateFocus ((Nlm_SlatE) s, TRUE);
  2985.     rsult = s;
  2986.   }
  2987.   return rsult;
  2988. }
  2989.  
  2990. static void Nlm_SlateLoseFocus (Nlm_GraphiC s, Nlm_GraphiC excpt, Nlm_Boolean savePort)
  2991.  
  2992. {
  2993.   if (s != excpt) {
  2994.     Nlm_ChangeSlateFocus ((Nlm_SlatE) s, FALSE);
  2995.   }
  2996. }
  2997.  
  2998. #ifdef WIN_MAC
  2999. extern Nlm_Boolean Nlm_RegisterSlates (void)
  3000.  
  3001. {
  3002.   return TRUE;
  3003. }
  3004. #endif
  3005.  
  3006. #ifdef WIN_MSWIN
  3007. static void Nlm_DrawSlate (Nlm_SlatE s)
  3008.  
  3009. {
  3010.   Nlm_PnlActnProc  drw;
  3011.   Nlm_SlateTool    h;
  3012.   Nlm_PaneL        n;
  3013.   Nlm_PaneL        p;
  3014.   Nlm_PanelData    pdata;
  3015.   Nlm_RecT         r;
  3016.  
  3017.   if (Nlm_GetVisible ((Nlm_GraphiC) s) && Nlm_GetAllParentsVisible ((Nlm_GraphiC) s)) {
  3018.     h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  3019.     if (h != NULL && IsWindowVisible (h)) {
  3020.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3021. #ifndef DCLAP
  3022.       Nlm_SelectFont (Nlm_systemFont);
  3023. #endif
  3024.       Nlm_ResetDrawingTools ();
  3025.             Nlm_DrawSlateBorder( s);
  3026.       Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  3027.       if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  3028.           pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  3029.         p = (Nlm_PaneL) s;
  3030. /*
  3031.         recentlyClickedPanel = p;
  3032. */
  3033.         drw = Nlm_GetPanelDraw (p);
  3034.         if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3035.           drw (p);
  3036.           Nlm_ResetDrawingTools ();
  3037.         }
  3038.       } else {
  3039.         p = (Nlm_PaneL) Nlm_GetChild ((Nlm_GraphiC) s);
  3040.         while (p != NULL) {
  3041.           n = (Nlm_PaneL) Nlm_GetNext ((Nlm_GraphiC) p);
  3042.           drw = Nlm_GetPanelDraw (p);
  3043.           if (drw != NULL && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3044.             drw (p);
  3045.             Nlm_ResetDrawingTools ();
  3046.           }
  3047.           p = n;
  3048.         }
  3049.       }
  3050.     }
  3051.   }
  3052. }
  3053.  
  3054. /* Message cracker functions */
  3055.  
  3056. static void MyCls_OnLButtonDown (HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
  3057.  
  3058. {
  3059.   Nlm_PnlClckProc  clk;
  3060.   Nlm_SlateTool    h;
  3061.   Nlm_Int2         hOffset;
  3062.   Nlm_PaneL        n;
  3063.   Nlm_Boolean      notInside;
  3064.   Nlm_PaneL        p;
  3065.   Nlm_PanelData    pdata;
  3066.   Nlm_PoinT        pt;
  3067.   Nlm_RecT         r;
  3068.   Nlm_SlatE        s;
  3069.   Nlm_Int2         vOffset;
  3070.  
  3071.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3072.   h = Nlm_GetSlateHandle (s);
  3073.   Nlm_ctrlKey = (Nlm_Boolean) ((MK_CONTROL & keyFlags) != 0);
  3074.   Nlm_shftKey = (Nlm_Boolean) ((MK_SHIFT & keyFlags) != 0);
  3075.   SetCapture (hwnd);
  3076.   currentSlate = s;
  3077.   Nlm_dblClick = fDoubleClick;
  3078.   if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3079.     SetTimer (h, 2, 100, NULL);
  3080.     slateTimerUsed = TRUE;
  3081.     slateTimer = h;
  3082.     Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3083.     Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3084.     recentlyClickedSlate = (Nlm_SlatE) s;
  3085.     recentlyClickedPanel = NULL;
  3086.     Nlm_SelectFont (Nlm_systemFont);
  3087.     Nlm_ResetDrawingTools ();
  3088.     Nlm_GetPanelData ((Nlm_PaneL) s, &pdata);
  3089.     if (pdata.click != NULL || pdata.drag != NULL || pdata.hold != NULL ||
  3090.         pdata.release != NULL || pdata.draw != NULL || pdata.reset != NULL) {
  3091.       p = (Nlm_PaneL) s;
  3092.       recentlyClickedPanel = p;
  3093.       clk = Nlm_GetPanelClick (p);
  3094.       if (clk != NULL && Nlm_GetEnabled ((Nlm_GraphiC) p) && Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3095.         clk (p, pt);
  3096.         Nlm_Update ();
  3097.       }
  3098.     } else {
  3099.       p = Nlm_CreateReverseLinks ((Nlm_SlatE) s);
  3100.       notInside = TRUE;
  3101.       while (p != NULL && notInside) {
  3102.         n = Nlm_GetPanelPrev (p);
  3103.         Nlm_GetPanelData (p, &pdata);
  3104.         if (pdata.click != NULL || pdata.drag != NULL ||
  3105.             pdata.hold != NULL || pdata.release != NULL) {
  3106.           Nlm_GetRect ((Nlm_GraphiC) p, &r);
  3107.           Nlm_DoGetOffset ((Nlm_GraphiC) p, &hOffset, &vOffset);
  3108.           Nlm_OffsetRect (&r, -hOffset, -vOffset);
  3109.           if (Nlm_PtInRect (pt, &r) && Nlm_GetEnabled ((Nlm_GraphiC) p) &&
  3110.               Nlm_GetVisible ((Nlm_GraphiC) p)) {
  3111.             recentlyClickedPanel = p;
  3112.             notInside = FALSE;
  3113.             clk = Nlm_GetPanelClick (p);
  3114.             if (clk != NULL) {
  3115.               clk (p, pt);
  3116.               Nlm_Update ();
  3117.             }
  3118.           }
  3119.         }
  3120.         p = n;
  3121.       }
  3122.     }
  3123.   }
  3124. }
  3125.  
  3126. static void MyCls_OnMouseMove (HWND hwnd, int x, int y, UINT keyFlags)
  3127.  
  3128. {
  3129.   Nlm_PnlClckProc  drg;
  3130.   Nlm_PaneL        p;
  3131.   Nlm_PoinT        pt;
  3132.   Nlm_RecT         r;
  3133.   Nlm_SlatE        s;
  3134.  
  3135.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3136.   if (currentSlate == s) {
  3137.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) &&
  3138.         Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3139.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3140.       Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3141.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3142.         p = recentlyClickedPanel;
  3143.         drg = Nlm_GetPanelDrag (p);
  3144.         if (drg != NULL) {
  3145.           Nlm_ResetDrawingTools ();
  3146.           drg (p, pt);
  3147.         }
  3148.       }
  3149.     }
  3150.   }
  3151. }
  3152.  
  3153. static void MyCls_OnLButtonUp (HWND hwnd, int x, int y, UINT keyFlags)
  3154.  
  3155. {
  3156.   Nlm_SlateTool    h;
  3157.   Nlm_PaneL        p;
  3158.   Nlm_PoinT        pt;
  3159.   Nlm_RecT         r;
  3160.   Nlm_PnlClckProc  rls;
  3161.   Nlm_SlatE        s;
  3162.  
  3163.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3164.   ReleaseCapture ();
  3165.   h = Nlm_GetSlateHandle ((Nlm_SlatE) s);
  3166.   if (slateTimerUsed) {
  3167.     KillTimer (h, 2);
  3168.     slateTimer = NULL;
  3169.   }
  3170. #ifdef DCLAP
  3171.     /* dgg - need these on mouseup also! */
  3172.   Nlm_ctrlKey = (Nlm_Boolean) ((MK_CONTROL & keyFlags) != 0);
  3173.   Nlm_shftKey = (Nlm_Boolean) ((MK_SHIFT & keyFlags) != 0);
  3174. #endif
  3175.   slateTimerUsed = FALSE;
  3176.   if (currentSlate == s) {
  3177.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) &&
  3178.         Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3179.       Nlm_GetRect ((Nlm_GraphiC) s, &r);
  3180.       Nlm_LoadPt (&pt, (Nlm_Int2) x + r.left, (Nlm_Int2) y + r.top);
  3181.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3182.         p = recentlyClickedPanel;
  3183.         rls = Nlm_GetPanelRelease (p);
  3184.         if (rls != NULL) {
  3185.           Nlm_ResetDrawingTools ();
  3186.           rls (p, pt);
  3187.         }
  3188.       }
  3189.       Nlm_SelectFont (Nlm_systemFont);
  3190.       Nlm_ResetDrawingTools ();
  3191.       recentlyClickedSlate = NULL;
  3192.       recentlyClickedPanel = NULL;
  3193.     }
  3194.   }
  3195.   currentSlate = NULL;
  3196. }
  3197.  
  3198. static void MyCls_OnTimer (HWND hwnd, UINT id)
  3199.  
  3200. {
  3201.   Nlm_PaneL        p;
  3202.   Nlm_PnlClckProc  prs;
  3203.   Nlm_PoinT        pt;
  3204.   Nlm_SlatE        s;
  3205.  
  3206.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3207.   if (currentSlate == s) {
  3208.     if (Nlm_GetEnabled ((Nlm_GraphiC) s) && Nlm_GetVisible ((Nlm_GraphiC) s)) {
  3209.       Nlm_MousePosition (&pt);
  3210.       if ((Nlm_SlatE) s == recentlyClickedSlate && recentlyClickedPanel != NULL) {
  3211.         p = recentlyClickedPanel;
  3212.         prs = Nlm_GetPanelHold (p);
  3213.         if (prs != NULL) {
  3214.           Nlm_ResetDrawingTools ();
  3215.           prs (p, pt);
  3216.         }
  3217.       }
  3218.     }
  3219.   }
  3220. }
  3221.  
  3222. static void MyCls_OnPaint (HWND hwnd)
  3223.  
  3224. {
  3225.   PAINTSTRUCT    ps;
  3226.   Nlm_PointTool  ptool;
  3227.   Nlm_RectTool   rtool;
  3228.   Nlm_SlatE      s;
  3229.   Nlm_PortTool   temp;
  3230.  
  3231.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3232.   temp = Nlm_currentHDC;
  3233.   GetUpdateRgn (hwnd, (Nlm_RgnTool) Nlm_updateRgn, TRUE);
  3234.   GetWindowRect (hwnd, &rtool);
  3235.   ptool = * (PPOINT) &rtool.left;
  3236.   ScreenToClient (Nlm_currentHWnd, &ptool);
  3237.   Nlm_OffsetRgn (Nlm_updateRgn, (Nlm_Int2) ptool.x, (Nlm_Int2) ptool.y);
  3238.   BeginPaint (hwnd, &ps);
  3239.   Nlm_currentHDC = Nlm_ParentWindowPort ((Nlm_GraphiC) s);
  3240.   SelectClipRgn (Nlm_currentHDC, (Nlm_RgnTool) Nlm_updateRgn);
  3241.   GetRgnBox ((Nlm_RgnTool) Nlm_updateRgn, &rtool);
  3242.   Nlm_RectToolToRecT (&rtool, &Nlm_updateRect);
  3243.   Nlm_DrawSlate (s);
  3244.   EndPaint (hwnd, &ps);
  3245.   GetWindowRect (Nlm_currentHWnd, &rtool);
  3246.   ptool = * (PPOINT) &rtool.left;
  3247.   SetRectRgn ((Nlm_RgnTool) Nlm_updateRgn, rtool.left,
  3248.               rtool.top, rtool.right, rtool.bottom);
  3249.   Nlm_OffsetRgn (Nlm_updateRgn, (Nlm_Int2) (-ptool.x), (Nlm_Int2) (-ptool.y));
  3250.   SelectClipRgn (Nlm_currentHDC, NULL);
  3251.   GetRgnBox ((Nlm_RgnTool) Nlm_updateRgn, &rtool);
  3252.   Nlm_RectToolToRecT (&rtool, &Nlm_updateRect);
  3253.   Nlm_currentHDC = temp;
  3254. }
  3255.  
  3256. static void MyCls_OnChar (HWND hwnd, UINT ch, int cRepeat)
  3257.  
  3258. {
  3259.   Nlm_SltCharProc  keyProc;
  3260.   Nlm_SlatE        s;
  3261.  
  3262.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3263.   keyProc = Nlm_GetSlateCharProc (s);
  3264.   handlechar = FALSE;
  3265.   if (keyProc != NULL) {
  3266.     keyProc (s, (Nlm_Char) ch);
  3267.   } else if (ch == '\t') {
  3268.     Nlm_DoSendFocus ((Nlm_GraphiC) s, (Nlm_Char) ch);
  3269.   } else if (ch == '\n' || ch == '\r') {
  3270.     Nlm_DoSendFocus ((Nlm_GraphiC) s, (Nlm_Char) ch);
  3271.   } else {
  3272.     handlechar = TRUE;
  3273.   }
  3274. }
  3275.  
  3276. static void MyCls_OnSetFocus (HWND hwnd, HWND hwndOldFocus)
  3277.  
  3278. {
  3279.   Nlm_SlatE  s;
  3280.  
  3281.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3282.   Nlm_ChangeSlateFocus (s, TRUE);
  3283. }
  3284.  
  3285. static void MyCls_OnKillFocus (HWND hwnd, HWND hwndNewFocus)
  3286.  
  3287. {
  3288.   Nlm_SlatE  s;
  3289.  
  3290.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3291.   Nlm_ChangeSlateFocus (s, FALSE);
  3292. }
  3293.  
  3294. LRESULT CALLBACK EXPORT SlateProc (HWND hwnd, UINT message,
  3295.                                    WPARAM wParam, LPARAM lParam)
  3296.  
  3297. {
  3298.   LRESULT      rsult;
  3299.   Nlm_SlatE    s;
  3300.   HDC          tempHDC;
  3301.   HWND         tempHWnd;
  3302.   Nlm_Boolean  clearRecent;  /* dgg */
  3303.  
  3304.   if (Nlm_VibrantDisabled ()) {
  3305.     return DefWindowProc (hwnd, message, wParam, lParam);
  3306.   }
  3307.  
  3308.   rsult = 0;
  3309.   clearRecent = FALSE;
  3310.   tempHWnd = Nlm_currentHWnd;
  3311.   tempHDC = Nlm_currentHDC;
  3312.   s = (Nlm_SlatE) GetProp (hwnd, (LPSTR) "Nlm_VibrantProp");
  3313.   Nlm_theWindow = Nlm_GetParentWindow ((Nlm_GraphiC) s);
  3314.   Nlm_currentHWnd = GetParent (hwnd);
  3315.   Nlm_currentHDC = Nlm_ParentWindowPort ((Nlm_GraphiC) s);
  3316.   Nlm_currentWindowTool = hwnd;
  3317.   Nlm_currentKey = '\0';
  3318.   Nlm_currentWParam = wParam;
  3319.   Nlm_currentLParam = lParam;
  3320.   Nlm_cmmdKey = FALSE;
  3321.   Nlm_ctrlKey = FALSE;
  3322.   Nlm_optKey = FALSE;
  3323.   Nlm_shftKey = FALSE;
  3324.   Nlm_dblClick = FALSE;
  3325.   switch (message) {
  3326.     case WM_LBUTTONDBLCLK:
  3327.       HANDLE_WM_LBUTTONDBLCLK (hwnd, wParam, lParam, MyCls_OnLButtonDown);
  3328.       break;
  3329.     case WM_LBUTTONDOWN:
  3330.       HANDLE_WM_LBUTTONDOWN (hwnd, wParam, lParam, MyCls_OnLButtonDown);
  3331.       break;
  3332.     case WM_MOUSEMOVE:
  3333.       HANDLE_WM_MOUSEMOVE (hwnd, wParam, lParam, MyCls_OnMouseMove);
  3334.       break;
  3335.     case WM_TIMER:
  3336.       HANDLE_WM_TIMER (hwnd, wParam, lParam, MyCls_OnTimer);
  3337.       break;
  3338.     case WM_LBUTTONUP:
  3339.       HANDLE_WM_LBUTTONUP (hwnd, wParam, lParam, MyCls_OnLButtonUp);
  3340. #ifdef DCLAP
  3341.       clearRecent = TRUE;
  3342. #endif
  3343.       break;
  3344.     case WM_PAINT:
  3345.       HANDLE_WM_PAINT (hwnd, wParam, lParam, MyCls_OnPaint);
  3346.       break;
  3347.     case WM_CHAR:
  3348.       HANDLE_WM_CHAR (hwnd, wParam, lParam, MyCls_OnChar);
  3349.       if (handlechar) {
  3350.         rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3351.       }
  3352.       break;
  3353.     case WM_SETFOCUS:
  3354.       HANDLE_WM_SETFOCUS (hwnd, wParam, lParam, MyCls_OnSetFocus);
  3355.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3356.       break;
  3357.     case WM_KILLFOCUS:
  3358.       HANDLE_WM_KILLFOCUS (hwnd, wParam, lParam, MyCls_OnKillFocus);
  3359.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3360.       break;
  3361.     default:
  3362.       rsult = DefWindowProc (hwnd, message, wParam, lParam);
  3363. #ifdef DCLAP
  3364.       /* clearRecent = TRUE; << bad, calls here for DRAG message !? */
  3365. #endif
  3366.       break;
  3367.   }
  3368.  
  3369. /* jk modification of dgg addition -- clear problems w/ drag message appearing after mouseup */
  3370.   if (clearRecent) {
  3371.     recentlyClickedSlate = NULL;
  3372.     recentlyClickedPanel = NULL;
  3373.   }
  3374.  
  3375.   Nlm_currentHWnd = tempHWnd;
  3376.   Nlm_currentHDC = tempHDC;
  3377.   Nlm_currentWindowTool = tempHWnd;
  3378.   return rsult;
  3379. }
  3380.  
  3381. extern Nlm_Boolean Nlm_RegisterSlates (void)
  3382.  
  3383. {
  3384.   Nlm_Boolean  rsult;
  3385.   WNDCLASS     wc;
  3386.  
  3387.   rsult = FALSE;
  3388.   wc.style = CS_PARENTDC | CS_DBLCLKS;
  3389.   wc.lpfnWndProc = SlateProc;
  3390.   wc.cbClsExtra = 0;
  3391.   wc.cbWndExtra = 0;
  3392.   wc.hInstance = Nlm_currentHInst;
  3393.   wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  3394.   wc.hCursor = LoadCursor (NULL, IDC_ARROW);
  3395.   wc.hbrBackground = GetStockObject (HOLLOW_BRUSH);
  3396.   wc.lpszMenuName = NULL;
  3397.   sprintf (slateclass, "Nlm_SlateClass%ld", (long) (int) Nlm_currentHInst);
  3398.   wc.lpszClassName = slateclass;
  3399.   rsult = (Nlm_Boolean) RegisterClass (&wc);
  3400.   return rsult;
  3401. }
  3402. #endif
  3403.  
  3404. #ifdef WIN_MOTIF
  3405. extern Nlm_Boolean Nlm_RegisterSlates (void)
  3406.  
  3407. {
  3408.   XtActionsRec  actions;
  3409.  
  3410.   actions.string = "slate";
  3411.   actions.proc = Nlm_SlateClickCallback;
  3412.   XtAppAddActions (Nlm_appContext, &actions, 1);
  3413.   actions.string = "piano";
  3414.   actions.proc = Nlm_SlateKeyCallback;
  3415.   XtAppAddActions (Nlm_appContext, &actions, 1);
  3416.   return TRUE;
  3417. }
  3418. #endif
  3419.  
  3420. extern void Nlm_KillSlateTimer (void)
  3421.  
  3422. {
  3423.   recentlyClickedSlate = NULL;
  3424.   recentlyClickedPanel = NULL;
  3425. #ifdef WIN_MAC
  3426. #endif
  3427. #ifdef WIN_MSWIN
  3428.   if (slateTimerUsed) {
  3429.     KillTimer (slateTimer, 2);
  3430.     slateTimer = NULL;
  3431.   }
  3432.   slateTimerUsed = FALSE;
  3433. #endif
  3434. #ifdef WIN_MOTIF
  3435.   if (slateTimerUsed) {
  3436.     XtRemoveTimeOut (slateTimer);
  3437.     slateTimer = 0;
  3438.   }
  3439.   slateTimerUsed = FALSE;
  3440. #endif
  3441. }
  3442.  
  3443. extern void Nlm_FreeSlate (void)
  3444.  
  3445. {
  3446.   gphprcsptr = (Nlm_GphPrcsPtr) Nlm_MemFree (gphprcsptr);
  3447. }
  3448.  
  3449. extern void Nlm_InitSlate (void)
  3450.  
  3451. {
  3452.   gphprcsptr = (Nlm_GphPrcsPtr) Nlm_MemNew (sizeof (Nlm_GphPrcs) * 3);
  3453.  
  3454.   slateProcs = &(gphprcsptr [0]);
  3455. #ifdef WIN_MAC
  3456.   slateProcs->click = Nlm_SlateClick;
  3457.   slateProcs->key = Nlm_SlateKey;
  3458.   slateProcs->draw = Nlm_DrawSlate;
  3459. #endif
  3460. #ifdef WIN_MSWIN
  3461.   slateProcs->command = Nlm_SlateCommand;
  3462. #endif
  3463. #ifdef WIN_MOTIF
  3464.   slateProcs->callback = Nlm_SlateCallback;
  3465. #endif
  3466.   slateProcs->show = Nlm_ShowSlate;
  3467.   slateProcs->hide = Nlm_HideSlate;
  3468.   slateProcs->enable = Nlm_EnableSlate;
  3469.   slateProcs->disable = Nlm_DisableSlate;
  3470.   slateProcs->remove = Nlm_RemoveSlate;
  3471.   slateProcs->reset = Nlm_ResetSlate;
  3472.   slateProcs->select = Nlm_SelectSlate;
  3473.   slateProcs->countItems = Nlm_CountGroupItems;
  3474.   slateProcs->linkIn = Nlm_LinkIn;
  3475.   slateProcs->adjustPrnt = Nlm_AdjustSlate;
  3476.   slateProcs->setOffset = Nlm_SetSlateOffset;
  3477.   slateProcs->getOffset = Nlm_GetSlateOffset;
  3478.   slateProcs->setPosition = Nlm_SetSlatePosition;
  3479.   slateProcs->getPosition = Nlm_GetSlatePosition;
  3480.   slateProcs->setRange = Nlm_SetSlateRange;
  3481.   slateProcs->gainFocus = Nlm_SlateGainFocus;
  3482.   slateProcs->loseFocus = Nlm_SlateLoseFocus;
  3483.  
  3484.   panelProcs = &(gphprcsptr [1]);
  3485.   panelProcs->show = Nlm_ShowPanel;
  3486.   panelProcs->hide = Nlm_HidePanel;
  3487.   panelProcs->enable = Nlm_EnablePanel;
  3488.   panelProcs->disable = Nlm_DisablePanel;
  3489.   panelProcs->remove = Nlm_RemovePanel;
  3490.   panelProcs->reset = Nlm_ResetPanel;
  3491.   panelProcs->select = Nlm_SelectPanel;
  3492.   panelProcs->getOffset = Nlm_GetPanelOffset;
  3493.   panelProcs->setPosition = Nlm_SetPanelPosition;
  3494.   panelProcs->getPosition = Nlm_GetPanelPosition;
  3495.  
  3496.   displayProcs = &(gphprcsptr [2]);
  3497.   displayProcs->select = Nlm_SelectDisplay;
  3498.   displayProcs->sendChar = Nlm_PaintOrFormatChar;
  3499. }
  3500.