home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Science / RasMol2 / rasmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-25  |  64.9 KB  |  2,187 lines  |  [TEXT/KAHL]
  1. /* rasmac.c
  2.  * RasMol Molecular Graphics
  3.  * Roger Sayle, October 1994
  4.  * Version 2.5
  5.  */
  6. #include <string.h>
  7. #include <stdio.h>
  8.  
  9. #ifdef __CONDITIONALMACROS__
  10. #include <Printing.h>
  11. #else
  12. #include <PrintTraps.h>
  13. #endif
  14.  
  15. #include <StandardFile.h>
  16. #include <AppleEvents.h>
  17. #include <GestaltEqu.h>
  18. #include <ToolUtils.h>
  19. #include <Resources.h>
  20. #include <OSEvents.h>
  21. #include <DiskInit.h>
  22. #include <OSUtils.h>
  23. #include <SegLoad.h>
  24. #include <Events.h>
  25. #include <Memory.h>
  26. #include <Finder.h>
  27. #include <Files.h>
  28. #include <Types.h>
  29. #include <Scrap.h>
  30. #include <Desk.h>
  31. #include <EPPC.h>
  32.  
  33. #include <Quickdraw.h>
  34. #include <Controls.h>
  35. #include <Palettes.h>
  36. #include <TextEdit.h>
  37. #include <Windows.h>
  38. #include <Dialogs.h>
  39. #include <Menus.h>
  40. #include <Fonts.h>
  41.  
  42. #define RASMOL
  43. #include "rasmol.h"
  44. #include "molecule.h"
  45. #include "graphics.h"
  46. #include "pixutils.h"
  47. #include "transfor.h"
  48. #include "command.h"
  49. #include "abstree.h"
  50. #include "render.h"
  51. #include "outfile.h"
  52.  
  53.  
  54. /* Determine Mouse Sensitivity! */
  55. #define IsClose(u,v)  (((u)>=(v)-1) && ((u)<=(v)+1))
  56.  
  57. #define CmndSize   (CmndRows*CmndCols)
  58. #define ScrlMax    80
  59. #define CmndRows   160
  60. #define CmndCols   80
  61.  
  62. /* Terminal Emulation Variables */
  63. static char TermScreen[CmndSize];
  64.  
  65. static int CharSkip;
  66. static int CmndStart;
  67. static int ScrlStart;
  68. static int TermCursor;
  69. static int CharWide,CharHigh;
  70. static int TermXPos,TermYPos;
  71. static int TermRows,TermCols;
  72. static Rect CmndRect;
  73.  
  74. static ControlHandle CmndScroll;
  75. static short RasMolResFile;
  76.  
  77. static int DialogFormat;
  78. static char Filename[256];
  79. static Point MousePrev;
  80. static int PointX,PointY;
  81. static int InitX,InitY;
  82. static int HeldButton;
  83.  
  84.  
  85. #ifdef __CONDITIONALMACROS__
  86. #define ArrowCursor   SetCursor(&qd.arrow)
  87. #else
  88. #define ArrowCursor   SetCursor(&arrow)
  89. #endif
  90.  
  91.  
  92. /* Forwardly Compatable Definitions */
  93. #ifndef gestaltNativeCPUtype
  94. #define gestaltNativeCPUtype 'cput'
  95. #define gestaltCPU68000    0x000
  96. #define gestaltCPU68010    0x001
  97. #define gestaltCPU68020    0x002
  98. #define gestaltCPU68030    0x003
  99. #define gestaltCPU68040    0x004
  100. #define gestaltCPU601      0x101
  101. #define gestaltCPU603      0x103
  102. #define gestaltCPU604      0x104
  103. #endif
  104.  
  105. #ifndef __CONDITIONALMACROS__
  106. /* Undocumented System Functions */
  107. pascal OSErr SetDialogDefaultItem( DialogPtr theDialog,
  108.         short newItem ) = {0x303C,0x0304,0xAA68};
  109. #endif
  110.  
  111.  
  112. #ifdef __CONDITIONALMACROS__
  113. /* Global RoutineDescriptors */
  114. AEEventHandlerUPP HandleAEIgnorePtr;
  115. AEEventHandlerUPP HandleAEOpenDocPtr;
  116. AEEventHandlerUPP HandleAEQuitAppPtr;
  117. ControlActionUPP CanvScrollProcPtr;
  118. ControlActionUPP CmndScrollProcPtr;
  119. DlgHookYDUPP OpenDlgHookPtr;
  120. DlgHookYDUPP SaveDlgHookPtr;
  121. #endif
  122.  
  123.  
  124. /* Function Prototypes */
  125. static void PaintScreen();
  126.  
  127.  
  128. void RasMolExit()
  129. {
  130.     /* Restore System Event Mask */
  131.     SetEventMask( everyEvent & ~keyUp );
  132.     
  133.     /* Free System Memory Resources */
  134.     if( FBuffer ) _ffree( FBuffer );
  135.     if( DBuffer ) _ffree( DBuffer );
  136.     if( DrawDots ) DeleteSurface();
  137.     PurgeDatabase();
  138.     CloseDisplay();
  139.     ExitToShell();
  140. }
  141.  
  142.  
  143. void RasMolFatalExit( msg )
  144.     char *msg;
  145. {
  146.     register char *ptr;
  147.     register int len;
  148.     
  149.     Str255 buffer;
  150.     DialogPtr dlg;
  151.     Handle hand;
  152.     short item;
  153.     Rect rect;
  154.     
  155.     dlg = GetNewDialog(171,(Ptr)0,(WindowPtr)-1);
  156.     SetDialogDefaultItem(dlg,1);
  157.     
  158.     /* Error Message Text! */
  159.     ptr = (char*)&buffer[1];
  160.     while( *msg ) 
  161.         *ptr++ = *msg++;
  162.     
  163.     len = ptr - (char*)&buffer[1];
  164.     buffer[0] = (unsigned char)len;
  165.     GetDItem(dlg,4,&item,&hand,&rect);
  166.     SetIText(hand,buffer);
  167.     ShowWindow(dlg);
  168.  
  169.     do {
  170. #ifdef __CONDITIONALMACROS__
  171.         ModalDialog((ModalFilterUPP)0,&item);
  172. #else
  173.         ModalDialog((ProcPtr)0,&item);
  174. #endif
  175.     } while( item != 1 );
  176.     DisposDialog(dlg);
  177.  
  178.     /* Restore System Event Mask */
  179.     SetEventMask( everyEvent & ~keyUp );
  180.     
  181.     /* Free System Memory Resources */
  182.     if( FBuffer ) _ffree( FBuffer );
  183.     if( DBuffer ) _ffree( DBuffer );
  184.     if( DrawDots ) DeleteSurface();
  185.     PurgeDatabase();
  186.     CloseDisplay();
  187.     ExitToShell();
  188. }
  189.  
  190.  
  191. /* Externally Visible Functions! */
  192. static void CopyResource( type, file, id )
  193.     ResType type;  short file;  short id;
  194. {
  195.     register Handle hand;
  196.     Str255 name;
  197.  
  198.     UseResFile(RasMolResFile);
  199.     hand = GetResource(type,id);
  200.     if( hand )
  201.     {   GetResInfo(hand,&id,&type,name);
  202.         DetachResource(hand);
  203.  
  204.         UseResFile(file);
  205.         AddResource(hand,type,kCustomIconResource,name);
  206.         if( !ResError() ) WriteResource(hand);
  207.         ReleaseResource(hand);
  208.         UseResFile(RasMolResFile);
  209.     }
  210. }
  211.  
  212. void SetFileInfo( ptr, appl, type, icon )
  213.     char *ptr;  OSType appl, type;  short icon;
  214. {
  215.     register char *dst;
  216.     register short file;
  217.     register int len;
  218.     
  219.     Str255 buffer;
  220.     FSSpec fss;
  221.     FInfo info;
  222.     
  223.     /* Create Pascal Filename */
  224.     dst = (char*)&buffer[1];
  225.     while( *ptr ) *dst++ = *ptr++;
  226.     len = dst - (char*)&buffer[1];
  227.     buffer[0] = (unsigned char)len;
  228.     
  229.     FSMakeFSSpec(0,0,buffer,&fss);
  230.     
  231.     if( icon )
  232.     {   FSpCreateResFile(&fss,appl,type,
  233.                          smSystemScript);
  234.         file = FSpOpenResFile(&fss,fsRdWrPerm);
  235.         CopyResource('icl4',file,icon);
  236.         CopyResource('icl8',file,icon);
  237.         CopyResource('ICN#',file,icon);
  238.         CopyResource('ics#',file,icon);
  239.         CopyResource('ics4',file,icon);
  240.         CopyResource('ics8',file,icon);
  241.         CloseResFile(file);
  242.     }
  243.     
  244.     if( !FSpGetFInfo(&fss,&info) )
  245.     {   info.fdType = type;
  246.         info.fdCreator = appl;
  247.         if( icon )
  248.             info.fdFlags |= kHasCustomIcon;
  249.         FSpSetFInfo(&fss,&info);
  250.     }
  251.     FlushVol(NULL,fss.vRefNum);
  252. }
  253.  
  254.  
  255. static void SetTermScroll( pos )
  256.     int pos;
  257. {
  258.     GrafPtr savePort;
  259.     
  260.     GetPort(&savePort);
  261.     SetPort(CmndWin);
  262.     SetCtlValue(CmndScroll,pos);
  263.     ScrlStart = ScrlMax - pos;
  264.     InvalRect(&CmndWin->portRect);
  265.     SetPort(savePort);
  266. }
  267.  
  268.  
  269. #define ClipCaret  (CaretX<CmndWin->portRect.right-15)
  270.  
  271. static long LastCaretTime;
  272. static int CaretX,CaretY;
  273. static int CaretFlag;
  274.  
  275.  
  276. static void ShowCaret()
  277. {
  278.     GrafPtr savePort;
  279.     
  280.     if( !CaretFlag && ClipCaret )
  281.     {   GetPort(&savePort);
  282.         SetPort(CmndWin);
  283.         PenMode(patCopy);
  284.         MoveTo(CaretX,CaretY);
  285.         Line(0,CharSkip);
  286.         SetPort(savePort);
  287.     }
  288.     LastCaretTime = TickCount();
  289.     CaretFlag = True;
  290. }
  291.  
  292. static void HideCaret()
  293. {
  294.     GrafPtr savePort;
  295.     
  296.     if( CaretFlag && ClipCaret )
  297.     {   GetPort(&savePort);
  298.         SetPort(CmndWin);
  299.         PenMode(patBic);
  300.         MoveTo(CaretX,CaretY);
  301.         Line(0,CharSkip);
  302.         SetPort(savePort);
  303.     }
  304.     CaretFlag = False;
  305. }
  306.  
  307. static void SetCaretPos( x, y )
  308.     int x, y;
  309. {
  310.     if( CaretFlag )
  311.     {   HideCaret();
  312.         CaretX = x;
  313.         CaretY = y;
  314.         ShowCaret();
  315.     } else
  316.     {   CaretX = x;
  317.         CaretY = y;
  318.     }
  319. }
  320.  
  321. static void HandleCaret()
  322. {
  323.     register long ticks;
  324.     
  325.     ticks = TickCount();
  326.     if(  ticks > LastCaretTime + GetCaretTime() )
  327.     {   if( CaretFlag )
  328.        {   LastCaretTime = ticks;
  329.            HideCaret();
  330.        } else ShowCaret();
  331.     }
  332. }
  333.  
  334.  
  335. void WriteChar( ch )
  336.     int ch;
  337. {
  338.     register int i;
  339.     
  340.     GrafPtr savePort;
  341.     
  342.     /* Scroll to bottom! */
  343.     if( ScrlStart )
  344.         SetTermScroll( ScrlMax );
  345.  
  346.     switch( ch )
  347.     {   case(0x07):  SysBeep(15);
  348.                      break;
  349.                      
  350.         case(0x08):  if( TermXPos>0 )
  351.                      {   TermXPos--;
  352.                          if( TermCursor )
  353.                              SetCaretPos(TermXPos*CharWide,
  354.                                          TermYPos*CharSkip);
  355.                      }
  356.                      break;
  357.                      
  358.         case(0x0D):  if( TermXPos )
  359.                      {   if( TermCursor )
  360.                              SetCaretPos(0,TermYPos*CharSkip);
  361.                          TermXPos = 0;
  362.                      }
  363.                      break;
  364.                      
  365.         case(0x0A):  if( TermYPos==TermRows-1 )
  366.                      {   CmndStart++;
  367.                          if( CmndStart == CmndRows )
  368.                              CmndStart = 0;
  369.                              
  370.                          i = TermYPos + CmndStart;
  371.                          if( i >= CmndRows ) i -= CmndRows;
  372.                          memset(TermScreen+i*CmndCols,' ',CmndCols);
  373.                          
  374.                          GetPort(&savePort);
  375.                          SetPort(CmndWin);
  376.                          /* InvalRect(&CmndWin->portRect); */
  377.                          PaintScreen();
  378.                          SetPort(savePort);
  379.                      } else TermYPos++;
  380.                      TermXPos = 0;
  381.                      
  382.                      if( TermCursor )
  383.                          SetCaretPos(0,TermYPos*CharSkip);
  384.                      break;
  385.                      
  386.         default:     i = TermYPos + CmndStart;
  387.                      if( i >= CmndRows ) i -= CmndRows;
  388.                      TermScreen[i*CmndCols+TermXPos] = ch;
  389.                      if( TermXPos < TermCols )
  390.                      {   GetPort(&savePort);
  391.                          SetPort(CmndWin);
  392.                          MoveTo(TermXPos*CharWide+1,TermYPos*CharSkip+CharHigh);
  393.                          DrawChar(ch);
  394.                          SetPort(savePort);
  395.                      }
  396.                      
  397.                      if( TermXPos==CmndCols-1 )
  398.                      {   if( TermYPos==TermRows-1 )
  399.                          {  CmndStart++;
  400.                             if( CmndStart == CmndRows )
  401.                                 CmndStart = 0;
  402.                              
  403.                             i = TermYPos + CmndStart;
  404.                             if( i >= CmndRows ) i-= CmndRows;
  405.                             memset(TermScreen+i*CmndCols,' ',CmndCols);
  406.                             
  407.                             GetPort(&savePort);
  408.                             SetPort(CmndWin);
  409.                             /* InvalRect(&CmndWin->portRect); */
  410.                             PaintScreen();
  411.                             SetPort(savePort);
  412.                          } else TermYPos++;
  413.                          TermXPos = 0;
  414.                      } else TermXPos++;
  415.                      
  416.                      if( TermCursor )
  417.                          SetCaretPos(TermXPos*CharWide,
  418.                                      TermYPos*CharSkip);
  419.                      break;
  420.     }
  421. }
  422.  
  423.  
  424. void WriteString( ptr )
  425.     char *ptr;
  426. {
  427.     while( *ptr )
  428.         WriteChar( *ptr++ );
  429. }
  430.  
  431.  
  432. static void InitTerminal()
  433. {
  434.     register WindowPeek wpeek;
  435.     register WStateData *wsdp;
  436.     register Region *rgn;
  437.     register int mb,tb;
  438.     register int x, y;
  439.     FontInfo finfo;
  440.     Point pnt;
  441.     Rect rect;
  442.     
  443.     TermCursor = False;
  444.     CaretFlag = False;
  445.     
  446.     /* Default Window Size */
  447.     TermCols = 80;  TermRows = 24;
  448.     ScrlStart = CmndStart = 0;
  449.     TermXPos = TermYPos = 0;
  450.  
  451.     CmndWin = GetNewWindow(151,0,CanvWin);
  452.     SetPort(CmndWin);
  453.     
  454.     /* Font Style */
  455.     TextMode(srcCopy);
  456.     TextFont(monaco);
  457.     TextSize(9);
  458.     TextFace(0);
  459.     
  460.     GetFontInfo(&finfo);
  461.     CharSkip = finfo.ascent + finfo.descent + finfo.leading;
  462.     CharHigh = finfo.ascent;
  463.     CharWide = finfo.widMax;
  464.     
  465.     /* Set Initial Terminal Size */
  466.     x = TermCols*CharWide;
  467.     y = TermRows*CharSkip;
  468.     SizeWindow(CmndWin,x+16,y,TRUE);
  469.     ShowWindow(CmndWin);
  470.  
  471.     /* Create Scroll Bar */
  472.     rect.left = x+1;   rect.right = x+17;
  473.     rect.top = -1;     rect.bottom = y-14;
  474.     CmndScroll = NewControl(CmndWin,&rect,"\p",FALSE,ScrlMax,
  475.                             0,ScrlMax,scrollBarProc,0L);
  476.     
  477.     wpeek = (WindowPeek)CmndWin;
  478.     pnt = topLeft(CmndWin->portRect);
  479.     rgn = *(wpeek->strucRgn);
  480.     LocalToGlobal(&pnt);
  481.  
  482.     /* Title & Menu Bar Heights */
  483.     tb = pnt.v - rgn->rgnBBox.top;
  484.     mb = GetMBarHeight()+tb+4;
  485.  
  486. #ifdef __CONDITIONALMACROS__    
  487.     y = (qd.screenBits.bounds.bottom-(mb+1))/CharSkip;
  488. #else
  489.     y = (screenBits.bounds.bottom-(mb+1))/CharSkip;
  490. #endif
  491.     if( y>CmndRows ) y = CmndRows;
  492.  
  493.     CmndRect.bottom = y*CharSkip+1;
  494.     CmndRect.right = CmndCols*CharWide+17;
  495.     CmndRect.left = CharWide+49;
  496.     CmndRect.top = 62;   
  497.  
  498.     /* Set Zoom-In Size */
  499.     wsdp = (WStateData*) *(wpeek->dataHandle);
  500.     wsdp->stdState.bottom = CmndRect.bottom+mb;
  501.     wsdp->stdState.right = CmndRect.right+4;
  502.     wsdp->stdState.left = 4;
  503.     wsdp->stdState.top = mb;
  504.     
  505.     memset(TermScreen,' ',CmndSize);
  506. }
  507.  
  508.  
  509. static void DrawCmndGrowIcon()
  510. {
  511.     register RgnHandle saveRgn;
  512.     GrafPtr savePort;
  513.     Rect rect;
  514.     
  515.     GetPort(&savePort);
  516.     SetPort(CmndWin);
  517.     saveRgn = NewRgn();
  518.     GetClip(saveRgn);
  519.     
  520.     rect = CmndWin->portRect;
  521.     rect.left = rect.right-15;
  522.     ClipRect(&rect);
  523.     DrawGrowIcon(CmndWin);
  524.     
  525.     SetClip(saveRgn);
  526.     DisposeRgn(saveRgn);
  527.     SetPort(savePort);
  528. }
  529.  
  530.  
  531. static void PaintScreen()
  532. {
  533.     register char *ptr;
  534.     register WindowPtr win;
  535.     register int SRow,ERow;
  536.     register int SCol,ECol;
  537.     register int row,len;
  538.     register int x,y;
  539.     Rect rect;
  540.     
  541.     /* Toolbox Components */
  542.     DrawControls(CmndWin);
  543.     DrawCmndGrowIcon();
  544.     
  545.     /* Determine Invalid Rect? */
  546.     SRow = 0;   ERow = TermRows-1;
  547.     SCol = 0;   ECol = TermCols-1;
  548.     
  549.     len = ECol-SCol+1;
  550.     x = SCol*CharWide + 1;
  551.     y = SRow*CharSkip + CharHigh;
  552.     
  553.     SRow += CmndStart - ScrlStart;
  554.     if( SRow >= CmndRows )
  555.     {   SRow -= CmndRows;
  556.     } else if( SRow < 0 )
  557.         SRow += CmndRows;
  558.         
  559.     ERow += CmndStart - ScrlStart;
  560.     if( ERow >= CmndRows )
  561.     {   ERow -= CmndRows;
  562.     } else if( ERow < 0 )
  563.         ERow += CmndRows;
  564.         
  565.     
  566.     row = SRow;
  567.     ptr = TermScreen + SRow*CmndCols + SCol;
  568.     while( True )
  569.     {   MoveTo(x,y);
  570.         DrawText(ptr,0,len);
  571.         if( row != ERow )
  572.         {   ptr += CmndCols;
  573.             row++;
  574.             if( row == CmndRows )
  575.             {   ptr = TermScreen + SCol;
  576.                 row = 0;
  577.             }
  578.         } else break;
  579.         y += CharSkip;
  580.     }
  581.     
  582.     /* Erase Screen Edges! */
  583.     rect = CmndWin->portRect;
  584.     rect.right -= 15;
  585.     
  586.     x = TermCols*CharWide+1;
  587.     y = TermRows*CharSkip;
  588.     if( x<rect.right )
  589.     {   rect.left = x;
  590.         EraseRect(&rect);
  591.     }
  592.     
  593.     if( y<rect.bottom )
  594.     {   rect.left = 0;
  595.         rect.top = y;
  596.         EraseRect(&rect);
  597.     }
  598.     
  599.     win = FrontWindow();
  600.     if( (win==CanvWin) || (win==CmndWin) )
  601.     {   row = TermYPos + ScrlStart;
  602.         if( row < TermRows )
  603.         {   SetCaretPos(TermXPos*CharWide,row*CharSkip);
  604.             TermCursor = True;
  605.             ShowCaret();
  606.         } else 
  607.         {   TermCursor = False;
  608.             HideCaret();
  609.         }
  610.     } else
  611.     {   TermCursor = False;
  612.         HideCaret();
  613.     }
  614.     
  615.     /* Validate CmndWin */
  616.     ValidRect(&CmndWin->portRect);
  617. }
  618.  
  619.  
  620. void AdviseUpdate( item )
  621.     int item;
  622. {
  623.     if( item == AdvName )
  624.         EnableMenus( !DisableMenu );
  625. }
  626.  
  627.  
  628. void RefreshScreen()
  629. {
  630.     ReDrawFlag &= ~(RFTransZ|RFPoint);
  631.     
  632.     if( ReDrawFlag )
  633.     {   if( ReDrawFlag & RFReSize )
  634.             ReSizeScreen();
  635.             
  636.         if( ReDrawFlag & RFColour )
  637.         {   ClearImage();
  638.             DefineColourMap();
  639.         }
  640.         
  641.         if( Database )
  642.         {   BeginWait();
  643.             if( ReDrawFlag & RFApply )
  644.                 ApplyTransform();
  645.             DrawFrame();
  646.  
  647.             TransferImage();
  648.             EndWait();
  649.         } else
  650.         {   ClearBuffers();
  651.             ClearImage();
  652.         }
  653.         ReDrawFlag = 0;
  654.     }
  655. }
  656.  
  657.  
  658. static void ConvertFilename( fss )
  659.     FSSpec *fss;
  660. {
  661.     register char *src;
  662.     register char *dst;
  663.     register int i;
  664.     char buffer[256];
  665.     
  666.     Str255 dirname;
  667.     DirInfo dinfo;
  668.     
  669.     src = buffer;
  670.     dinfo.ioDrParID = fss->parID;
  671.     dinfo.ioNamePtr = dirname;
  672.     do {
  673.         dinfo.ioVRefNum = fss->vRefNum;
  674.         dinfo.ioFDirIndex = -1;
  675.         dinfo.ioDrDirID = dinfo.ioDrParID;
  676.         PBGetCatInfo((CInfoPBPtr)&dinfo,0);
  677.         
  678.         *src++ = ':';
  679.         for( i=dirname[0]; i; i-- )
  680.             *src++ = dirname[i];
  681.     } while( dinfo.ioDrDirID != 2 );
  682.     
  683.     /* Reverse the file path! */
  684.     dst = Filename;
  685.     while( src != buffer )
  686.         *dst++ = *(--src);
  687.     for( i=1; i<=fss->name[0]; i++ )
  688.         *dst++ = fss->name[i];
  689.     *dst = '\0';
  690. }
  691.  
  692.  
  693. static void HandleAboutDialog()
  694. {
  695.     register char *fpu;
  696.     register char *src;
  697.     register char *dst;
  698.     register int len;
  699.     
  700.     Str255 temp;
  701.     Str255 buffer;
  702.     DialogPtr dlg;
  703.     Handle hand;
  704.     long reply;
  705.     short item;
  706.     Rect rect;
  707.     
  708.     dlg = GetNewDialog(170,(Ptr)0,(WindowPtr)-1);
  709.     SetDialogDefaultItem(dlg,1);
  710.     
  711.     /* System Information! */
  712.     dst = (char*)&buffer[1];
  713.     Gestalt(gestaltPhysicalRAMSize,&reply);
  714.     reply = (long)reply>>10;
  715.    
  716.     if( reply >= (long)1024 )
  717.     {   len = sprintf(dst,"%ldMb ",reply>>10);
  718.     } else len = sprintf(dst,"%ldKb ",reply);
  719.     dst += len;
  720.     
  721.     Gestalt(gestaltMachineType,&reply);
  722.     GetIndString(temp,kMachineNameStrID,(short)reply);
  723.     for( len=1; len<=temp[0]; len++ ) 
  724.         *dst++ = temp[len];        
  725.     
  726.     if( Gestalt(gestaltAUXVersion,&reply) )
  727.     {   for( src=" (System "; *src; src++ )
  728.             *dst++ = *src;
  729.             
  730.         Gestalt(gestaltSystemVersion,&reply);
  731.         *dst++ = (char)((reply>>8)&0x0f) + '0';  *dst++ = '.';
  732.         *dst++ = (char)((reply>>4)&0x0f) + '0';  *dst++ = '.';
  733.         *dst++ = (char)(reply&0x0f) + '0';       *dst++ = ')';
  734.     } else /* A/UX */
  735.         for( src=" (A/UX)"; *src; src++ )
  736.             *dst++ = *src;
  737.             
  738.     len = dst - (char*)&buffer[1];
  739.     buffer[0] = (unsigned char)len;
  740.     GetDItem(dlg,6,&item,&hand,&rect);
  741.     SetIText(hand,buffer);
  742.     
  743.     /* Machine Information! */
  744.     dst = (char*)&buffer[1];
  745.     if( Gestalt(gestaltNativeCPUtype,&reply) )
  746.     {   /* NativeCPUtype not available! */
  747.         Gestalt(gestaltProcessorType,&reply);
  748.         switch( reply )
  749.         {   case(gestalt68000):  src = "MC68000"; break;
  750.             case(gestalt68010):  src = "MC68010"; break;
  751.             case(gestalt68020):  src = "MC68020"; break;
  752.             case(gestalt68030):  src = "MC68030"; break;
  753.             case(gestalt68040):  src = "MC68040"; break;
  754.             default:   src = "Unknown processor";
  755.         }
  756.     } else switch( reply )
  757.         {   case(gestaltCPU68000):  src = "MC68000"; break;
  758.             case(gestaltCPU68010):  src = "MC68010"; break;
  759.             case(gestaltCPU68020):  src = "MC68020"; break;
  760.             case(gestaltCPU68030):  src = "MC68030"; break;
  761.             case(gestaltCPU68040):  src = "MC68040"; break;
  762.             case(gestaltCPU601):    src = "PPC601";  break;
  763.             case(gestaltCPU603):    src = "PPC603";  break;
  764.             case(gestaltCPU604):    src = "PPC604";  break;
  765.             default:   src = "Unknown processor";
  766.         }
  767.  
  768.     if( *src != 'P' )
  769.     {   Gestalt(gestaltFPUType,&reply);
  770.         switch( reply )
  771.         {   default:               fpu=" unknown";  break;
  772.             case(gestalt68881):    fpu=" 68881";    break;
  773.             case(gestalt68882):    fpu=" 68882";    break;
  774.             case(gestalt68040FPU): fpu=" internal"; break;
  775.             case(gestaltNoFPU):    
  776.                         fpu="out";
  777.                         if( !strcmp(src,"MC68040") )
  778.                             src = "MC68LC040";       
  779.                         break;
  780.         }
  781.     } else fpu = " internal";
  782.     
  783.     while( *src ) *dst++ = *src++;
  784.     for( src=" with"; *src; src++ )
  785.         *dst++ = *src;
  786.     while( *fpu ) *dst++ = *fpu++;
  787.     for( src=" maths coprocessor"; *src; src++ )
  788.         *dst++ = *src;
  789.         
  790.     len = dst - (char*)&buffer[1];
  791.     buffer[0] = (unsigned char)len;
  792.     GetDItem(dlg,7,&item,&hand,&rect);
  793.     SetIText(hand,buffer);
  794.  
  795.     /* Display Dialog Box! */    
  796.     ShowWindow(dlg);
  797.     do {
  798. #ifdef __CONDITIONALMACROS__
  799.         ModalDialog((ModalFilterUPP)0,&item);
  800. #else
  801.         ModalDialog((ProcPtr)0,&item);
  802. #endif
  803.     } while( item != 1 );
  804.     DisposDialog(dlg);
  805. }
  806.  
  807.  
  808. static void PasteCommandText()
  809. {
  810.     register Handle hand;
  811.     register long i,len;
  812.     register char *ptr;
  813.     register char ch;
  814.     long offset;
  815.     
  816.     hand = NewHandle(0);
  817.     len = GetScrap(hand,'TEXT',&offset);
  818.     if( len > 0 )
  819.     {   HLock(hand);
  820.         ptr = (char*)*hand;
  821.         for( i=0; i<len; i++ )
  822.         {   ch = *ptr++;
  823.             if( ch >= ' ' )
  824.             {   ProcessCharacter(ch);
  825.             } else if( (ch==0x0d) || (ch==0x0a) )
  826.             {   ProcessCharacter(ch);
  827.                 if( !ExecuteCommand() )
  828.                 {   ResetCommandLine(0);
  829.                 } else RasMolExit();
  830.             } else if( ch>=' ' )
  831.                 ProcessCharacter(ch);
  832.         }
  833.         HUnlock(hand);
  834.     }
  835. }
  836.  
  837.  
  838. pascal short OpenDlgHook( item, dialog, data )
  839.     short item;  DialogPtr dialog;  void *data;
  840. {
  841.     Handle hand;
  842.     short type;
  843.     Rect rect;
  844.     
  845.     if( item == sfHookFirstCall )
  846.     {   GetDItem(dialog,10,&type,&hand,&rect);
  847.         SetCtlValue((ControlHandle)hand,DialogFormat);
  848.         item = sfHookNullEvent;
  849.     } else if( item == 10 )
  850.     {   GetDItem(dialog,10,&type,&hand,&rect);
  851.         DialogFormat = GetCtlValue((ControlHandle)hand);
  852.         item = sfHookNullEvent;
  853.     }
  854.     return( item );
  855. }
  856.  
  857. pascal short SaveDlgHook( item, dialog, data )
  858.     short item;  DialogPtr dialog;  void *data;
  859. {
  860.     Handle hand;
  861.     short type;
  862.     Rect rect;
  863.     
  864.     if( item == sfHookFirstCall )
  865.     {   GetDItem(dialog,12,&type,&hand,&rect);
  866.         SetCtlValue((ControlHandle)hand,DialogFormat);
  867.         item = sfHookNullEvent;
  868.     } else if( item == 12 )
  869.     {   GetDItem(dialog,12,&type,&hand,&rect);
  870.         DialogFormat = GetCtlValue((ControlHandle)hand);
  871.         item = sfHookNullEvent;
  872.     }
  873.     return( item );
  874. }
  875.  
  876.  
  877. static void HandleFileOpen()
  878. {
  879.     register int format;
  880.     StandardFileReply reply;
  881.     SFTypeList types;
  882.     Point pnt;
  883.     
  884.  
  885.     /* File Types */
  886.     types[0]='TEXT';
  887.     types[1]='RSML';
  888.     types[2]='mMOL';
  889.  
  890.     DialogFormat = 1;
  891.     pnt.v = pnt.h = -1;
  892.     CustomGetFile( NULL, 3, types, &reply, 172, pnt,
  893. #ifdef __CONDITIONALMACROS__
  894.                    OpenDlgHookPtr,
  895. #else
  896.                    (DlgHookYDProcPtr)OpenDlgHook,
  897. #endif 
  898.                    NULL, 0, NULL, NULL );
  899.     
  900.     if( reply.sfGood )
  901.     {   ConvertFilename( &reply.sfFile );
  902.         switch( DialogFormat )
  903.         {   case(1):  format = FormatPDB;      break;
  904.             case(2):  format = FormatAlchemy;  break;
  905.             case(3):  format = FormatMol2;     break;
  906.             case(4):  format = FormatMDL;      break;
  907.             case(5):  format = FormatXYZ;      break;
  908.             case(6):  format = FormatCharmm;   break;
  909.         }
  910.         
  911.         FetchFile(format,True,Filename);
  912.         if( Database )
  913.         {   ReDrawFlag |= RFRefresh | RFColour;
  914.             if( InfoBondCount < 1 )
  915.             {   EnableBackBone(False,80);
  916.             } else EnableWireFrame(True,0);
  917.             CPKColourAttrib();
  918.         }
  919.     }
  920. }
  921.  
  922. static void HandleFileSave()
  923. {
  924.     StandardFileReply reply;
  925.     Point pnt;
  926.     
  927.     DialogFormat = 1;
  928.     pnt.v = pnt.h = -1;
  929.     CustomPutFile("\pSave Coordinate File:","\p",&reply,173,pnt,
  930. #ifdef __CONDITIONALMACROS__
  931.                    SaveDlgHookPtr,
  932. #else
  933.                    (DlgHookYDProcPtr)SaveDlgHook, 
  934. #endif
  935.                    NULL, 0, NULL, NULL );
  936.     
  937.     if( reply.sfGood )
  938.     {   ConvertFilename( &reply.sfFile );
  939.         if( DialogFormat==1 )
  940.         {   SavePDBMolecule(Filename);
  941.         } else /* DialogFormat==2 */
  942.             SaveAlchemyMolecule(Filename);
  943.     }
  944. }
  945.  
  946. static void HandleExportMenu( item )
  947.     int item;
  948. {
  949.     StandardFileReply reply;
  950.     register unsigned char *ptr;
  951.     register int resid;
  952.     Point pnt;
  953.     
  954.     switch( item )
  955.     {   case(1):  resid=0;   ptr="\pSave GIF Image:";          break;
  956.         case(2):  resid=174; ptr="\pSave PostScript File:";    break;
  957.         case(3):  resid=175; ptr="\pSave Portable PixMap:";    break;
  958.         case(4):  resid=176; ptr="\pSave SUN Rasterfile:";     break;
  959.         case(5):  resid=0;   ptr="\pSave Microsoft BMP File:"; break;
  960.         case(6):  resid=0;   ptr="\pSave PICT Image:";         break;
  961.         default:  return;
  962.     }
  963.     
  964.     if( resid )
  965.     {   DialogFormat = 1;
  966.         pnt.v = pnt.h = -1;
  967.         CustomPutFile( ptr, "\p", &reply, resid, pnt,
  968. #ifdef __CONDITIONALMACROS__
  969.                        SaveDlgHookPtr,
  970. #else
  971.                       (DlgHookYDProcPtr)SaveDlgHook,
  972. #endif 
  973.                       NULL, 0, NULL, NULL );
  974.     } else StandardPutFile( ptr, "\p", &reply );
  975.     if( !reply.sfGood ) return;
  976.     
  977.     ConvertFilename( &reply.sfFile );
  978.     switch( item )
  979.     {   case(1):  WriteGIFFile(Filename);  break;
  980.         case(2):  if( DialogFormat == 1 )
  981.                   {   WriteEPSFFile(Filename,True,True);
  982.                   } else if( DialogFormat == 2 )
  983.                   {   WriteEPSFFile(Filename,False,True); 
  984.                   } else /* DialogFormat == 3 */
  985.                       WriteVectPSFile(Filename);
  986.                   break;
  987.                   
  988.         case(3):  WritePPMFile(Filename,(DialogFormat==1));  break;
  989.         case(4):  WriteRastFile(Filename,(DialogFormat==1)); break;
  990.         case(5):  WriteBMPFile(Filename);  break;
  991.         case(6):  WritePICTFile(Filename); break;
  992.     }
  993. }
  994.  
  995.  
  996. static void HandleAppleMenu( item )
  997.     int item;
  998. {
  999.     GrafPtr port;
  1000.     Str255 name;
  1001.     
  1002.     GetPort(&port);
  1003.     GetItem( GetMHandle(140), item, name );
  1004.     OpenDeskAcc(name);
  1005.     SetPort(port);
  1006. }
  1007.  
  1008.  
  1009. static void HandleMenu( hand )
  1010.     long hand;
  1011. {
  1012.     register int i,mask;
  1013.     register int menu;
  1014.     register int item;
  1015.     
  1016.     if( (menu = HiWord(hand)) )
  1017.     {   item = LoWord(hand);
  1018.         switch( menu )
  1019.         {   case(140):  /* Apple Menu */
  1020.                         if( item == 1 )
  1021.                         {   HandleAboutDialog();
  1022.                         } else if( item>2 )
  1023.                             HandleAppleMenu(item);
  1024.                         break;
  1025.                       
  1026.             case(141):  /* File Menu */
  1027.                         switch( item )
  1028.                         {   case(1):  /* Open */
  1029.                                       if( !Database )
  1030.                                           HandleFileOpen();
  1031.                                       break;
  1032.                             case(2):  /* Save As */
  1033.                                       if( Database )
  1034.                                           HandleFileSave();
  1035.                                       break;
  1036.                             case(3):  /* Close */
  1037.                                       ZapDatabase();
  1038.                                       break;
  1039.                                       
  1040.                             case(5):  /* Page Setup */
  1041.                                       PrOpen();
  1042.                                       if( !PrintHand )
  1043.                                       {   PrintHand = (THPrint)
  1044.                                               NewHandle(sizeof(TPrint));
  1045.                                           PrintDefault(PrintHand);
  1046.                                       }
  1047.                                       PrStlDialog(PrintHand);
  1048.                                       PrClose();
  1049.                                       break;
  1050.                                       
  1051.                             case(6):  /* Print */
  1052.                                       PrintImage();
  1053.                                       break;
  1054.                                       
  1055.                             case(8):  /* Quit */
  1056.                                       RasMolExit();
  1057.                         }
  1058.                         break;
  1059.                       
  1060.             case(142):  /* Edit Menu */
  1061.                         switch( item )
  1062.                         {   case(1):  /* Undo */
  1063.                                       for( i=0; i<8; i++ )
  1064.                                           DialValue[i] = 0.0;
  1065.                                       ReDrawFlag |= RFDials;
  1066.                                       ResetTransform();
  1067.                                       UpdateScrollBars();
  1068.                                       break;
  1069.                                       
  1070.                             case(3):  /* Copy */
  1071.                                       ClipboardImage();
  1072.                                       break;
  1073.                             
  1074.                             case(4):  /* Paste */
  1075.                                       PasteCommandText();
  1076.                                       break;
  1077.                                       
  1078.                             case(7):  /* Select All */
  1079.                                       SelectZone(AllAtomFlag);
  1080.                                       break;
  1081.                         }
  1082.                         break;
  1083.                         
  1084.             case(143):  /* Display Menu */
  1085.                         switch( item )
  1086.                         {   case(1):  /* Wireframe */
  1087.                                       DisableSpacefill();
  1088.                                       EnableWireFrame(True,0);
  1089.                                       SetRibbonStatus(False,0,0);
  1090.                                       DisableBackBone();
  1091.                                       ReDrawFlag |= RFRefresh;
  1092.                                       break;
  1093.                                       
  1094.                             case(2):  /* Backbone */
  1095.                                       DisableSpacefill();
  1096.                                       DisableWireFrame();
  1097.                                       SetRibbonStatus(False,0,0);
  1098.                                       EnableBackBone(False,80);
  1099.                                       ReDrawFlag |= RFRefresh;
  1100.                                       break;
  1101.                                       
  1102.                             case(3):  /* Sticks */
  1103.                                       DisableSpacefill();
  1104.                                       if( MainAtomCount<256 )
  1105.                                       {   EnableWireFrame(False,40);
  1106.                                       } else EnableWireFrame(False,80);
  1107.                                       SetRibbonStatus(False,0,0);
  1108.                                       DisableBackBone();
  1109.                                       ReDrawFlag |= RFRefresh;
  1110.                                       break;
  1111.                                       
  1112.                             case(4):  /* Spheres */
  1113.                                       SetVanWaalRadius();
  1114.                                       DisableWireFrame();
  1115.                                       SetRibbonStatus(False,0,0);
  1116.                                       DisableBackBone();
  1117.                                       ReDrawFlag |= RFRefresh;
  1118.                                       break;
  1119.                                       
  1120.                             case(5):  /* Ball & Stick */
  1121.                                       SetRadiusValue(120);
  1122.                                       EnableWireFrame(False,40);
  1123.                                       SetRibbonStatus(False,0,0);
  1124.                                       DisableBackBone();
  1125.                                       ReDrawFlag |= RFRefresh;
  1126.                                       break;
  1127.                                       
  1128.                             case(6):  /* Ribbons */
  1129.                                       DisableSpacefill();
  1130.                                       DisableWireFrame();
  1131.                                       SetRibbonStatus(True,RibbonFlag,0);
  1132.                                       DisableBackBone();
  1133.                                       ReDrawFlag |= RFRefresh;
  1134.                                       break;
  1135.                                       
  1136.                             case(7):  /* Strands */
  1137.                                       DisableSpacefill();
  1138.                                       DisableWireFrame();
  1139.                                       SetRibbonStatus(True,StrandFlag,0);
  1140.                                       DisableBackBone();
  1141.                                       ReDrawFlag |= RFRefresh;
  1142.                                       break;
  1143.                         }
  1144.                         break;              
  1145.                             
  1146.             case(144):  /* Colours Menu */
  1147.                         switch( item )
  1148.                         {   case(1):  /* Monochrome */
  1149.                                       MonoColourAttrib(255,255,255);
  1150.                                       ReDrawFlag |= RFColour;  break;
  1151.                             case(2):  /* CPK */
  1152.                                       CPKColourAttrib();
  1153.                                       ReDrawFlag |= RFColour;  break;
  1154.                             case(3):  /* Shapely */
  1155.                                       ShapelyColourAttrib();
  1156.                                       ReDrawFlag |= RFColour;  break;
  1157.                             case(4):  /* Group */
  1158.                                       ScaleColourAttrib( GroupAttr );
  1159.                                       ReDrawFlag |= RFColour;  break;
  1160.                             case(5):  /* Chain */
  1161.                                       ScaleColourAttrib( ChainAttr );
  1162.                                       ReDrawFlag |= RFColour;  break;
  1163.                             case(6):  /* Temperature */
  1164.                                       ScaleColourAttrib( TempAttr );
  1165.                                       ReDrawFlag |= RFColour;  break;
  1166.                             case(7):  /* Structure */
  1167.                                       StructColourAttrib();
  1168.                                       ReDrawFlag |= RFColour;  break;
  1169.                             case(8):  /* User */
  1170.                                       UserMaskAttrib(MaskColourFlag);
  1171.                                       ReDrawFlag |= RFColour;  break;
  1172.                         }
  1173.                         break;
  1174.                                                     
  1175.             case(145):  /* Option Menu */
  1176.                         switch( item )
  1177.                         {   case(1):  /* Slabbing */
  1178.                                       ReDrawFlag |= RFRefresh;
  1179.                                       UseSlabPlane = !UseSlabPlane;
  1180.                                       if( UseSlabPlane )
  1181.                                           UseShadow = False;
  1182.                                       break;
  1183.                                       
  1184.                             case(2):  /* Hydrogens */
  1185.                                       mask = NormAtomFlag;
  1186.                                       if( HetaGroups )
  1187.                                           mask |= HeteroFlag;
  1188.                                       Hydrogens = !Hydrogens;
  1189.                                       ReDrawFlag |= RFRefresh;
  1190.                                       
  1191.                                       if( Hydrogens )
  1192.                                       {   SelectZone(mask|HydrogenFlag);
  1193.                                       } else RestrictZone(mask);
  1194.                                       break;
  1195.                                       
  1196.                             case(3):  /* Hetero Atoms */
  1197.                                       mask = NormAtomFlag;
  1198.                                       if( Hydrogens )
  1199.                                           mask |= HydrogenFlag;
  1200.                                       HetaGroups = !HetaGroups;
  1201.                                       ReDrawFlag |= RFRefresh;
  1202.                                       
  1203.                                       if( HetaGroups )
  1204.                                       {   SelectZone(mask|HeteroFlag);
  1205.                                       } else RestrictZone(mask);
  1206.                                       break;
  1207.                                       
  1208.                             case(4):  /* Specular */
  1209.                                       FakeSpecular = !FakeSpecular;
  1210.                                       ReDrawFlag |= RFColour;
  1211.                                       break;
  1212.                                       
  1213.                             case(5):  /* Shadows */
  1214.                                       ReDrawFlag |= RFRefresh;
  1215.                                       UseShadow = !UseShadow;
  1216.                                       if( UseShadow )
  1217.                                       {   ReviseInvMatrix();
  1218.                                           VoxelsClean = False;
  1219.                                           UseSlabPlane = False;
  1220.                                           ReAllocBuffers();
  1221.                                       }
  1222.                                       break;
  1223.                         }
  1224.                         break;
  1225.                         
  1226.             case(146):  /* Export Menu */
  1227.                         if( Database )
  1228.                             HandleExportMenu( item );
  1229.                         break;
  1230.                         
  1231.             case(147):  /* Windows Menu */
  1232.                         if( item==1 )
  1233.                         {   SelectWindow(CanvWin);
  1234.                             ShowWindow(CanvWin);
  1235.                         } else /* item==2 */
  1236.                         {   SelectWindow(CmndWin);
  1237.                             ShowWindow(CmndWin);
  1238.                         }
  1239.                         break;
  1240.         }
  1241.         HiliteMenu(0);
  1242.     }
  1243. }
  1244.  
  1245.  
  1246. static void AdjustMenus()
  1247. {
  1248.     register MenuHandle menu;
  1249.     register WindowPtr win;
  1250.     
  1251.     /* Refresh Menus */
  1252.     EnableMenus(!DisableMenu);
  1253.     
  1254.     /* Options Menu */
  1255.     menu = GetMHandle(145);
  1256.     CheckItem(menu,1,UseSlabPlane);
  1257.     CheckItem(menu,2,Hydrogens);
  1258.     CheckItem(menu,3,HetaGroups);
  1259.     CheckItem(menu,4,FakeSpecular);
  1260.     CheckItem(menu,5,UseShadow);
  1261.  
  1262.     /* Windows Menu */
  1263.     win = FrontWindow();
  1264.     menu = GetMHandle(147);
  1265.     CheckItem(menu,1,(win==CanvWin));
  1266.     CheckItem(menu,2,(win==CmndWin));
  1267. }
  1268.  
  1269. static void ReSizeCanvWin()
  1270. {
  1271.     register int x,y;
  1272.  
  1273.     x = CanvWin->portRect.right - CanvWin->portRect.left;
  1274.     y = CanvWin->portRect.bottom - CanvWin->portRect.top;
  1275.  
  1276.     /* ClipRect(&CanvWin->portRect); */
  1277.     InvalRect(&CanvWin->portRect);
  1278.     
  1279.     HidePen();
  1280.     HideControl(HScroll);
  1281.     HideControl(VScroll);
  1282.     MoveControl(HScroll,-1,y-15);  SizeControl(HScroll,x-14,16);    
  1283.     MoveControl(VScroll,x-15,-1);  SizeControl(VScroll,16,y-14);
  1284.     ShowPen();
  1285.     
  1286.     ShowControl(HScroll);
  1287.     ShowControl(VScroll);
  1288.     DrawGrowIcon(CanvWin);
  1289.  
  1290.     XRange = x-15;   WRange = XRange>>1;
  1291.     YRange = y-15;   HRange = YRange>>1;
  1292.     Range = MinFun(XRange,YRange);
  1293.     ReDrawFlag |= RFReSize;
  1294.     ClearImage();
  1295. }
  1296.  
  1297.  
  1298. static void GrowCanvWin( pos )
  1299.     Point pos;
  1300. {
  1301.     register long size;
  1302.     register int x,y,dx;
  1303.     GrafPtr savePort;
  1304.     Rect rect;
  1305.     
  1306. #ifdef __CONDITIONALMACROS__
  1307.     rect.bottom = qd.screenBits.bounds.bottom;
  1308.     rect.right = qd.screenBits.bounds.right;
  1309. #else
  1310.     rect.bottom = screenBits.bounds.bottom;
  1311.     rect.right = screenBits.bounds.right;
  1312. #endif
  1313.  
  1314.     rect.left = 128;
  1315.     rect.top = 128;
  1316.     
  1317.     size = GrowWindow(CanvWin,pos,&rect);
  1318.     if( !size ) return; /* No Change! */
  1319.     
  1320.     GetPort(&savePort);
  1321.     SetPort(CanvWin);
  1322.     
  1323.     x = LoWord(size)-15;
  1324.     y = HiWord(size);
  1325.     
  1326.     /* Ensure Long Aligned */
  1327.     if( dx = x%4 ) x += 4-dx;
  1328.     SizeWindow(CanvWin,x+15,y,FALSE);
  1329.     ReSizeCanvWin();
  1330.     SetPort(savePort);
  1331. }
  1332.  
  1333. static void ReSizeCmndWin()
  1334. {
  1335.     register int rows,cols;
  1336.     register int sr,er;
  1337.     register int x, y;
  1338.     
  1339.     x = CmndWin->portRect.right - CmndWin->portRect.left;
  1340.     y = CmndWin->portRect.bottom - CmndWin->portRect.top;
  1341.     
  1342.     InvalRect(&CmndWin->portRect);
  1343.     MoveControl(CmndScroll,x-15,-1);
  1344.     SizeControl(CmndScroll,16,y-14);    
  1345.     
  1346.     cols = (x-16)/CharWide;
  1347.     rows = y/CharSkip;
  1348.     
  1349.     /* Scroll to bottom */
  1350.     if( ScrlStart )
  1351.         SetTermScroll( ScrlMax );
  1352.  
  1353.     if( rows < TermRows )
  1354.     {   if( TermYPos >= rows )
  1355.         {   CmndStart += (TermYPos-rows) + 1;
  1356.             if( CmndStart > CmndRows )
  1357.                 CmndStart -= CmndRows;
  1358.             TermYPos = rows-1;
  1359.         }
  1360.         
  1361.     } else if( rows > TermRows )
  1362.     {   sr = TermRows + CmndStart;
  1363.         if( sr >= CmndRows )
  1364.             sr -= CmndRows;
  1365.             
  1366.         er = CmndStart + rows;
  1367.         if( er >= CmndRows )
  1368.             er -= CmndRows;
  1369.             
  1370.         do {
  1371.             memset(TermScreen+sr*CmndCols,' ',CmndCols);
  1372.             sr++; if( sr == CmndRows ) sr = 0;
  1373.         } while( sr != er );
  1374.     }
  1375.     
  1376.     if( cols > CmndCols )
  1377.     {   TermCols = CmndCols;
  1378.     } else TermCols = cols;
  1379.     TermRows = rows;
  1380. }
  1381.  
  1382.  
  1383. static void GrowCmndWin( pos )
  1384.     Point pos;
  1385. {
  1386.     register long size;
  1387.     GrafPtr savePort;
  1388.     
  1389.     size = GrowWindow(CmndWin,pos,&CmndRect);
  1390.     if( !size ) return;  /* No Change! */
  1391.     
  1392.     GetPort(&savePort);
  1393.     SetPort(CmndWin);
  1394.     SizeWindow(CmndWin,LoWord(size),HiWord(size),FALSE);
  1395.     ReSizeCmndWin();
  1396.     SetPort(savePort);
  1397. }
  1398.  
  1399.  
  1400. static void ClampDial( dial, value )
  1401.     int dial;  Real value;
  1402. {
  1403.     register Real temp;
  1404.     
  1405.     temp = DialValue[dial] + value;
  1406.     
  1407.     if( temp > 1.0 )
  1408.     {   DialValue[dial] = 1.0;
  1409.     } else if( temp < -1.0 )
  1410.     {   DialValue[dial] = -1.0;
  1411.     } else DialValue[dial] = temp;
  1412. }
  1413.  
  1414.  
  1415. static void WrapDial( dial, value )
  1416.     int dial;  Real value;
  1417. {
  1418.     register Real temp;
  1419.     
  1420.     temp = DialValue[dial] + value;
  1421.     while( temp < -1.0 )  temp += 2.0;
  1422.     while( temp > 1.0 )   temp -= 2.0;
  1423.     DialValue[dial] = temp;
  1424. }
  1425.  
  1426.  
  1427. #define ShiftModifier   0x2200
  1428. #define CntrlModifier   0x9000
  1429. #define LButtModifier   0x0080
  1430. #define MButtModifier   0x0100  /* [Option]  */
  1431. #define RButtModifier   0x4800  /* [Command] */
  1432.  
  1433. static void MouseMove( status, dx, dy )
  1434.     int status, dx, dy;
  1435. {
  1436.     if( MouseMode == MMRasMol )
  1437.     {   if( status & ShiftModifier )
  1438.         {   if( status & (MButtModifier|RButtModifier) )
  1439.             {   if( dx )  /* Z Rotation Horizontal */
  1440.                 {   WrapDial( 2, (Real)dx/WRange );
  1441.                     ReDrawFlag |= RFRotateZ;
  1442.                 }
  1443.             } else
  1444.                 if( dy )  /* Zoom Vertical */
  1445.                 {   ClampDial( 3, (Real)dy/HRange );
  1446.                     ReDrawFlag |= RFZoom;
  1447.                 }
  1448.         
  1449.         } else if( status & CntrlModifier )
  1450.         {   if( dy )   /* Slab Vertical */
  1451.             {   ClampDial( 7, (Real)dy/YRange );
  1452.                 ReDrawFlag |= RFSlab;
  1453.             }
  1454.         
  1455.         } else /* Unmodified */
  1456.             if( status & (MButtModifier|RButtModifier) )
  1457.             {   if( dx ) /* Translate X Horizontal */
  1458.                 {   ClampDial( 4, (Real)dx/XRange );
  1459.                     ReDrawFlag |= RFTransX;
  1460.                 }
  1461.                 if( dy ) /* Translate Y Vertical   */
  1462.                 {   ClampDial( 5, (Real)dy/YRange );
  1463.                     ReDrawFlag |= RFTransY;
  1464.                 }
  1465.             } else
  1466.             {   if( dx ) /* Rotate Y Horizontal */
  1467.                 {   WrapDial( 1, (Real)dx/WRange );
  1468.                     ReDrawFlag |= RFRotateY;
  1469.                 }
  1470.                 if( dy ) /* Rotate X Vertical */
  1471.                 {   WrapDial( 0, (Real)dy/HRange );
  1472.                     ReDrawFlag |= RFRotateX;
  1473.                 }
  1474.                 UpdateScrollBars();
  1475.             }
  1476.  
  1477.     } else if( MouseMode == MMQuanta )
  1478.     {   if( status & ShiftModifier )
  1479.         {   if( status & LButtModifier )
  1480.             {   if( dy ) /* Slab Vertical */
  1481.                 {   ClampDial( 7, (Real)dy/YRange );
  1482.                     ReDrawFlag |= RFSlab;
  1483.                 }
  1484.             } else if( status & MButtModifier )
  1485.             {   if( dx ) /* Translate X Horizontal */
  1486.                 {   ClampDial( 4, (Real)dx/XRange );
  1487.                     ReDrawFlag |= RFTransX;
  1488.                 }
  1489.                 if( dy ) /* Translate Y Vertical   */
  1490.                 {   ClampDial( 5, (Real)dy/YRange );
  1491.                     ReDrawFlag |= RFTransY;
  1492.                 }
  1493.             } else if( !(status & RButtModifier) )
  1494.                 if( dy )  /* Zoom Vertical */
  1495.                 {   ClampDial( 3, (Real)dy/HRange );
  1496.                     ReDrawFlag |= RFZoom;
  1497.                 }
  1498.         } else if( status & MButtModifier )
  1499.         {   if( dx ) /* Rotate Y Horizontal */
  1500.             {   WrapDial( 1, (Real)dx/WRange );
  1501.                 ReDrawFlag |= RFRotateY;
  1502.             }
  1503.             if( dy ) /* Rotate X Vertical */
  1504.             {   WrapDial( 0, (Real)dy/HRange );
  1505.                 ReDrawFlag |= RFRotateX;
  1506.             }
  1507.             UpdateScrollBars();
  1508.         } else if( status & RButtModifier )
  1509.             if( dx )  /* Z Rotation Horizontal */
  1510.             {   WrapDial( 2, (Real)dx/WRange );
  1511.                 ReDrawFlag |= RFRotateZ;
  1512.             }
  1513.         
  1514.     } else /* MMInsight */
  1515.         if( status & LButtModifier )
  1516.         {   if( status & MButtModifier )
  1517.             {   if( status & RButtModifier )
  1518.                 {   ClampDial( 7, (Real)dx/XRange - 
  1519.                                   (Real)dy/YRange );
  1520.                     ReDrawFlag |= RFSlab;
  1521.                 } else
  1522.                 {   ClampDial( 3, (Real)dx/WRange - 
  1523.                                   (Real)dy/HRange );
  1524.                     ReDrawFlag |= RFZoom;
  1525.                 }
  1526.             } else if( status & RButtModifier )
  1527.             {   WrapDial( 2, (Real)dx/WRange - 
  1528.                              (Real)dy/HRange );
  1529.                 ReDrawFlag |= RFRotateZ;
  1530.             } else
  1531.             {   if( dx ) /* Rotate Y Horizontal */
  1532.                 {   WrapDial( 1, (Real)dx/WRange );
  1533.                     ReDrawFlag |= RFRotateY;
  1534.                 }
  1535.                 if( dy ) /* Rotate X Vertical */
  1536.                 {   WrapDial( 0, (Real)dy/HRange );
  1537.                     ReDrawFlag |= RFRotateX;
  1538.                 }
  1539.                 UpdateScrollBars();
  1540.             }
  1541.         } else if( status & MButtModifier )
  1542.         {   if( dx ) /* Translate X Horizontal */
  1543.             {   ClampDial( 4, (Real)dx/XRange );
  1544.                 ReDrawFlag |= RFTransX;
  1545.             }
  1546.             if( dy ) /* Translate Y Vertical   */
  1547.             {   ClampDial( 5, (Real)dy/YRange );
  1548.                 ReDrawFlag |= RFTransY;
  1549.             }
  1550.         } 
  1551. }
  1552.  
  1553.  
  1554. pascal void CanvScrollProc( cntrl, code )
  1555.     ControlHandle cntrl;  short code;
  1556. {   
  1557.     register int pos;
  1558.     
  1559.     pos = GetCtlValue(cntrl); 
  1560.     switch( code )
  1561.     {   case(inUpButton):    pos -= 5;   break;
  1562.         case(inDownButton):  pos += 5;   break;
  1563.         case(inPageUp):      pos -= 10;  break;
  1564.         case(inPageDown):    pos += 10;  break;
  1565.         default:             return;
  1566.     }
  1567.     
  1568.     if( pos>100 )
  1569.     {   pos -= 100;
  1570.     } else if( pos<0 )
  1571.         pos += 100;
  1572.         
  1573.     SetCtlValue(cntrl,pos);
  1574.     if( cntrl == HScroll )
  1575.     {   DialValue[1] = (pos/50.0)-1.0;
  1576.         ReDrawFlag |= RFRotateY;
  1577.     } else /* cntrl == VScroll */
  1578.     {   DialValue[0] = (pos/50.0)-1.0;
  1579.         ReDrawFlag |= RFRotateX; 
  1580.     }
  1581.     RefreshScreen();
  1582. }
  1583.  
  1584.  
  1585. static void ClickCanvWin( ptr )
  1586.     EventRecord *ptr;
  1587. {
  1588.     register int code,pos;
  1589.  
  1590.     ControlHandle hand;
  1591.     GrafPtr savePort;
  1592.     Point pnt;
  1593.     
  1594.     if( CanvWin == FrontWindow() )
  1595.     {   GetPort(&savePort);
  1596.         SetPort(CanvWin);
  1597.         
  1598.         GlobalToLocal(&ptr->where);
  1599.         code = FindControl(ptr->where,CanvWin,&hand);
  1600.         if( !code )
  1601.         {   InitX = PointX = ptr->where.h;
  1602.             InitY = PointY = ptr->where.v;
  1603.             HeldButton = True;
  1604.             
  1605.         } else if( code == inThumb )   
  1606.         {   TrackControl(hand,ptr->where,0L);
  1607.             pos = GetCtlValue(hand);
  1608.             if( hand == HScroll )
  1609.             {   DialValue[1] = (pos/50.0)-1.0;
  1610.                 ReDrawFlag |= RFRotateY;
  1611.             } else /* hand == VScroll */
  1612.             {   DialValue[0] = (pos/50.0)-1.0;
  1613.                 ReDrawFlag |= RFRotateX; 
  1614.             }
  1615.             RefreshScreen();
  1616.         } else TrackControl(hand,ptr->where,
  1617. #ifdef __CONDITIONALMACROS__
  1618.                          CanvScrollProcPtr);
  1619. #else
  1620.                          (ProcPtr)CanvScrollProc );
  1621. #endif
  1622.         SetPort(savePort);
  1623.     } else SelectWindow( CanvWin );
  1624. }
  1625.  
  1626.  
  1627.  
  1628. pascal void CmndScrollProc( cntrl, code )
  1629.     ControlHandle cntrl;  short code;
  1630. {
  1631.     switch( code )
  1632.     {   case(inUpButton):    if( ScrlStart < ScrlMax )
  1633.                              {   SetTermScroll((ScrlMax-ScrlStart)-1);
  1634.                                  PaintScreen();
  1635.                              }
  1636.                              break;
  1637.                              
  1638.         case(inDownButton):  if( ScrlStart > 0 )
  1639.                              {   SetTermScroll((ScrlMax-ScrlStart)+1);
  1640.                                  PaintScreen();
  1641.                              }
  1642.                              break;
  1643.                                  
  1644.         case(inPageUp):      if( ScrlStart < (ScrlMax-10) )
  1645.                              {   SetTermScroll((ScrlMax-ScrlStart)-10);
  1646.                                  PaintScreen();
  1647.                              }
  1648.                              break;
  1649.                              
  1650.         case(inPageDown):    if( ScrlStart > 10 )
  1651.                              {   SetTermScroll((ScrlMax-ScrlStart)+10);
  1652.                                  PaintScreen();
  1653.                              }
  1654.                              break;
  1655.     }
  1656. }
  1657.  
  1658.  
  1659. static void ClickCmndWin( ptr )
  1660.     EventRecord *ptr;
  1661. {
  1662.     register int code;
  1663.     ControlHandle hand;
  1664.     GrafPtr savePort;
  1665.     
  1666.     if( CmndWin == FrontWindow() )
  1667.     {   GetPort(&savePort);
  1668.         SetPort(CmndWin);
  1669.         
  1670.         GlobalToLocal(&ptr->where);
  1671.         code = FindControl(ptr->where,CmndWin,&hand);
  1672.         if( code == inThumb )   
  1673.         {   TrackControl(CmndScroll,ptr->where,0L);
  1674.             SetTermScroll(GetCtlValue(CmndScroll));
  1675.         } else if( code )
  1676.             TrackControl(CmndScroll,ptr->where,
  1677. #ifdef __CONDITIONALMACROS__
  1678.                          CmndScrollProcPtr);
  1679. #else
  1680.                          (ProcPtr)CmndScrollProc );
  1681. #endif
  1682.         SetPort(savePort);
  1683.     } else SelectWindow( CmndWin );
  1684. }
  1685.  
  1686.  
  1687. static void ZoomCanvWin( pos, code )
  1688.     Point pos;  int code;
  1689. {
  1690.     GrafPtr savePort;
  1691.     
  1692.     if( TrackBox(CanvWin,pos,code) )
  1693.     {   GetPort(&savePort);
  1694.         SetPort(CanvWin);
  1695.         /* EraseRect(&CanvWin->portRect); */
  1696.         ZoomWindow(CanvWin,code,TRUE);
  1697.         ReSizeCanvWin();
  1698.         SetPort(savePort);
  1699.     }   
  1700. }
  1701.  
  1702.  
  1703. static void ZoomCmndWin( pos, code )
  1704.     Point pos;  int code;
  1705. {
  1706.     GrafPtr savePort;
  1707.                                     
  1708.     if( TrackBox(CmndWin,pos,code) )
  1709.     {   GetPort(&savePort);
  1710.         SetPort(CmndWin);
  1711.         EraseRect(&CmndWin->portRect);
  1712.         ZoomWindow(CmndWin,code,TRUE);
  1713.         ReSizeCmndWin();
  1714.         SetPort(savePort);
  1715.      }
  1716. }
  1717.  
  1718.  
  1719. static void HandleMouseDownEvent( ptr )
  1720.     EventRecord *ptr;
  1721. {
  1722.     register int code;
  1723.     WindowPtr win;
  1724.     
  1725.     code = FindWindow(ptr->where,&win);
  1726.     switch( code )
  1727.     {   case(inMenuBar):    AdjustMenus();
  1728.                             HandleMenu( MenuSelect(ptr->where) );
  1729.                             break;
  1730.                             
  1731.         case(inSysWindow):  SystemClick(ptr,win);
  1732.                             break;
  1733.  
  1734.         case(inContent):    if( win == CanvWin )
  1735.                             {   ClickCanvWin( ptr );
  1736.                             } else if( win == CmndWin )
  1737.                             {   ClickCmndWin( ptr );
  1738.                             }
  1739.                             break;
  1740.         
  1741.         case(inDrag):       if( (win==CanvWin) || (win==CmndWin) )
  1742. #ifdef __CONDITIONALMACROS__
  1743.                                 DragWindow(win,ptr->where,&qd.screenBits.bounds);
  1744. #else
  1745.                                 DragWindow(win,ptr->where,&screenBits.bounds);
  1746. #endif
  1747.                             break;
  1748.                              
  1749.         case(inGrow):       if( win==CanvWin )
  1750.                             {   GrowCanvWin( ptr->where );
  1751.                             } else if( win==CmndWin )
  1752.                                 GrowCmndWin( ptr->where );
  1753.                             break;
  1754.         
  1755.         case(inGoAway):     if( (win==CanvWin) || (win==CmndWin) )
  1756.                                 if( TrackGoAway(win,ptr->where) )
  1757.                                     HideWindow(win);
  1758.                             break;
  1759.                             
  1760.         case(inZoomIn):     
  1761.         case(inZoomOut):    if( win==CanvWin )
  1762.                             {   ZoomCanvWin(ptr->where,code);
  1763.                             } else if( win==CmndWin )
  1764.                                 ZoomCmndWin(ptr->where,code);
  1765.                             break;
  1766.     }
  1767. }
  1768.  
  1769.  
  1770.  
  1771. static void HandleMoveEvent( status )
  1772.     int status;
  1773. {
  1774.     register WindowPtr win;
  1775.     register int dx,dy;
  1776.     GrafPtr savePort;
  1777.     Point pos;
  1778.     
  1779.     win = FrontWindow();
  1780.     if( win==CanvWin )
  1781.     {   GetPort(&savePort);
  1782.         SetPort(CanvWin);
  1783.         GetMouse(&pos);
  1784.         
  1785.         /* Invert Button Bit */
  1786.         status ^= LButtModifier;
  1787.         
  1788.         if( (status & (LButtModifier|MButtModifier|RButtModifier))
  1789.             || ((MouseMode==MMQuanta) && (status&ShiftModifier)) )
  1790.         {   if( !HeldButton )
  1791.             {   InitX = PointX = pos.h;
  1792.                 InitY = PointY = pos.v;
  1793.                 HeldButton = True;
  1794.             }
  1795.         } else HeldButton = False;
  1796.  
  1797.         if( HeldButton && !IsClose(pos.h,InitX) 
  1798.                        && !IsClose(pos.v,InitY) )
  1799.         {   dx = pos.h - PointX;
  1800.             dy = pos.v - PointY;
  1801.             MouseMove(status,dx,dy);
  1802.             PointX = pos.h;
  1803.             PointY = pos.v;
  1804.         }   
  1805.         
  1806.         if( HeldButton || ((pos.h>0) && (pos.v>0) &&
  1807.               (pos.v<CanvWin->portRect.bottom-15) &&
  1808.               (pos.h<CanvWin->portRect.right-15)) )
  1809.         {   SetCursor(*CanvCursor);
  1810.         } else ArrowCursor;
  1811.         SetPort(savePort);
  1812.     } else if( win==CmndWin )
  1813.     {   GetPort(&savePort);
  1814.         SetPort(CmndWin);
  1815.         GetMouse(&pos);
  1816.         
  1817.         if( (pos.h>0) && (pos.v>0) &&
  1818.             (pos.v<CmndWin->portRect.bottom) &&
  1819.             (pos.h<CmndWin->portRect.right-15) )
  1820.         {   SetCursor(*CmndCursor);
  1821.         } else ArrowCursor;
  1822.         SetPort(savePort);
  1823.     }
  1824. }
  1825.  
  1826.  
  1827. static int MacKeyMap[32] = { 0x00, 0x01, 0x00, 0x0d, 0x05, 0x00, 0x00, 0x00,
  1828.                              0x08, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
  1829.                              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1830.                              0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x10, 0x0e };
  1831.                               
  1832. static void HandleEvents()
  1833. {
  1834.     register int key,row;
  1835.     
  1836.     EventRecord event;
  1837.     GrafPtr savePort;
  1838.     WindowPtr win;
  1839.     Point pnt;
  1840.  
  1841.     SystemTask();
  1842.     if( GetNextEvent(everyEvent,&event) )
  1843.     {   switch( event.what )
  1844.         {   case(mouseDown):    HeldButton = False;
  1845.                                 HandleMouseDownEvent(&event);
  1846.                                 break;
  1847.                                 
  1848.             case(mouseUp):      if( HeldButton && Database )
  1849.                                 {   GetPort(&savePort);
  1850.                                     SetPort(CanvWin);
  1851.                                     GlobalToLocal(&event.where);
  1852.                                     SetPort(savePort);
  1853.                                     
  1854.                                     PointX = event.where.h;
  1855.                                     PointY = event.where.v;
  1856.                                     
  1857.                                     if( IsClose(PointX,InitX) &&
  1858.                                         IsClose(PointY,InitY) )
  1859.                                     {   IdentifyAtom(PointX,PointY);
  1860.                                         AdviseUpdate(AdvPickNumber);
  1861.                                         AdviseUpdate(AdvPickAtom);
  1862.                                     }
  1863.                                 }
  1864.                                 HeldButton = False;
  1865.                                 break;
  1866.             
  1867.             case(autoKey):
  1868.             case(keyDown):      key = (char)(event.message & charCodeMask);
  1869.                                 if( event.modifiers & cmdKey )
  1870.                                 {   AdjustMenus();
  1871.                                     HandleMenu(MenuKey(key));
  1872.                                 } else if( key<32 )
  1873.                                 {   if( !(event.modifiers & controlKey) )
  1874.                                         key = MacKeyMap[key];
  1875.                                     if( ProcessCharacter(key) )
  1876.                                         if( ExecuteCommand() )
  1877.                                             RasMolExit();
  1878.                                 } else if( key==127 )
  1879.                                 {   /* Forward Delete */
  1880.                                     ProcessCharacter(0x04);
  1881.                                 } else ProcessCharacter(key);
  1882.                                 break;
  1883.             
  1884.             case(keyUp):        break;
  1885.             
  1886.             case(updateEvt):    GetPort(&savePort);
  1887.                                 win = (WindowPtr)event.message;
  1888.                                 if( win == CanvWin )
  1889.                                 {   SetPort(CanvWin);
  1890.                                     BeginUpdate(CanvWin);
  1891.                                     /* ActivatePalette(CanvWin); */
  1892.                                     DrawGrowIcon(CanvWin);
  1893.                                     
  1894.                                     /* Machintosh 128K ROMs and later.       */ 
  1895.                                     /* UpdtControl(CanvWin,CanvWin->visRgn); */
  1896.                                     DrawControls(CanvWin);
  1897.                                     
  1898.                                     /* CopyBits(PixMap);   */
  1899.                                     /* EraseRect(updRect);*/
  1900.                                     if( Database )
  1901.                                     {   TransferImage();
  1902.                                     } else ClearImage();
  1903.                                     
  1904.                                     EndUpdate(CanvWin);
  1905.                                 } else if( win == CmndWin )
  1906.                                 {   SetPort(CmndWin);
  1907.                                     BeginUpdate(CmndWin);
  1908.                                     PaintScreen();
  1909.                                     EndUpdate(CmndWin);
  1910.                                 }
  1911.                                 SetPort(savePort);
  1912.                                 break;
  1913.             
  1914.             case(activateEvt):  HiliteMenu(0);
  1915.                                 HeldButton = False;
  1916.                                 
  1917.                                 win = (WindowPtr)event.message;
  1918.                                 if( win==CanvWin )
  1919.                                 {   DrawGrowIcon(CanvWin);
  1920.                                     if( event.modifiers & activeFlag )
  1921.                                     {   ShowControl(HScroll);
  1922.                                         ShowControl(VScroll);
  1923.                                     } else /* deactiveEvt */
  1924.                                     {   HideControl(HScroll);
  1925.                                         HideControl(VScroll);
  1926.                                     }
  1927.                                 } else /* win==CmndWin */
  1928.                                 {   DrawCmndGrowIcon();
  1929.                                     if( event.modifiers & activeFlag )
  1930.                                     {   ShowControl(CmndScroll);
  1931.                                     } else /* deactiveEvt */
  1932.                                         HideControl(CmndScroll);
  1933.                                 }
  1934.                                 
  1935.                                 /* Caret Handling! */
  1936.                                 win = FrontWindow();
  1937.                                 if( (win==CanvWin) || (win==CmndWin) )
  1938.                                 {   row = TermYPos + ScrlStart;
  1939.                                     if( row < TermRows )
  1940.                                     {   SetCaretPos( TermXPos*CharWide,
  1941.                                                      row*CharSkip );
  1942.                                         TermCursor = True;
  1943.                                         ShowCaret();
  1944.                                     } else
  1945.                                     {   TermCursor = False;
  1946.                                         HideCaret();
  1947.                                     }      
  1948.                                 } else
  1949.                                 {   TermCursor = False;
  1950.                                     HideCaret();
  1951.                                 }
  1952.                                 
  1953.                                 /* Mouse Move Handling! */
  1954.                                 if( win == CanvWin )
  1955.                                 {   GetPort(&savePort);
  1956.                                     SetPort(CanvWin);
  1957.                                     GetMouse(&MousePrev);
  1958.                                     SetPort(savePort);
  1959.                                 }
  1960.                                 break;
  1961.                                 
  1962.             case(kHighLevelEvent):
  1963.                                 AEProcessAppleEvent(&event);
  1964.                                 break;
  1965.                                 
  1966.         }
  1967.     } else if( TermCursor )
  1968.         HandleCaret();
  1969.         
  1970.     HandleMoveEvent( event.modifiers );
  1971.     
  1972.     if( ReDrawFlag )
  1973.         RefreshScreen();
  1974.     if( !CommandActive )
  1975.         ResetCommandLine(0);
  1976. }
  1977.  
  1978.  
  1979. static int HandleFileSpec( fss )
  1980.     FSSpec *fss;
  1981. {
  1982.     register int format;
  1983.     register FILE *fp;
  1984.     FInfo info;
  1985.     
  1986.     if( Database )
  1987.         ZapDatabase();
  1988.  
  1989.     FSpGetFInfo(fss,&info);
  1990.     if( info.fdType == 'RSML' )
  1991.     {   if( (fp=fopen(Filename,"r")) )
  1992.         {   LoadScriptFile(fp,Filename);
  1993.             fclose(fp);
  1994.             return( True );
  1995.         } else return( False );
  1996.     }
  1997.     
  1998.     if( info.fdType == 'mMOL' )
  1999.     {      format = FormatMDL;
  2000.     } else format = FormatPDB;
  2001.         
  2002.     FetchFile(format,True,Filename);
  2003.     if( Database )
  2004.     {   ReDrawFlag |= RFRefresh | RFColour;
  2005.         if( InfoBondCount < 1 )
  2006.         {   EnableBackBone(False,80);
  2007.         } else EnableWireFrame(True,0);
  2008.         CPKColourAttrib();
  2009.         return( True );
  2010.     }        
  2011.     return( False );
  2012. }
  2013.  
  2014.  
  2015. /* Apple Event Handler Prototypes! */
  2016. pascal OSErr HandleAEOpenDoc( AppleEvent*, AppleEvent*, long );
  2017. pascal OSErr HandleAEQuitApp( AppleEvent*, AppleEvent*, long );
  2018. pascal OSErr HandleAEIgnore( AppleEvent*, AppleEvent*, long );
  2019.  
  2020.  
  2021. pascal OSErr HandleAEOpenDoc( event, reply, ref )
  2022.     AppleEvent *event; AppleEvent *reply; long ref;
  2023. {
  2024.     register OSErr stat;
  2025.     register long i;
  2026.     
  2027.     AEDescList list;
  2028.     AEKeyword keywd;
  2029.     DescType dtype;
  2030.     FSSpec fss;
  2031.     long count;
  2032.     Size size;
  2033.     
  2034.     stat = AEGetParamDesc(event,keyDirectObject,
  2035.                           typeAEList,&list);
  2036.     if( stat ) return( stat );
  2037.     
  2038.     stat = AEGetAttributePtr(event,keyMissedKeywordAttr,
  2039.                              typeWildCard, &dtype, 0, 0, &size );
  2040.     if( stat != errAEDescNotFound ) 
  2041.     {   AEDisposeDesc( &list );
  2042.         return( stat? stat : errAEEventNotHandled );
  2043.     }
  2044.     
  2045.     AECountItems( &list, &count );
  2046.     for( i=1; i<=count; i++ )
  2047.     {   stat = AEGetNthPtr(&list,i,typeFSS,&keywd,
  2048.                            &dtype,(Ptr)&fss,sizeof(fss),
  2049.                            &size);
  2050.         if( !stat )
  2051.         {   ConvertFilename(&fss);
  2052.             if( HandleFileSpec(&fss) )
  2053.             {   RefreshScreen();
  2054.                 if( Database && ref )
  2055.                     PrintImage();
  2056.                 break;
  2057.             }
  2058.         }
  2059.     }
  2060.     AEDisposeDesc( &list );         
  2061.     return noErr;
  2062. }
  2063.  
  2064. pascal OSErr HandleAEQuitApp( event, reply, ref )
  2065.     AppleEvent *event; AppleEvent *reply; long ref;
  2066. {
  2067.     RasMolExit();
  2068.     return noErr;
  2069. }
  2070.  
  2071. pascal OSErr HandleAEIgnore( event, reply, ref )
  2072.     AppleEvent *event; AppleEvent *reply; long ref;
  2073. {
  2074.     return noErr;
  2075. }
  2076.  
  2077.  
  2078. static void InitialiseApplication()
  2079. {
  2080.     register PScrapStuff ptr;
  2081.     
  2082.     /* Init Mac ToolBox */
  2083. #ifdef __CONDITIONALMACROS__
  2084.     InitGraf(&qd.thePort);
  2085. #else
  2086.     InitGraf(&thePort);
  2087. #endif
  2088.  
  2089.     InitCursor();
  2090.     InitFonts();
  2091.     InitWindows();
  2092.     InitMenus();
  2093.     TEInit();
  2094.     InitDialogs(0L);
  2095.  
  2096.     RasMolResFile = CurResFile();
  2097.     FlushEvents(everyEvent,0);
  2098.     MaxApplZone();
  2099.     
  2100.     /* Initialise Clipboard */
  2101.     ptr = InfoScrap();
  2102.     if( ptr && (ptr->scrapState<0) )
  2103.         ZeroScrap();
  2104.     
  2105.     /* Enable KeyUp Events  */
  2106.     SetEventMask(everyEvent);
  2107.     
  2108. #ifdef __CONDITIONALMACROS__
  2109.     /* Create Routine Descriptors */
  2110.     HandleAEIgnorePtr = NewAEEventHandlerProc(HandleAEIgnore);
  2111.     HandleAEOpenDocPtr = NewAEEventHandlerProc(HandleAEOpenDoc);
  2112.     HandleAEQuitAppPtr = NewAEEventHandlerProc(HandleAEQuitApp);
  2113.     CanvScrollProcPtr = NewControlActionProc(CanvScrollProc);
  2114.     CmndScrollProcPtr = NewControlActionProc(CanvScrollProc);
  2115.     OpenDlgHookPtr = NewDlgHookYDProc(OpenDlgHook);
  2116.     SaveDlgHookPtr = NewDlgHookYDProc(SaveDlgHook);
  2117.  
  2118.     /* Install Required Event Handlers */
  2119.     AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,
  2120.                           HandleAEIgnorePtr, 0, FALSE);
  2121.     AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,
  2122.                           HandleAEOpenDocPtr, 0, FALSE);
  2123.     AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,
  2124.                           HandleAEOpenDocPtr, 1, FALSE);
  2125.     AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,
  2126.                           HandleAEQuitAppPtr, 0, FALSE);
  2127.  
  2128. #else
  2129.     /* Install Required Event Handlers */
  2130.     AEInstallEventHandler(kCoreEventClass,kAEOpenApplication,
  2131.                           HandleAEIgnore, 0, FALSE);
  2132.     AEInstallEventHandler(kCoreEventClass,kAEOpenDocuments,
  2133.                           HandleAEOpenDoc, 0, FALSE);
  2134.     AEInstallEventHandler(kCoreEventClass,kAEPrintDocuments,
  2135.                           HandleAEOpenDoc, 1, FALSE);
  2136.     AEInstallEventHandler(kCoreEventClass,kAEQuitApplication,
  2137.                           HandleAEQuitApp, 0, FALSE);
  2138. #endif
  2139. }
  2140.  
  2141.  
  2142. int main()
  2143. {
  2144.     GrafPtr savePort;
  2145.     
  2146.     InitialiseApplication();
  2147.  
  2148.     Interactive = True;
  2149.     ReDrawFlag = RFInitial;
  2150.     
  2151.     OpenDisplay(InitialWide,InitialHigh);
  2152.     InitTerminal();
  2153.     
  2154.     WriteString("RasMol Molecular Renderer\n");
  2155.     WriteString("Roger Sayle, October 1994\n");
  2156.     WriteString("Version 2.5\n");
  2157.  
  2158. #ifdef __powerc
  2159.     WriteString("[PowerPC Native]\n");
  2160. #endif
  2161.  
  2162. #ifdef EIGHTBIT
  2163.     WriteString("[8bit version]\n\n");
  2164. #else
  2165.     WriteString("[24bit version]\n\n");
  2166. #endif
  2167.  
  2168.     InitialiseCommand();
  2169.     InitialiseTransform();
  2170.     InitialiseDatabase();
  2171.     InitialiseRenderer();
  2172.     InitialisePixUtils();
  2173.     InitialiseAbstree();
  2174.     InitialiseOutFile();
  2175.     /* LoadInitFile(); */
  2176.     
  2177.     ResetCommandLine(1);
  2178.     RefreshScreen();
  2179.     
  2180.     GetPort(&savePort);
  2181.     SetPort(CanvWin);
  2182.     GetMouse(&MousePrev);
  2183.     SetPort(savePort);
  2184.     
  2185.     while( True )
  2186.         HandleEvents();
  2187. }