home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Science / RasMol2 / applemac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-24  |  11.6 KB  |  543 lines  |  [TEXT/KAHL]
  1. /* applemac.c
  2.  * RasMol2 Molecular Graphics
  3.  * Roger Sayle, October 1994
  4.  * Version 2.5
  5.  */
  6. #include <QuickDraw.h>
  7. #include <Controls.h>
  8. #include <Palettes.h>
  9. #include <Windows.h>
  10. #include <Menus.h>
  11. #include <Fonts.h>
  12.  
  13. #ifdef __CONDITIONALMACROS__
  14. #include <Printing.h>
  15. #else
  16. #include <PrintTraps.h>
  17. #endif
  18. #include <ToolUtils.h>
  19. #include <Memory.h>
  20. #include <Types.h>
  21. #include <Scrap.h>
  22.  
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25.  
  26. #define GRAPHICS
  27. #include "rasmol.h"
  28. #include "graphics.h"
  29. #include "molecule.h"
  30. #include "transfor.h"
  31. #include "render.h"
  32.  
  33.  
  34. static PixPatHandle BackHand;
  35. static PaletteHandle CMap;
  36. static PixMap *PixelMap;
  37. static int CMapClean;
  38.  
  39.  
  40. int CreateImage()
  41. {
  42.     register Long size;
  43.     
  44.     if( FBuffer ) _ffree(FBuffer);
  45.     size = (Long)XRange*YRange*sizeof(Pixel);
  46.     FBuffer = (Pixel*)_fmalloc( size+32 );
  47.  
  48. #ifdef EIGHTBIT
  49.     PixelMap->rowBytes = XRange | 0x8000;
  50. #else
  51.     PixelMap->rowBytes = (XRange<<2) | 0x8000;
  52. #endif
  53.  
  54.     PixelMap->baseAddr = (Ptr)FBuffer;
  55.     PixelMap->bounds.right = XRange;
  56.     PixelMap->bounds.bottom = YRange;
  57.     return( (int)FBuffer );
  58. }
  59.  
  60.  
  61. void TransferImage()
  62. {
  63.     register PixMapHandle pmHand;
  64.     register GDHandle gdHand;
  65.     register int mode;
  66.     GrafPtr savePort;
  67.     Rect rect;
  68.    
  69.     GetPort(&savePort);
  70.     SetPort(CanvWin);
  71.    
  72.     ForeColor(blackColor);
  73.     BackColor(whiteColor);
  74.    
  75.     rect.top = 0;   rect.bottom = YRange;
  76.     rect.left = 0;  rect.right = XRange;
  77.  
  78.     gdHand = GetMaxDevice(&CanvWin->portRect);
  79.     pmHand = (**gdHand).gdPMap;
  80.     if( (**pmHand).pixelSize < (sizeof(Pixel)<<3) )
  81.     {   mode = srcCopy+ditherCopy;
  82.     } else mode = srcCopy;
  83.     
  84.     /* ClipRect(&rect); */
  85.     CopyBits((BitMap*)PixelMap,
  86.              (BitMap*)&CanvWin->portBits,
  87.              &rect,&rect,mode,(RgnHandle)0);
  88.  
  89.     BackColor(blackColor);
  90.     SetPort(savePort);
  91. }
  92.  
  93.  
  94. void ClearImage()
  95. {
  96.     GrafPtr savePort;
  97.     RGBColor col;
  98.     Rect rect;
  99.  
  100.     GetPort(&savePort);
  101.     SetPort(CanvWin);
  102.     
  103.     rect.bottom = CanvWin->portRect.bottom-15;
  104.     rect.right = CanvWin->portRect.right-15;
  105.     rect.left = 0;    
  106.     rect.top = 0;
  107.     
  108.     col.red   = BackR<<8 | BackR;
  109.     col.green = BackG<<8 | BackG;
  110.     col.blue  = BackB<<8 | BackB;
  111.     
  112.     MakeRGBPat(BackHand,&col);
  113.     FillCRect(&rect,BackHand);
  114.     SetPort(savePort);
  115. }
  116.  
  117.  
  118. static PicHandle CreateMacPicture()
  119. {
  120.     GrafPtr savePort;
  121.     RgnHandle saveRgn;
  122.     PicHandle pict;
  123.     Rect rect;
  124.  
  125.     saveRgn = NewRgn();
  126.     GetPort(&savePort);
  127.     SetPort(CanvWin);
  128.     GetClip( saveRgn );
  129.     
  130.     rect.top = 0;   rect.bottom = YRange;
  131.     rect.left = 0;  rect.right = XRange;
  132.     pict = OpenPicture(&rect);
  133.   
  134.     ForeColor(blackColor);
  135.     BackColor(whiteColor);
  136.    
  137.     ClipRect( &rect );
  138.     CopyBits((BitMap*)PixelMap,
  139.              (BitMap*)&CanvWin->portBits,
  140.              &rect,&rect,srcCopy,(RgnHandle)0);
  141.  
  142.     ClosePicture();
  143.     
  144.     SetClip(saveRgn);
  145.     BackColor(blackColor);
  146.     DisposeRgn(saveRgn);
  147.     SetPort(savePort);
  148.     return pict;
  149. }
  150.  
  151.  
  152. int PrintImage()
  153. {
  154.     register int xsize,ysize;
  155.     register int high,wide;
  156.     
  157.     TPrStatus prStatus;
  158.     TPPrPort printPort;
  159.     GrafPtr savePort;
  160.     PicHandle pict;
  161.     short prErr;
  162.     Rect *page;
  163.     Rect rect;
  164.  
  165.     PrOpen();
  166.     if( !PrintHand )
  167.     {   PrintHand = (THPrint)NewHandle(sizeof(TPrint));
  168.         PrintDefault(PrintHand);
  169.     }
  170.  
  171.     if( PrJobDialog(PrintHand) )
  172.     {   pict = CreateMacPicture();
  173.         printPort = PrOpenDoc(PrintHand,0,0);
  174.         GetPort(&savePort);    
  175.         SetPort(&printPort->gPort);
  176.         
  177.         PrOpenPage( printPort, 0 );
  178.         page = &(**PrintHand).prInfo.rPage; 
  179.         wide = page->right - page->left;
  180.         high = page->bottom - page->top;
  181.         
  182.         xsize = XRange;
  183.         ysize = YRange;
  184.         if( xsize > wide )
  185.         {   ysize = (int)(((Long)ysize*wide)/xsize);
  186.             xsize = wide;
  187.         }
  188.         if( ysize > high )
  189.         {   xsize = (int)(((Long)xsize*high)/ysize);
  190.             ysize = high;
  191.         }
  192.         
  193.         rect.top  = page->top  + (high-ysize)>>1;
  194.         rect.left = page->left + (wide-xsize)>>1;
  195.         rect.bottom = rect.top + ysize;
  196.         rect.right = rect.left + xsize;
  197.         
  198.         DrawPicture( pict, &rect );
  199.         PrClosePage( printPort );
  200.         
  201.         SetPort(savePort);
  202.         PrCloseDoc(printPort);
  203.         KillPicture(pict);
  204.         
  205.         if( !(prErr = PrError()) )
  206.             if( (*PrintHand)->prJob.bJDocLoop == bSpoolLoop )
  207.             {   PrPicFile(PrintHand,0,0,0,&prStatus);
  208.                 prErr = PrError();
  209.             }
  210.          
  211.     } else prErr = False;  /* Cancel Print */
  212.  
  213.     PrClose();
  214.     return( !prErr );
  215. }
  216.  
  217. int ClipboardImage()
  218. {
  219.     register long clipErr;
  220.     register long length;
  221.     PicHandle pict;
  222.     
  223.     register int i;
  224.     register FILE *fp;
  225.     
  226.     ZeroScrap();
  227.     pict = CreateMacPicture();
  228.     
  229.     HLock((Handle)pict);
  230.     length = (long)GetHandleSize((Handle)pict);
  231.     clipErr = PutScrap(length,'PICT',(Ptr)*pict);
  232.     HUnlock((Handle)pict);
  233.     
  234.     KillPicture(pict);   
  235.     return( !clipErr );
  236. }
  237.  
  238.  
  239. void AllocateColourMap()
  240. { 
  241. #ifdef EIGHTBIT
  242.     register PixMapHandle pmHand;
  243.     register GDHandle gdHand;
  244.     register CTabHandle cmap;
  245.     register int i;
  246.     RGBColor col;
  247.     
  248.     ULut[0] = True;
  249.     ULut[255] = True;
  250.     
  251.     HLock((Handle)CMap);
  252.     cmap = PixelMap->pmTable;
  253.     (**cmap).ctSeed = GetCTSeed();
  254.     for( i=0; i<256; i++ )
  255.     {   if( ULut[i] )
  256.         {   col.red   = RLut[i]<<8 | RLut[i];
  257.             col.green = GLut[i]<<8 | GLut[i];
  258.             col.blue  = BLut[i]<<8 | BLut[i];
  259.             Lut[i] = i;
  260.         } else col.red = col.green = col.blue = 0;
  261.         (**cmap).ctTable[i].rgb = col;
  262.         SetEntryColor(CMap,i,&col);
  263.     }
  264.     HUnlock((Handle)CMap);
  265.     
  266.     gdHand = GetMaxDevice(&CanvWin->portRect);
  267.     pmHand = (**gdHand).gdPMap;
  268.     if( (**pmHand).pixelSize >= 8 )
  269.     {   ActivatePalette(CanvWin);
  270.         CMapClean = False;
  271.     }
  272.     FBClear = False;
  273. #endif
  274. }
  275.  
  276.  
  277. void UpdateScrollBars()
  278. {
  279.     register int pos;
  280.     
  281.     pos = 50+(int)(50.0*DialValue[1]);
  282.     SetCtlValue(HScroll,pos);
  283.     
  284.     pos = 50+(int)(50.0*DialValue[0]);
  285.     SetCtlValue(VScroll,pos);
  286. }
  287.  
  288.  
  289. void SetMouseMode( mode )
  290.     int mode;
  291. {
  292.     MouseMode = mode;
  293. }
  294.  
  295.  
  296. int LookUpColour( name, r, g, b )
  297.     char *name; int *r, *g, *b;
  298. {
  299.     return( False );
  300. }
  301.  
  302.  
  303. void EnableMenus( flag )
  304.     int flag;
  305. {
  306.     register int i;
  307.     MenuHandle hand;
  308.     long offset;
  309.     
  310.     /* File Menu */
  311.     hand = GetMHandle(141);
  312.     if( flag && !Database )
  313.     {   EnableItem(hand,1);
  314.     } else DisableItem(hand,1);
  315.     
  316.     if( Database && flag )
  317.     {   EnableItem(hand,2);
  318.         EnableItem(hand,3);
  319.         EnableItem(hand,5);
  320.         EnableItem(hand,6);
  321.     } else
  322.     {   DisableItem(hand,2);
  323.         DisableItem(hand,3);
  324.         DisableItem(hand,5);
  325.         DisableItem(hand,6);
  326.     }
  327.     
  328.     /* Edit Menu */
  329.     hand = GetMHandle(142);
  330.     if( Database )
  331.     {   EnableItem(hand,3);
  332.     } else DisableItem(hand,3);
  333.     
  334.     if( flag && (GetScrap(0,'TEXT',&offset)>0) )
  335.     {   EnableItem(hand,4);
  336.     } else DisableItem(hand,4);
  337.     
  338.     if( flag && Database )
  339.     {   EnableItem(hand,7);
  340.     } else DisableItem(hand,7);
  341.     
  342.     
  343.     /* Middle Menus */
  344.     if( Database && flag )
  345.     {   EnableItem(GetMHandle(143),0);
  346.         EnableItem(GetMHandle(144),0);
  347.         EnableItem(GetMHandle(145),0);
  348.     } else
  349.     {   DisableItem(GetMHandle(143),0);
  350.         DisableItem(GetMHandle(144),0);
  351.         DisableItem(GetMHandle(145),0);
  352.     }
  353.     
  354.     /* Export Menu */
  355.     hand = GetMHandle(146);
  356.     if( Database )
  357.     {   EnableItem(hand,0);
  358.     } else DisableItem(hand,0);
  359.     DisableMenu = !flag;
  360.     DrawMenuBar();
  361. }
  362.  
  363.  
  364. static void DefineMenus()
  365. {
  366.     MenuHandle hand;
  367.     register long region;
  368.     register int i;
  369.     
  370.     /* Apple Menu */
  371.     hand = GetMenu(140);
  372.     AddResMenu(hand,'DRVR');
  373.     InsertMenu(hand,0);
  374.     
  375.     for( i=141; i<148; i++ )
  376.         InsertMenu( GetMenu(i), 0 );
  377.         
  378.     /* if( GetEnvirons(smRegionCode) == verUS ) */
  379.     /* SetItem(GetMHandle(144),0,'\pColors");   */
  380.     EnableMenus( True );
  381. }
  382.  
  383.  
  384. int OpenDisplay( x, y )
  385.     int x, y;
  386. {
  387. #ifndef EIGHTBIT
  388.     register CTabHandle cmap;
  389. #endif
  390.     register int i;
  391.     Rect rect;
  392.     
  393.     UseHourGlass = True;
  394.     MouseMode = MMRasMol;
  395.     DisableMenu = False;
  396.  
  397.     for( i=0; i<8; i++ )
  398.         DialValue[i] = 0.0;
  399.     
  400.     ULut[0] = ULut[255] = True;
  401.     RLut[255] = GLut[255] = BLut[255] = 0;
  402.     RLut[0] = GLut[0] = BLut[0] = 255;
  403.     
  404.     XRange = x;   WRange = XRange>>1;
  405.     YRange = y;   HRange = YRange>>1;
  406.     Range = MinFun(XRange,YRange);
  407.     
  408.     CanvWin = GetNewCWindow(150,0,(WindowPtr)-1);
  409.     SetPort(CanvWin);
  410.     
  411.     SizeWindow(CanvWin,x+15,y+15,TRUE);
  412.     ShowWindow(CanvWin);
  413.     
  414.     /* Load Cursors */
  415.     CanvCursor = GetCursor(160);
  416.     CmndCursor = GetCursor(1);
  417.     WaitCursor = GetCursor(4);   
  418.     
  419.     /* Create Scroll Bars */
  420.     rect.left = -1;  rect.right = x+1;  
  421.     rect.top = y;    rect.bottom = y+16;
  422.     HScroll = NewControl(CanvWin,&rect,"\p",TRUE,
  423.                          50,0,100,scrollBarProc,0L);
  424.     
  425.     rect.left = x;   rect.right = x+16;
  426.     rect.top = -1;   rect.bottom = y+1;
  427.     VScroll = NewControl(CanvWin,&rect,"\p",TRUE,
  428.                          50,0,100,scrollBarProc,0L);
  429.     
  430.     DrawGrowIcon(CanvWin);
  431.     
  432.     
  433.     /* PixMap! */
  434.     PixelMap = (PixMap*)NewPtr(sizeof(PixMap));
  435.     if( !PixelMap ) return( True );
  436.     
  437.     /* 72.0 DPI Resolution! */
  438.     PixelMap->hRes = 72;
  439.     PixelMap->vRes = 72;
  440.     PixelMap->bounds.left = 0;
  441.     PixelMap->bounds.top = 0;
  442.     PixelMap->cmpSize = 8;
  443.     
  444.     PixelMap->planeBytes = 0;
  445.     PixelMap->pmReserved = 0;
  446.     PixelMap->pmVersion = 0;
  447.     PixelMap->packType = 0;
  448.     PixelMap->packSize = 0;
  449.     
  450. #ifdef EIGHTBIT
  451.     /* Indexed PixMap */
  452.     PixelMap->pixelSize = 8;
  453.     PixelMap->pixelType = 0;
  454.     PixelMap->cmpCount = 1;
  455.     
  456.     PixelMap->pmTable = GetCTable(8);
  457.     (**PixelMap->pmTable).ctSeed = GetCTSeed();
  458.     
  459.     CMap = NewPalette(256,(CTabHandle)0,pmTolerant,0);
  460.     SetPalette(CanvWin,CMap,True);
  461.     CMapClean = True;
  462. #else
  463.     /* Direct PixMap */
  464.     PixelMap->pixelSize = 32;
  465.     PixelMap->cmpSize = 8;
  466.     PixelMap->pixelType = RGBDirect;
  467.     PixelMap->cmpCount = 3;
  468.     
  469.     i = sizeof(ColorTable) - sizeof(CSpecArray);
  470.     cmap = (CTabHandle)NewHandle(i);
  471.     (**cmap).ctSeed = 32;
  472.     (**cmap).ctFlags = 0;
  473.     (**cmap).ctSize = 0;
  474.     PixelMap->pmTable = cmap;
  475. #endif
  476.     
  477.     /* Initialise Palette! */
  478.     for( i=1; i<255; i++ )
  479.         ULut[i] = False;
  480.     AllocateColourMap();
  481.     
  482.     PrintHand = (THPrint)NULL;
  483.     BackHand = NewPixPat();
  484.     DefineMenus();
  485.     return(False);
  486. }
  487.  
  488. void CloseDisplay()
  489. {
  490. }
  491.  
  492.  
  493. void BeginWait()
  494. {
  495.     register WindowPtr win;
  496.     
  497.     if( UseHourGlass )
  498.     {   win = FrontWindow();
  499.         if( win==CanvWin || win==CmndWin )
  500.             SetCursor(*WaitCursor);
  501.     }
  502. }
  503.  
  504. #ifdef __CONDITIONALMACROS__
  505. #define ArrowCursor   SetCursor(&qd.arrow)
  506. #else
  507. #define ArrowCursor   SetCursor(&arrow)
  508. #endif
  509.  
  510. void EndWait()
  511. {
  512.     register WindowPtr win;
  513.     GrafPtr savePort;
  514.     Point pos;
  515.     
  516.     /* if( UseHourGlass )? */
  517.     
  518.     win = FrontWindow();
  519.     if( win==CanvWin )
  520.     {   GetPort(&savePort);
  521.         SetPort(CanvWin);
  522.         GetMouse(&pos);
  523.         
  524.         if( (pos.h>0) && (pos.v>0) &&
  525.             (pos.v<CanvWin->portRect.bottom-15) &&
  526.             (pos.h<CanvWin->portRect.right-15) )
  527.         {   SetCursor(*CanvCursor);
  528.         } else ArrowCursor;
  529.         SetPort(savePort);
  530.     } else if( win==CmndWin )
  531.     {   GetPort(&savePort);
  532.         SetPort(CmndWin);
  533.         GetMouse(&pos);
  534.         
  535.         if( (pos.h>0) && (pos.v>0) &&
  536.             (pos.v<CmndWin->portRect.bottom) &&
  537.             (pos.h<CmndWin->portRect.right-15) )
  538.         {   SetCursor(*CmndCursor);
  539.         } else ArrowCursor;
  540.         SetPort(savePort);
  541.     }
  542. }
  543.