home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Educational / RasMol / Source / rasnext / RasView.m < prev   
Encoding:
Text File  |  1995-11-01  |  14.7 KB  |  683 lines
  1.  
  2. #import <dpsclient/event.h>
  3. #include <objc/NXBundle.h>
  4. #include <dpsclient/psops.h>
  5.  
  6. #define NEXT
  7.  
  8. #import <appkit/OpenPanel.h>
  9. #import <appkit/ClipView.h>
  10. #import <appkit/ScrollView.h>
  11. #import <appkit/Scroller.h>
  12. #import <appkit/Matrix.h>
  13. #import "RasView.h"
  14.  
  15. #ifdef TWOBIT
  16. char *tbuf;
  17. #endif
  18.  
  19. @implementation RasView
  20.  
  21. //
  22. - initFrame:(const NXRect *) frameRect
  23.  {
  24.     [(self = [super initFrame:frameRect]) allocateGState];
  25.     bm = nil;
  26. #if IMAGE
  27.     image = nil;
  28. #endif
  29.     meters = nil;
  30.     text = nil;
  31.     rasView = self;
  32.     XRange = frameRect->size.width;
  33.     YRange = frameRect->size.height;
  34.     [NXApp setDelegate:self];
  35.     return self;
  36.  }
  37.  
  38. - initBitmap
  39. {
  40.     if (bm) [bm free];
  41. #ifdef TWOBIT
  42.     if (bm) free(tbuf);
  43.     tbuf = malloc(((XRange>>2)+1)*YRange);
  44.     bm = [[NXBitmapImageRep alloc] initData:(unsigned char*)tbuf
  45.         pixelsWide:XRange
  46.         pixelsHigh:YRange
  47.         bitsPerSample:2
  48.         samplesPerPixel:1
  49.         hasAlpha:NO
  50.         isPlanar:NO
  51.         colorSpace:NX_OneIsWhiteColorSpace
  52.         bytesPerRow:((XRange>>2)+1)
  53.         bitsPerPixel:2
  54.     ];
  55. #else
  56. #ifdef EIGHTBIT
  57. //    printf("Initialize 8bit\n");
  58.     bm = [[NXBitmapImageRep alloc] initData:(unsigned char*)FBuffer
  59.         pixelsWide:XRange
  60.         pixelsHigh:YRange
  61.         bitsPerSample:8
  62.         samplesPerPixel:1
  63.         hasAlpha:NO
  64.         isPlanar:NO
  65.         colorSpace:NX_OneIsWhiteColorSpace
  66.         bytesPerRow:0
  67.         bitsPerPixel:0
  68.     ];
  69. #else
  70. #ifdef SIXTEENBIT
  71. //    printf("Initialize 12bit\n");
  72.     bm = [[NXBitmapImageRep alloc] initData:(unsigned char*)FBuffer
  73.         pixelsWide:XRange
  74.         pixelsHigh:YRange
  75.         bitsPerSample:4
  76.         samplesPerPixel:3
  77.         hasAlpha:NO
  78.         isPlanar:NO
  79.         colorSpace:NX_RGBColorSpace
  80.         bytesPerRow:0
  81.         bitsPerPixel:16
  82.     ];
  83. #else
  84. //    printf("Initialize 24bit\n");
  85.     bm = [[NXBitmapImageRep alloc] initData:(unsigned char*)FBuffer
  86.         pixelsWide:XRange
  87.         pixelsHigh:YRange
  88.         bitsPerSample:8
  89.         samplesPerPixel:3
  90.         hasAlpha:NO
  91.         isPlanar:NO
  92.         colorSpace:NX_OneIsWhiteColorSpace
  93.         bytesPerRow:0
  94.         bitsPerPixel:32
  95.     ];
  96. #endif
  97. #endif
  98. #endif
  99. #if IMAGE
  100.     { NXSize sz;
  101.     [bm getSize:&sz];
  102.     image=[[NXImage alloc] initSize:&sz];
  103.     if (![image useRepresentation:bm]) printf("Representation error\n");
  104. //    [image setUnique:YES]; /* make caches disjoint */
  105. //    [image setBackgroundColor:NX_COLORBLACK];
  106.     }
  107. #endif
  108.     return self;
  109. }
  110.  
  111. #define Button1Mask 1
  112. #define Button2Mask 2
  113. #define Button3Mask 4
  114. #define ACTIVEBUTTONMASK \
  115.     (NX_MOUSEUPMASK|NX_MOUSEDRAGGEDMASK| \
  116.     NX_RMOUSEUPMASK|NX_RMOUSEDRAGGEDMASK)
  117.  
  118. extern void MouseMove( int status, int dx, int dy );
  119.  
  120. - (BOOL)acceptsFirstMouse
  121. {
  122.     return YES;
  123. }
  124.  
  125. - resetMeter:(int)i
  126. {
  127.     [[meters cellAt:i :0] setStringValue:""];
  128.     return self;
  129. }
  130.  
  131. - setMeter:(int)i value:(Real)t
  132. {
  133.     char buf[32];
  134.  
  135.     sprintf(buf, "%7.4f", t);
  136.     [[meters cellAt:i :0] setStringValue:buf];
  137.     return self;
  138. }
  139.  
  140. - keyDown:(NXEvent *)theEvent
  141. {
  142.     [super keyDown:theEvent];
  143. //    printf("keyDown:\n");
  144.     return self;
  145. }
  146.  
  147. - mouseDown:(NXEvent *)theEvent
  148. {
  149.     int oldMask;
  150.     NXPoint oldMouse, newMouse, dMouse;
  151.     unsigned int status, buttons=0;
  152.     Real t, t0;
  153.  
  154.     // track the mouse until a mouseUp event occurs, updating the display
  155.     // as tracking happens.
  156.  
  157.     if (theEvent->type==NX_LMOUSEDOWN) buttons = Button1Mask;
  158.     else if (theEvent->type==NX_RMOUSEDOWN) buttons = Button2Mask;
  159.     [self lockFocus];
  160.     oldMask = [window addToEventMask:ACTIVEBUTTONMASK];
  161.     
  162.     oldMouse = theEvent->location;
  163.     [self convertPoint:&oldMouse fromView:nil];
  164.     [self setMeter:1 value:0.0];
  165.     t = t0 = realtime();
  166.     while (1) {
  167.     newMouse = theEvent->location;
  168.     [self convertPoint:&newMouse fromView:nil];
  169.     dMouse.x = newMouse.x - oldMouse.x;
  170.     dMouse.y = newMouse.y - oldMouse.y;
  171.     if (dMouse.x != 0.0 || dMouse.y != 0.0) {
  172.         status = (theEvent->flags & (65535<<16)) | buttons;
  173.         MouseMove(status, (int)dMouse.x, -(int)dMouse.y);
  174.         theEvent = [NXApp peekAndGetNextEvent:ACTIVEBUTTONMASK];
  175.         if (!theEvent) {
  176.         RefreshScreen();
  177.         [self setMeter:1 value:realtime()-t0-t];
  178.         t = realtime()-t0;
  179.         }
  180.     } else theEvent = NULL;
  181.     if (!theEvent) theEvent = [NXApp getNextEvent:ACTIVEBUTTONMASK];
  182.     if (theEvent->type==NX_MOUSEUP || theEvent->type==NX_RMOUSEUP) break;
  183.     oldMouse = newMouse;
  184.     }
  185.     
  186.     [self unlockFocus];
  187.     [self resetMeter:1];
  188.     [window setEventMask:oldMask];
  189.     return self;
  190. }
  191.  
  192. - rightMouseDown:(NXEvent *)theEvent
  193. {
  194.     return [self mouseDown:theEvent];
  195. }
  196.  
  197. - superviewSizeChanged:(const NXSize *)oldSize
  198. {
  199.     [super superviewSizeChanged:oldSize];
  200.     XRange = bounds.size.width;
  201.     YRange = bounds.size.height;
  202.     WRange = XRange>>1;
  203.     HRange = YRange>>1;
  204.     Range = MinFun(XRange,YRange);
  205.     printf("Change size to: %d %d\n", XRange, YRange);
  206.     ReDrawFlag |= RFReSize;
  207.     RefreshScreen();
  208.     return self;
  209. }
  210.  
  211. int drawCount=0;
  212.  
  213. - drawSelf:(const NXRect *) rects :(int)count
  214.  {
  215. #if IMAGE
  216.     NXPoint origin = {0.0,0.0};
  217.  
  218.     [image recache];
  219.     [image composite:NX_SOVER toPoint:&origin];
  220. #else
  221.     [bm draw];
  222. #endif
  223.     drawCount++;
  224.     return self;
  225.  }
  226.  
  227. - (BOOL)openFile:(const char *)fn
  228. {
  229.     if( fn && FetchFile(FileFormat,True, (char *)fn) )
  230.     {   
  231.     ReDrawFlag |= RFRefresh | RFColour;
  232.     if( InfoBondCount < 1 ) EnableBackbone(CylinderFlag,80);
  233.     else EnableWireframe(CylinderFlag,80);
  234.     CPKColourAttrib();
  235.     RefreshScreen();
  236.     } else {
  237.     NXRunAlertPanel(NULL,"Couldn't get molecule from %s", NULL,NULL,NULL, fn);
  238.     fn = NULL;
  239.     }
  240.     if( !CommandActive ) ResetCommandLine(0);
  241.     [self update];
  242.     return fn!=0;
  243. }
  244.  
  245. - open:sender
  246.  {
  247. //    const char *const types[] = {{"pdb"}, (const char *) NULL};
  248.     id pan = [OpenPanel new];
  249.     const char *const *filenames;
  250.     char filename[FILENAME_MAX];
  251.  
  252.     if (![pan runModal]) return NO;
  253.     if ((filenames = [pan filenames]) == NULL) return NO;
  254.     sprintf(filename,"%s/%s", [pan directory], filenames[0]);
  255.     [self openFile:filename];
  256.     return self;
  257. }
  258.  
  259. - update
  260. {
  261.     RefreshScreen();
  262.     return self;
  263. }
  264.  
  265. - setText:aText
  266. {
  267.     text = aText;
  268.     [text setDelegate:self];
  269.     [text setMonoFont:FALSE];
  270.     [text setCharFilter:NXFieldFilter];
  271.     ras_init();
  272.     FBClear = False;
  273.     ReDrawFlag |= RFRefresh;
  274.     RefreshScreen();
  275.     if (text) [[meters window] setNextResponder:text];
  276.     [self setNextResponder:text];
  277.     [window makeFirstResponder:self];
  278.     [window makeKeyAndOrderFront:self];
  279.     return self;
  280. }
  281.  
  282. - text
  283. {
  284.     return text;
  285. }
  286.  
  287. - setMeters:aMatrix;
  288. {
  289.     meters = aMatrix;
  290.     if (text) [[meters window] setNextResponder:text];
  291.     return self;
  292. }
  293.  
  294. - meters
  295. {
  296.     return meters;
  297. }
  298.  
  299. - break
  300. {
  301.     int len;
  302.     
  303.     line[lineIndex] = '\0';
  304.     len = [text charLength];
  305.     [text setSel:len :len];
  306.     [text setSelFontStyle:NX_UNBOLD];
  307.     [text replaceSel:line];
  308.     [text scrollSelToVisible];
  309.     lineIndex = 0;
  310.     return self;
  311. }
  312.  
  313. - putChar:(char)ch
  314. {
  315.     line[lineIndex++] = ch;
  316.     if (ch=='\n' || lineIndex>=linebuflength-1) [self break];
  317.     return self;
  318. }
  319.  
  320. - show:(char *)str
  321. {
  322.     while(*str) [self putChar:*(str++)];
  323.     [self break];
  324.     return self;
  325. }
  326.  
  327. // Application's delegate methods
  328.  
  329. - (BOOL)appAcceptsAnotherFile:sender
  330. {
  331.   return YES;
  332. }
  333.  
  334. - (int)app:sender openFile:(const char *)filename type:(const char *)type
  335. {
  336.     [self close:sender];
  337.     return [self openFile:filename];
  338. }
  339.  
  340. // Text's delegate method
  341.  
  342. - textDidEnd:sender endChar:(unsigned short)whyEnd
  343. {
  344.     NXSelPt start, end;
  345.     int len, ln, cp;
  346.     char *buf;
  347.     
  348.     [window makeFirstResponder:text];
  349.     if (whyEnd==NX_RETURN) {
  350.     [sender getSel:&start :&end];
  351.     ln = [sender lineFromPosition:end.cp-1];
  352.     cp = [sender positionFromLine:ln];
  353.     len = end.cp-cp;
  354.     buf = malloc(len+2);
  355.     [sender getSubstring:buf start:cp length:len];
  356.     ln = 0;
  357.     if (strncmp(buf, CurPrompt, strlen(CurPrompt))==0) ln+=strlen(CurPrompt);
  358.     [text setSel:cp+ln :end.cp];
  359.     [text setSelFontStyle:NX_BOLD];
  360.     buf[len] = '\n';
  361.     buf[len+1] = '\0';
  362.     [self putChar:'\n'];
  363.     for (cp=ln; buf[cp]; cp++)
  364.         if(ProcessCharacter(buf[cp]) && ProcessCommand()) exit(0);
  365.     if( !CommandActive ) ResetCommandLine(0);
  366.     RefreshScreen();
  367.     free(buf);
  368.     }
  369.     return self;
  370. }
  371.  
  372. - setValue:sender
  373. {
  374.     switch([sender selectedRow]){
  375.     case 0: ColourDepth = (int)[[sender cellAt:0 :0] floatValue];
  376.         printf("ColourDepth: %d\n", ColourDepth);
  377.         break;
  378.     case 1: Ambient = [[sender cellAt:1 :0] floatValue];
  379.         printf("Ambient: %g\n", Ambient);
  380.         break;
  381.     default: ;
  382.     }
  383.     return self;
  384. }
  385.  
  386. - testPattern:sender
  387. {
  388.     int i, j, k, dn;
  389.     Real t;
  390.     Pixel c;
  391.     NXEvent theEvent;
  392.  
  393.     printf("Test pattern\n");
  394.     ClearBuffers();
  395.     dn = YRange/(LastShade+3);
  396.     for (i=0; i<XRange; i++) {
  397.     c = 1<<(i*32/(XRange+1));
  398.     for (j=0; j<dn; j++) FBuffer[j*XRange+i] = c;
  399.     c = Lut[i*LutSize/(XRange+1)];
  400.     for (j=dn; j<2*dn; j++) FBuffer[j*XRange+i] = c;
  401.     for (k=0; k<LastShade; k++) {
  402.         c = Lut[Shade2Colour(k)+i*ColourDepth/(XRange+1)];
  403.         for (j=0; j<dn && j<YRange-dn; j++) FBuffer[((2+k)*dn+j)*XRange+i] = c;
  404.     }
  405.     }
  406.     [self setMeter:0 value:0.0];
  407.     [self setMeter:3 value:0.0];
  408.     t = realtime();
  409.     for (k=0; ![NXApp peekNextEvent:NX_KEYDOWNMASK into:&theEvent]; k++) {
  410.     for (i=0; i<XRange; i++) {
  411.         c = Lut[LutSize-1-((i+k*XRange/32)%XRange)*LutSize/(XRange+1)];
  412.         for (j=YRange-dn; j<YRange; j++) FBuffer[j*XRange+i] = c;
  413.     }
  414. //    [self display];
  415.     TransferImage();
  416.     if (k%10==0) {
  417.         [self setMeter:0 value:10.0/(realtime()-t)];
  418.         [self setMeter:3 value:(Real)drawCount];
  419.         t = realtime();
  420.     }
  421.     }
  422.     [self resetMeter:0];
  423.     [self resetMeter:3];
  424.     FBClear = False;
  425.     ReDrawFlag |= RFRefresh;
  426.     RefreshScreen();
  427.     return self;
  428. }
  429.  
  430. - testRotate:sender;
  431. {
  432.     int k;
  433.     Real t, tf;
  434.     NXEvent theEvent;
  435.  
  436.     [self setMeter:0 value:0.0];
  437.     [self setMeter:1 value:0.0];
  438.     [self setMeter:3 value:0.0];
  439.     t = tf = realtime();
  440.     for (k=0; ![NXApp peekNextEvent:NX_KEYDOWNMASK|NX_MOUSEDOWNMASK
  441.     into:&theEvent]; k++) {
  442.         MouseMove( Button1Mask, 5, 0 );
  443.         RefreshScreen();
  444.         [self setMeter:1 value:realtime()-t];
  445.         t = realtime();
  446.         if (k%10==0) {
  447.         [self setMeter:0 value:10.0/(realtime()-tf)];
  448.         [self setMeter:3 value:drawCount];
  449.         tf = realtime();
  450.         }
  451.     }
  452.     [self resetMeter:0];
  453.     [self resetMeter:1];
  454.     [self resetMeter:3];
  455.     return self;
  456. }
  457.  
  458. - close:sender
  459. {
  460.     ZapDatabase();
  461.     return [self update];
  462. }
  463.  
  464. - wireFrame: sender
  465. {
  466.     DisableSpacefill();
  467.     EnableWireframe(WireFlag,0);
  468.     SetRibbonStatus(False,0,0);
  469.     DisableBackbone();
  470.     ReDrawFlag |= RFRefresh;
  471.     return [self update];
  472. }
  473.  
  474. - backBone: sender
  475. {
  476.     DisableSpacefill();
  477.     DisableWireframe();
  478.     SetRibbonStatus(False,0,0);
  479.     EnableBackbone(CylinderFlag,80);
  480.     ReDrawFlag |= RFRefresh;
  481.     return [self update];
  482. }
  483.  
  484. - sticks: sender
  485. {
  486.     DisableSpacefill();
  487.     if( MainAtomCount<256 )
  488.     {   EnableWireframe(CylinderFlag,40);
  489.     } else EnableWireframe(CylinderFlag,80);
  490.     SetRibbonStatus(False,0,0);
  491.     ReDrawFlag |= RFRefresh;
  492.     DisableBackbone();
  493.     return [self update];
  494. }
  495.  
  496. - spheres: sender
  497. {
  498.     SetVanWaalRadius();
  499.                                 SetVanWaalRadius();
  500.                                 DisableWireframe();
  501.                                 SetRibbonStatus(False,0,0);
  502.                                 DisableBackbone();
  503.                                 ReDrawFlag |= RFRefresh;
  504.     return [self update];
  505. }
  506.  
  507. - ballAndStick: sender
  508. {
  509.                                 SetRadiusValue(120);
  510.                                 EnableWireframe(CylinderFlag,40);
  511.                                 SetRibbonStatus(False,0,0);
  512.                                 DisableBackbone();
  513.                                 ReDrawFlag |= RFRefresh;
  514.     return [self update];
  515. }
  516.  
  517.  
  518. - ribbons: sender
  519. {
  520.                                 DisableSpacefill();
  521.                                 DisableWireframe();
  522.                                 SetRibbonStatus(True,RibbonFlag,0);
  523.                                 DisableBackbone();
  524.                                 ReDrawFlag |= RFRefresh;
  525.     return [self update];
  526. }
  527.  
  528. - strands: sender
  529. {
  530.                                 DisableSpacefill();
  531.                                 DisableWireframe();
  532.                                 SetRibbonStatus(True,StrandFlag,0);
  533.                                 DisableBackbone();
  534.                                 ReDrawFlag |= RFRefresh;
  535.     return [self update];
  536. }
  537.  
  538. - cartoons: sender
  539. {
  540.                                 DisableSpacefill();
  541.                                 DisableWireframe();
  542.                                 SetRibbonCartoons();
  543.                                 DisableBackbone();
  544.                                 ReDrawFlag |= RFRefresh;
  545.     return [self update];
  546. }
  547.  
  548. - mono: sender
  549. {
  550.     MonoColourAttrib(255,255,255);
  551.     ReDrawFlag |= RFColour;
  552.     return [self update];
  553. }
  554.  
  555. - cpk: sender
  556. {
  557.     CPKColourAttrib();
  558.     ReDrawFlag |= RFColour;
  559.     return [self update];
  560. }
  561.  
  562. - shapely: sender
  563. {
  564.     ShapelyColourAttrib();
  565.     ReDrawFlag |= RFColour;
  566.     return [self update];
  567. }
  568.  
  569. - group: sender
  570. {
  571.     ScaleColourAttrib( GroupAttr );
  572.     ReDrawFlag |= RFColour;
  573.     return [self update];
  574. }
  575.  
  576. - chain: sender
  577. {
  578.     ScaleColourAttrib( ChainAttr );
  579.     ReDrawFlag |= RFColour;
  580.     return [self update];
  581. }
  582.  
  583. - temp: sender
  584. {
  585.     ScaleColourAttrib( TempAttr );
  586.     ReDrawFlag |= RFColour;
  587.     return [self update];
  588. }
  589.  
  590. - struct: sender
  591. {
  592.     StructColourAttrib();
  593.     ReDrawFlag |= RFColour;
  594.     return [self update];
  595. }
  596.  
  597. - user: sender
  598. {
  599.     UserMaskAttrib(MaskColourFlag);
  600.     ReDrawFlag |= RFColour;
  601.     return [self update];
  602. }
  603.  
  604. - slabbing: sender
  605. {
  606.     ReDrawFlag |= RFRefresh;
  607.     UseSlabPlane = !UseSlabPlane;
  608.     if( UseSlabPlane ) UseShadow = False;
  609.     return [self update];
  610. }
  611.  
  612. - hydrogens: sender
  613. {
  614.     int mask = NormAtomFlag;
  615.     if( HetaGroups ) mask |= HeteroFlag;
  616.     Hydrogens = !Hydrogens;
  617.     ReDrawFlag |= RFRefresh;
  618.     if( Hydrogens ) SelectZone(mask|HydrogenFlag);
  619.     else RestrictZone(mask);
  620.     return [self update];
  621. }
  622.  
  623. - hetero: sender
  624. {
  625.     int mask = NormAtomFlag;
  626.     if( Hydrogens ) mask |= HydrogenFlag;
  627.     HetaGroups = !HetaGroups;
  628.     ReDrawFlag |= RFRefresh;
  629.     if( HetaGroups ) SelectZone(mask|HeteroFlag);
  630.     else RestrictZone(mask);
  631.     return [self update];
  632. }
  633.  
  634. - specular: sender
  635. {
  636.     FakeSpecular = !FakeSpecular;
  637.     ReDrawFlag |= RFColour;
  638.     return [self update];
  639. }
  640.  
  641. - shadows: sender
  642. {
  643.     ReDrawFlag |= RFRefresh;
  644.     UseShadow = !UseShadow;
  645.     if( UseShadow ) {
  646.     ReviseInvMatrix();
  647.     VoxelsClean = False;
  648.     UseSlabPlane = False;
  649.     ReAllocBuffers();
  650.     }
  651.     return [self update];
  652. }
  653.  
  654. - stereo: sender
  655. {
  656.                                 if( UseStereo )
  657.                                 {   SetStereoMode(False);
  658.                                 } else SetStereoMode(True);
  659.                                 ReDrawFlag |= RFRefresh;
  660.     return [self update];
  661. }
  662.  
  663. - labels: sender
  664. {
  665.                                 LabelOptFlag = !LabelOptFlag;
  666.                                 DefaultLabels(LabelOptFlag);
  667.                                 ReDrawFlag |= RFRefresh;
  668.     return [self update];
  669. }
  670.  
  671. - export: sender
  672. {
  673.     ResetCommandLine(3);
  674.     return self;
  675. }
  676.  
  677. - help: sender
  678. {
  679.     return self;
  680. }
  681.  
  682. @end
  683.