home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWSimpleMovieView.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  28.2 KB  |  1,034 lines
  1. // WWSimpleMovieView is exactly that: a pretty simple view for showing movies.
  2. // It has a bunch of different behaviors to do all the obvious things:
  3. // all of the following do it at some given frames/second:
  4. // - plays movie either from the beginning each time or bounces
  5. //   - plays movie continuously
  6. //   - starts playing movie once when clicked, stops when clicked
  7. //   - plays movie when the mouse is over it; resets when the mouse leaves
  8.  
  9. // one thing that would be handy is if the view had a notion of a
  10. //control panel for itself.  It might have two outlets, one which is the
  11. //controlPanelView, and some other view (say, a WW3DWell) could come
  12. //along and switch that view in so that the view might have some visible
  13. //control.  This is sort of a bug of NS; no notion of objects having
  14. //control panels (i.e. the live version of an inspector).
  15.  
  16. #import "WWSimpleMovieView.h"
  17. #import "aspectRatios.h"
  18. // for IB protocols
  19. #import <apps/InterfaceBuilder.h>
  20.  
  21. // for mkdir()
  22. #import <sys/types.h>
  23. #import <sys/stat.h>
  24.  
  25.  
  26. @implementation WWSimpleMovieView
  27.  
  28.  
  29. #define WW_BOTTOMALIGNED  0
  30. #define WW_TOPALIGNED     1
  31.  
  32.  
  33. /*
  34. ==========================================================================
  35. subext() -- Remove extension from fname only if it is there.
  36.  
  37. ==========================================================================
  38. */
  39. static char 
  40. *subext(fname, ext)
  41. register char *fname, *ext;
  42. {
  43.   int fl, el;
  44.  
  45.     for ( fl = strlen(fname), el = strlen(ext);
  46.         --el > -1 && --fl > -1 && fname[fl] == ext[el]; )
  47.         ;
  48.     if (el == -1) 
  49.     {  fname[fl] = '\0';
  50.     }
  51.     return(fname);
  52. }
  53.  
  54.  
  55. /*
  56. ==========================================================================
  57. basename() -- deletes any prefix ending in `/' and the suffix.
  58.  
  59. ==========================================================================
  60. */
  61. static char 
  62. *basename(str, sfx, dest)
  63. char *str, *sfx, *dest;
  64. {
  65. char temp[1024];
  66. char *p, *p1;
  67. char *subext();
  68.  
  69.     p = p1 = temp;
  70.     strcpy(p, str);
  71.     while (*p) 
  72.     {  if (*p++ == '/') 
  73.            {  p1 = p;
  74.        }
  75.     }
  76.     strcpy (dest, subext(p1, sfx));
  77.     return(dest);
  78. }
  79.  
  80. + initialize { return [WWSimpleMovieView setVersion:3], self; }
  81.  
  82.  
  83. - showFrameAndIncrement:sender
  84. {
  85.    if (drawCorrectly && (alpha < 1.0))
  86.    {  clearTheView = YES; [self display];
  87.       clearTheView = NO;  [window display];
  88.    }
  89.    else
  90.    {  clearTheView = NO;  [self display];
  91.    }
  92.    NXPing();
  93.    if (!stationaryFrameTE)  // if we're not really playing, we're outta here
  94.    {  return self;
  95.    }
  96.  
  97.    // check to see if we're at the last frame of the sequence
  98.    if (goingForward)
  99.    {  if (currentFrameIndex == (frameCount - 1)) // we're at the end!
  100.       {  if (loop)
  101.          {  currentFrameIndex = 0;
  102.          }
  103.          else
  104.          {  currentFrameIndex--;
  105.             goingForward = NO;
  106.          }
  107.       }
  108.       else // more frames to go...
  109.       {  currentFrameIndex++;
  110.       }
  111.    }
  112.    else // going backwards; 0 is the end frame
  113.    {  if (!currentFrameIndex) // we're at the end!
  114.       {  if (loop)  // no way; we don't backwards if we're looping, doofus...
  115.          {  NXLogError("shouldn't be here, pal.\n");
  116.          }
  117.          goingForward = YES;
  118.          currentFrameIndex++;
  119.       }
  120.       else // keep counting down
  121.       {  currentFrameIndex--;
  122.       }
  123.    }
  124.  
  125.    movieImage = [imageList objectAt:currentFrameIndex];
  126.    return self;
  127. }
  128.  
  129. void nextFrame(DPSTimedEntry teNumber, double now, void *userData)
  130. {
  131.   id  myObj = (id)userData;
  132.  
  133.   [myObj showFrameAndIncrement:nil];
  134.   return ;
  135. }
  136.  
  137.  
  138.  
  139. - beginStationaryBehavior
  140. {
  141.   // make sure that I have some images in my list
  142.   if (![imageList count])
  143.   {  return self;
  144.   }
  145.   goingForward = YES;
  146.   stationaryFrameTE = DPSAddTimedEntry(frameTimeIncr, 
  147.                        (DPSTimedEntryProc)nextFrame, 
  148.                        self, NX_MODALRESPTHRESHOLD);
  149.   if (stationaryBehavior == WW_PLAY_MOUSE_IN)
  150.   {  [self setMyTrackingRect:YES];
  151.   }
  152.   return self;
  153. }
  154.  
  155. - endStationaryBehavior
  156. {
  157.   if (stationaryFrameTE)
  158.   {  DPSRemoveTimedEntry(stationaryFrameTE);
  159.      stationaryFrameTE = 0;
  160.   }
  161.  
  162.   return self;
  163. }
  164.  
  165. - copyFromZone:(NXZone *)zone
  166. {
  167.   id newCopy = [super copyFromZone:zone];
  168.  
  169.   if (frameCount)
  170.   {  // rather than copy through the movie data, we'll just 
  171.      // mark both this instance and the new one as using
  172.      // a shared movie
  173.      [self setMovieIsShared:YES];
  174.      [newCopy setMovieIsShared:YES];
  175.   }
  176.  
  177.   return newCopy;
  178. }
  179.  
  180. - free
  181. {
  182.   if (controlPanel)
  183.   {  [controlPanel setFreeWhenClosed:NO];
  184.      [controlPanel close];
  185.      [controlPanel free];
  186.      controlPanel = nil;
  187.   }
  188.   [self endStationaryBehavior];
  189.   if (stationaryBehavior == WW_PLAY_MOUSE_IN)
  190.   {  [self setMyTrackingRect:NO];
  191.   }
  192.  
  193.   if (!movieIsShared)
  194.   {  [imageList freeObjects];
  195.   }
  196.   [imageList free];
  197.  
  198.   if (!imageIsShared)
  199.   {  [image free];
  200.   }
  201.  
  202.   return [super free];
  203. }
  204.  
  205. - initFrame:(const NXRect *)r 
  206. {
  207.    [super initFrame:r];
  208.    backgroundColor = NXConvertRGBToColor(0.96, 1.0, 0.6);
  209.    borderType = 0;
  210.    alpha = 1.0;
  211.    image = nil;
  212.    movieImage = nil;
  213.    imageList = [[List alloc] init];
  214.    imageIsShared = NO;
  215.    movieIsShared = NO;
  216.    frameCount = 0;
  217.    aspectRatioType = WW_ASPECT_DONT_CARE;
  218.    aspectRatio = 1.0;
  219.    scaleToFit = NO;
  220.    imageUnder = NO;
  221.    horizontalLayoutType = NX_LEFTALIGNED;
  222.    verticalLayoutType = WW_BOTTOMALIGNED;
  223.    fps = 15.0;
  224.    frameTimeIncr = 1.0/fps;
  225.    loop = NO; // in other words, "breathe"
  226.    stationaryBehavior = WW_PLAY_MOUSE_CLICK;
  227.    stationaryFrameTE = (DPSTimedEntry)0;
  228.    sink = NO;
  229.    source = NO;
  230.    archiveImageData = YES;
  231.    archiveMovieData = YES;
  232.    trackingRect = 0;
  233.    drawCorrectly = YES;
  234.    controlPanel = nil;
  235.  
  236.    if (stationaryBehavior == WW_PLAY_CONTINUOUS)
  237.    {  [self beginStationaryBehavior];
  238.    }
  239.  
  240.    return self;
  241. }
  242.  
  243. - awake
  244. {
  245.    [super awake];
  246.    stationaryFrameTE = (DPSTimedEntry)0;
  247.    trackingRect = 0;
  248.    if ([NXApp conformsTo:@protocol(IB)])  // what a hacque!! (def: "hacqe: a particularly baroque (in both senses of the word...) hack")
  249.    {  [self perform:@selector(awakeFromNib) with:nil afterDelay:0.01 cancelPrevious:NO];
  250.       // the reason we do this is because I'm not certain that if we awake in IB our "window" will be set yet.
  251.    }
  252.    currentFrameIndex = 0;
  253.    frameCount = [imageList count];
  254.    controlPanel = nil;
  255.    if (frameCount)
  256.    {  movieImage = [imageList objectAt:currentFrameIndex];
  257.       if (stationaryBehavior == WW_PLAY_CONTINUOUS)
  258.       {  [self beginStationaryBehavior];
  259.       }
  260.    }
  261.  
  262.    return self;
  263. }
  264.  
  265. - awakeFromNib
  266. {
  267.   if (stationaryBehavior == WW_PLAY_MOUSE_IN)
  268.   {  [self setMyTrackingRect:YES];
  269.   }
  270.   return self;
  271. }
  272.  
  273.  
  274. #define EPSILON 10
  275.  
  276. - sizeTo:(NXCoord)width :(NXCoord)height
  277. {
  278.   // don't want to make it too small...
  279.   if (width < EPSILON) return nil;
  280.   if (height < EPSILON) return nil;
  281.  
  282.  
  283.   // let's say it comes in at 100, 100 and you're supposed to be constrained to 4:3
  284.   // you don't want it to get bigger than 100, 100, so... you frob the width, not the height
  285.   switch (aspectRatioType)
  286.   {  case WW_ASPECT_DONT_CARE:
  287.             aspectRatio = width/height;
  288.             break;
  289.      case WW_ASPECT_NTSC:  // 1.33:1
  290.             height = width/1.33;
  291.             aspectRatio = 1.33;
  292.             break;
  293.      case WW_ASPECT_SQUARE:  // 1:1
  294.             if (width < height)
  295.         {  height = width;
  296.         }
  297.         else
  298.         {  width = height;
  299.         }
  300.             aspectRatio = 1.0;
  301.             break;
  302.      case WW_ASPECT_CUSTOM:  //aspectX:aspectY
  303.             if (aspectRatio < 1.0)
  304.         {  width = height * aspectRatio;
  305.         }
  306.         else
  307.         {  height = width/aspectRatio;
  308.         }
  309.             break;
  310.      default:
  311.             NXLogError("unknown aspect ratio type: %d", aspectRatioType);
  312.             break;
  313.   }
  314.  
  315.   [super sizeTo:width :height];
  316.   [self display];
  317.   if (stationaryBehavior == WW_PLAY_MOUSE_IN)
  318.   {  [self setMyTrackingRect:YES];
  319.   }
  320.  
  321.   return self;
  322. }
  323.  
  324. - setBorderType:(int)newBorderType { borderType = newBorderType; return self; }
  325. - (int)borderType { return borderType; }
  326.  
  327. - setFPS:(float)newFPS { fps = newFPS; frameTimeIncr = 1.0/fps; return self; }
  328. - (float)fps { return fps; }
  329.  
  330. //
  331. - sizeToImage:sender 
  332. {
  333.    NXSize s;
  334.  
  335.  
  336.    if (image)
  337.    {  [image getSize:&s];
  338.       [self sizeTo:s.width :s.height];
  339.    }
  340.    return self;
  341. }
  342.  
  343. - sizeToMovie:sender 
  344. {
  345.    NXSize s;
  346.  
  347.  
  348.    if (movieImage)
  349.    {  [movieImage getSize:&s];
  350.       [self sizeTo:s.width :s.height];
  351.    }
  352.    return self;
  353. }
  354.  
  355. - setScaleToFit:(BOOL)flag { scaleToFit = flag; return self; }
  356. - (BOOL)scaleToFit { return scaleToFit; }
  357. - setImageUnder:(BOOL)flag { imageUnder = flag; return self; }
  358. - (BOOL)imageUnder { return imageUnder; }
  359.  
  360. - (int)aspectRatioType { return aspectRatioType; }
  361. - (float)aspectRatio { return aspectRatio; }
  362. - setAspectRatioFromMatrix:sender
  363. {
  364.   NXRect  newRect;
  365.  
  366.  
  367.   [self getFrame:&newRect];
  368.   aspectRatioType = [[sender selectedCell] tag];
  369.   switch (aspectRatioType)
  370.   {  case WW_ASPECT_DONT_CARE:
  371.             break;
  372.      case WW_ASPECT_NTSC:  // 1.33:1
  373.             newRect.size.height = newRect.size.width/1.33;
  374.             break;
  375.      case WW_ASPECT_SQUARE:  // 1:1
  376.             if (newRect.size.width < newRect.size.height)
  377.             {  newRect.size.height = newRect.size.width;
  378.         }
  379.         else
  380.         {  newRect.size.width = newRect.size.height;
  381.         }
  382.             break;
  383.      case WW_ASPECT_CUSTOM:  //aspectX:aspectY
  384.             if (aspectRatio < 1.0)
  385.         {  newRect.size.width = newRect.size.height * aspectRatio;
  386.         }
  387.         else
  388.         {  newRect.size.height = newRect.size.width/aspectRatio;
  389.         }
  390.             break;
  391.      default:
  392.             NXLogError("unknown aspect ratio type: %d", aspectRatioType);
  393.             break;
  394.   }
  395.   [self sizeTo:newRect.size.width :newRect.size.height];
  396.  
  397.   return self;
  398. }
  399. //
  400. - setAspectRatio:sender
  401. {
  402.   NXRect  newRect;
  403.  
  404.  
  405.   [self getFrame:&newRect];
  406.   aspectRatio = [sender floatValue];
  407.  
  408.   if (aspectRatioType != WW_ASPECT_CUSTOM)
  409.   {  return self;
  410.   }
  411.   if (aspectRatio < 1.0)
  412.   {  newRect.size.width = newRect.size.height * aspectRatio;
  413.   }
  414.   else
  415.   {  newRect.size.height = newRect.size.width/aspectRatio;
  416.   }
  417.   [self sizeTo:newRect.size.width :newRect.size.height];
  418.  
  419.   return self;
  420. }
  421. //
  422. - setHorizontalLayoutFromMatrix:sender  {  horizontalLayoutType = [[sender selectedCell] tag];  return self; }
  423. - (int)horizontalLayoutType { return horizontalLayoutType; }
  424.  
  425. - setVerticalLayoutFromMatrix:sender  {  verticalLayoutType = [[sender selectedCell] tag];  return self; }
  426. - (int)verticalLayoutType { return verticalLayoutType; }
  427.  
  428.  
  429. - (NXColor) backgroundColor     { return backgroundColor; }
  430. - setBackgroundColor:(NXColor)c { return backgroundColor = c, self; }
  431. - (float) alpha            { return alpha; }
  432. - setBackgroundAlpha:(float)n    { return alpha = n, self; }
  433.  
  434. - (int)stationaryBehavior    { return stationaryBehavior; }
  435. - setStationaryBehavior:(int)n    
  436. {  
  437.   [self endStationaryBehavior];
  438.   stationaryBehavior = n;
  439.   if (stationaryBehavior == WW_PLAY_CONTINUOUS)
  440.   {  [self beginStationaryBehavior];
  441.   }
  442.   if (stationaryBehavior == WW_PLAY_MOUSE_IN)
  443.   {  [self setMyTrackingRect:YES];
  444.   }
  445.   return self; 
  446. }
  447. - setStationaryBehaviorFromMatrix:sender 
  448. { 
  449.   [self setStationaryBehavior:[[sender selectedCell] tag]]; 
  450.   return self; 
  451. }
  452.  
  453. - setLoop:(BOOL)n { loop = n; return self; }
  454. - (BOOL)loop { return loop; }
  455.  
  456. - setArchiveImageData:(BOOL)n { archiveImageData = n; return self; }
  457. - (BOOL)archiveImageData { return archiveImageData; }
  458.  
  459. - setArchiveMovieData:(BOOL)n { archiveMovieData = n; return self; }
  460. - (BOOL)archiveMovieData { return archiveMovieData; }
  461.  
  462. - setDrawCorrectly:(BOOL)n { drawCorrectly = n; return self; }
  463. - (BOOL)drawCorrectly { return drawCorrectly; }
  464.  
  465. - (int)frameCount { return frameCount; }
  466.  
  467. - setImageIsShared:(BOOL)flag { imageIsShared = flag; return self; } 
  468. - setMovieIsShared:(BOOL)flag { movieIsShared = flag; return self; } 
  469.  
  470. - removeMovie:sender
  471. {
  472.   if (!movieIsShared)
  473.   {  [imageList freeObjects];
  474.      movieImage = nil;
  475.   }
  476.   else
  477.   {  [imageList empty];
  478.      movieImage = nil;
  479.   }
  480.   return self;
  481.   
  482. }
  483.  
  484. - setAnimDir:(const char *)filename 
  485. {
  486.    BOOL  done = NO;
  487.    char  theBaseName[MAXPATHLEN+1], 
  488.          tiffFileName[MAXPATHLEN+1], 
  489.          *animSuffixPtr;
  490.    int   frameIndex = 1;// remind me to slap Keith next time I see him...
  491.  
  492.  
  493.    if (filename && *filename)
  494.    {  if (!movieIsShared)
  495.       {  [imageList freeObjects];
  496.       }
  497.       movieImage = nil;
  498.       done = NO;
  499.       animSuffixPtr=rindex(filename, '.');
  500.       if (animSuffixPtr && strcmp(animSuffixPtr, ".anim"))
  501.       {  NXLogError("the file %s doesn't end in anim, dude!\n", filename);
  502.          return nil;
  503.       }
  504.       basename(filename, ".anim", theBaseName);  
  505.       while (!done)
  506.       {  sprintf(tiffFileName, "%s/%s.%d.tiff", filename, theBaseName, frameIndex);
  507.          // does the file exist?
  508.          if (access(tiffFileName, R_OK) == -1) 
  509.          {  done = YES;  // nope; we're outta here
  510.          }
  511.          else
  512.          {  movieImage = [NXImage findImageNamed:tiffFileName];
  513.             if (!movieImage) 
  514.             {  movieImage = [[NXImage alloc] init];
  515.                if (archiveMovieData)
  516.                {  [movieImage setDataRetained:YES];
  517.                }
  518.                if (![movieImage loadFromFile:tiffFileName])  
  519.                {  NXLogError("unable to load image from file <%s>\n", tiffFileName);
  520.                   done = YES; // guess the last image was bad; a common occurrence when the anim is still being generated...
  521.                   }
  522.             }
  523.             [imageList insertObject:movieImage at:(frameIndex - 1)]; // I really gotta whap Keith; 1 based indices; jeez...
  524.             frameIndex++;
  525.          }
  526.       }
  527.    }
  528.    frameCount = [imageList count];
  529.    currentFrameIndex = 0;
  530.    movieImage = [imageList objectAt:currentFrameIndex];
  531.    clearTheView = YES; [self display];
  532.    clearTheView = NO;  [window display];
  533.    NXPing();
  534.    if (stationaryBehavior == WW_PLAY_CONTINUOUS)
  535.    {  [self beginStationaryBehavior];
  536.    }
  537.  
  538.    return self;
  539. }
  540.  
  541.  
  542.  
  543. - removeImage:sender
  544. {
  545.    if (!imageIsShared)
  546.    {  [image free];
  547.    }
  548.    image = nil;
  549.    return self;
  550. }
  551.  
  552. - setImageFile:(const char *)filename 
  553. {
  554.     if (!imageIsShared)
  555.     {  [image free];
  556.     }
  557.     image = nil;
  558.     if (filename && *filename)
  559.     { image = [NXImage findImageNamed:filename];
  560.       if (!image) 
  561.       {  image = [[NXImage alloc] init];
  562.          [image setDataRetained:YES];
  563.          if (![image loadFromFile:filename])
  564.          {  NXLogError("unable to load image from file <%s>\n", filename);
  565.             return nil; 
  566.       }
  567.       }
  568.     }
  569.     clearTheView = YES; [self display];
  570.     clearTheView = NO;  [window display];
  571.     NXPing();
  572.     return self;
  573. }
  574.  
  575. - setImage:i  
  576. {  
  577.    if (!imageIsShared)
  578.    {  [image free];
  579.    }
  580.    image = i; 
  581.    clearTheView = YES; [self display];
  582.    clearTheView = NO;  [window display];
  583.    NXPing();
  584.    return self; 
  585. }
  586. - image { return image; }
  587.  
  588. - movieImage { return movieImage; }
  589.  
  590.  
  591. - drawSelf:(const NXRect *)theRect :(int)count
  592. {
  593.   NXPoint  p = {0.0, 0.0};
  594.   NXSize   imageSize, movieSize;
  595.  
  596.  
  597.   if (clearTheView)  
  598.   {  NXSetColor(backgroundColor);
  599.      PSsetalpha(0.0);
  600.      PScompositerect(theRect->origin.x, theRect->origin.y, 
  601.                theRect->size.width, theRect->size.height,
  602.                NX_SOVER);
  603.      return self;
  604.   }
  605.  
  606.   NXSetColor(backgroundColor);
  607.   if (!frameCount || drawCorrectly) // if there's no movie or we're being anal, use my alpha value
  608.   {  PSsetalpha(alpha);
  609.   }
  610.   else // otherwise, make it opaque, since the other views in the window aren't being redrawn too
  611.   {  PSsetalpha(1.0);
  612.   }
  613.  
  614.   PScompositerect(theRect->origin.x, theRect->origin.y, 
  615.               theRect->size.width, theRect->size.height,
  616.             NX_SOVER);
  617.  
  618.   [image getSize:&imageSize];
  619.   [movieImage getSize:&movieSize];
  620.  
  621.   switch (verticalLayoutType)
  622.   {  case WW_BOTTOMALIGNED:
  623.           p.y = 0.0;
  624.       break;
  625.      case WW_TOPALIGNED:
  626.           if (imageSize.height > movieSize.height)
  627.           {  p.y = theRect->size.height - imageSize.height;
  628.        }
  629.           else
  630.           {  p.y = theRect->size.height - movieSize.height;
  631.        }
  632.        break;
  633.     default:
  634.           p.y = 0.0;
  635.       break;
  636.   }
  637.   switch (horizontalLayoutType)
  638.   {  case NX_LEFTALIGNED:
  639.           p.x = 0.0;
  640.       break;
  641.      case NX_RIGHTALIGNED:
  642.           if (imageSize.width > movieSize.width)
  643.           {  p.x = theRect->size.width - imageSize.width;
  644.       }
  645.       else
  646.           {  p.x = theRect->size.width - movieSize.width;
  647.       }
  648.        break;
  649.      case NX_CENTERED:
  650.           if (imageSize.width > movieSize.width)
  651.           {  if (theRect->size.width > imageSize.width)
  652.              {  p.x = (theRect->size.width - imageSize.width)/2.0;
  653.              }
  654.              else
  655.              {  p.x = 0.0;
  656.              }
  657.       }
  658.           else
  659.           {  if (theRect->size.width > movieSize.width)
  660.              {  p.x = (theRect->size.width - movieSize.width)/2.0;
  661.              }
  662.              else
  663.              {  p.x = 0.0;
  664.              }
  665.       }
  666.  
  667.           if (imageSize.height > movieSize.height)
  668.           {  if (theRect->size.height > imageSize.height)
  669.              {  p.y = (theRect->size.height - imageSize.height)/2.0;
  670.              }
  671.              else
  672.              {  p.y = 0.0;
  673.              }
  674.        }
  675.           else
  676.           {  if (theRect->size.height > movieSize.height)
  677.              {  p.y = (theRect->size.height - movieSize.height)/2.0;
  678.              }
  679.              else
  680.              {  p.y = 0.0;
  681.              }
  682.        }
  683.       break;
  684.     default:
  685.           p.x = 0.0;
  686.       break;
  687.   }
  688.  
  689.   if (imageUnder)
  690.   {  [image composite:NX_SOVER toPoint:&p];
  691.      [movieImage composite:NX_SOVER toPoint:&p];
  692.   }
  693.   else
  694.   {  [movieImage composite:NX_SOVER toPoint:&p];
  695.      [image composite:NX_SOVER toPoint:&p];
  696.   }
  697.  
  698.   if (borderType)
  699.   {  NXRect  r = *theRect;
  700.  
  701.  
  702.      PSsetalpha(1.0);
  703.  
  704.      r.origin.x++; r.origin.y--;        
  705.      NXSetColor(NX_COLORBLACK); NXFrameRect(&r);
  706.  
  707.      r.origin.x--, r.origin.y++;        
  708.      NXSetColor(NX_COLORGRAY); NXFrameRect(&r);
  709.  
  710.      r.origin.x--; r.size.width++; r.size.height++; 
  711.      NXSetColor(NX_COLORWHITE); NXFrameRect(&r);
  712.   }
  713.  
  714.   return self;
  715. }
  716.  
  717. - (BOOL)acceptsFirstResponder { return YES; }
  718.  
  719. - setMyTrackingRect:(BOOL)flag
  720. {
  721.   NXRect  visible;
  722.  
  723.  
  724.   if (trackingRect)
  725.   {  [window discardTrackingRect:trackingRect];
  726.      trackingRect = 0;
  727.   }
  728.   if (flag)
  729.   {  if ([self getVisibleRect:&visible])
  730.      {  [self convertRect:&visible toView:nil];
  731.         [window setTrackingRect:&visible inside:NO owner:self tag:(int)self left:NO right:NO];
  732.         trackingRect = (int)self;
  733.      }
  734.   }
  735.   return self;
  736. }
  737.  
  738. // might want to allow alt-click to move only one frame...
  739. - mouseDown:(NXEvent *)theEvent
  740. {
  741.   if (theEvent->flags & NX_COMMANDMASK)  // show the control panel
  742.   {  [self loadControlPanel];
  743.      return self;
  744.   }
  745.   if (stationaryBehavior == WW_PLAY_MOUSE_CLICK)
  746.   {  if (!stationaryFrameTE)  // is it running?
  747.      {  if (theEvent->flags & NX_ALTERNATEMASK)  // click one frame
  748.         {  stationaryFrameTE = (DPSTimedEntry)1; // set it to something so the frame gets incremented...
  749.            [self showFrameAndIncrement:nil];
  750.            stationaryFrameTE = 0;
  751.         }
  752.         else
  753.         {  [self beginStationaryBehavior];  // start it up
  754.         }
  755.      }
  756.      else
  757.      {  [self endStationaryBehavior];  // stop it
  758.      }
  759.   }
  760.   return self;
  761. }
  762.  
  763. - mouseEntered:(NXEvent *)theEvent
  764. {
  765.   if (!stationaryFrameTE && (stationaryBehavior == WW_PLAY_MOUSE_IN))
  766.   {  [window makeFirstResponder:self]; // do I need to do this?
  767.      [self beginStationaryBehavior];
  768.   }
  769.   return self;
  770. }
  771.  
  772. - mouseExited:(NXEvent *)theEvent
  773. {
  774.   if (stationaryFrameTE && (stationaryBehavior == WW_PLAY_MOUSE_IN))
  775.   {  [self endStationaryBehavior];
  776.   }
  777.   return self;
  778. }
  779.  
  780. - (const char *)getInspectorClassName { return "WWSimpleMovieViewIBInspector"; }
  781.  
  782.  
  783. // Control Panel stuff (stolen from my IBInspector
  784.  
  785.  
  786. - loadControlPanel
  787. {
  788.    char buf[MAXPATHLEN + 1];
  789.    id bundle;
  790.  
  791.    
  792.    // we want to support two different things here.  
  793.    // 1st scenario: lots of MovieViews, screen space is expensive, we want to have these control panels 
  794.     
  795.    if (!controlPanel)
  796.    {  bundle = [NXBundle bundleForClass:[self class]];
  797.       [bundle getPath:buf forResource:"WWSimpleMovieViewControlPanel" ofType:"nib"];
  798.       [NXApp loadNibFile:buf owner:self withNames:NO fromZone:[self zone]];
  799.       if (!controlPanel)
  800.       {  NXLogError("problem loading WWSimpleMovieViewControlPanel\n");
  801.          return nil;
  802.       }
  803.       [controlPanel setDelegate:self];
  804.    }
  805.    [self revertControlPanel:nil];
  806.    [controlPanel makeKeyAndOrderFront:self];
  807.    return self;
  808. }
  809.  
  810.  
  811. - revertControlPanel:sender 
  812. { 
  813.    [theColor setColor:[self backgroundColor]];
  814.    [alphaSlider setFloatValue:[self alpha]];
  815.    if ([self drawCorrectly])
  816.    {  [alphaSlider setEnabled:YES];
  817.    }
  818.    else
  819.    {  if ( [self frameCount])
  820.       {  [alphaSlider setEnabled:NO];
  821.       }
  822.       else
  823.       {  [alphaSlider setEnabled:YES];
  824.       }
  825.    }
  826.    if ([self archiveImageData])
  827.    {  [theImage setStringValue:""];
  828.    }
  829.    else
  830.    {  [theImage setStringValue:[[self image] name]];
  831.    }
  832.  
  833.    if ([self archiveMovieData])
  834.    {  [theImage setStringValue:""];
  835.    }
  836.    else
  837.    {  [theMovie setStringValue:[[self movieImage] name]];
  838.    }
  839.  
  840.    [drawCorrectlySwitch setIntValue:[self drawCorrectly]];
  841.    [aspectRatioMatrix selectCellWithTag:[self aspectRatioType]];
  842.    [horizontalLayoutMatrix selectCellWithTag:[self horizontalLayoutType]];
  843.    [verticalLayoutMatrix selectCellWithTag:[self verticalLayoutType]];
  844.    [customAspectRatioText setFloatValue:[self aspectRatio]];
  845.    [customAspectRatioText setEnabled:([self aspectRatioType] == WW_ASPECT_CUSTOM)];
  846.    [scaleSwitch setIntValue:(int)[(WWSimpleMovieView *)self scaleToFit]];
  847.    [imageUnderSwitch setIntValue:[self imageUnder]];
  848.    [rotateTo setFloatValue:[self frameAngle]];
  849.    [borderTypeMatrix selectCellWithTag:[self borderType]];
  850.    [stationaryBehaviorMatrix selectCellWithTag:[self stationaryBehavior]];
  851.    [loopSwitch setIntValue:[self loop]];
  852.    [archiveMovieDataSwitch setIntValue:[self archiveMovieData]];
  853.    [archiveImageDataSwitch setIntValue:[self archiveImageData]];
  854.  
  855.    [fpsText setFloatValue:[self fps]];
  856.    clearTheView = YES; [self display];
  857.    clearTheView = NO;  [window display]; NXPing();
  858.  
  859.    return self;
  860. }
  861.  
  862. - takeColor_:s    { [self setBackgroundColor:[theColor color]]; [self revertControlPanel:nil]; return self; }
  863. - setAlpha_:s    { [self setBackgroundAlpha:[s floatValue]]; [self revertControlPanel:nil]; return self; }
  864. - setImage_:s    { [self setImageFile:(char *)[s stringValue]]; [self revertControlPanel:nil]; return self; }
  865. - setMovie_:s    { [self setAnimDir:(char *)[s stringValue]]; [self revertControlPanel:nil]; return self; }
  866. - setAspectRatio_:s    { [self setAspectRatio:s]; [self revertControlPanel:nil]; return self; }
  867. - setImageUnder_:s    { [self setImageUnder:[s intValue]]; [self revertControlPanel:nil]; return self; }
  868. - setScale_:s    { [self setScaleToFit:[s intValue]]; [self revertControlPanel:nil]; return self; }
  869. - setAspectRatioFromMatrix_:s    { [self setAspectRatioFromMatrix:s]; [self revertControlPanel:nil]; return self; }
  870. - setHorizontalLayoutFromMatrix_:s    { [self setHorizontalLayoutFromMatrix:s]; [self revertControlPanel:nil]; return self; }
  871. - setBorderTypeFromMatrix_:s    { [self setBorderType:[[s selectedCell] tag]]; [self revertControlPanel:nil]; return self; }
  872. - setVerticalLayoutFromMatrix_:s    { [self setVerticalLayoutFromMatrix:s]; [self revertControlPanel:nil]; return self; }
  873. - setFPS_:s    { [self setFPS:[s floatValue]]; [self revertControlPanel:nil]; return self; }
  874. - setStationaryBehaviorFromMatrix_:s    { [self setStationaryBehaviorFromMatrix:s]; [self revertControlPanel:nil]; return self; }
  875. - setLoop_:s    { [self setLoop:[s intValue]]; [self revertControlPanel:nil]; return self; }
  876. - setArchiveMovieData_:s    { [self setArchiveMovieData:[s intValue]]; [self revertControlPanel:nil]; return self; }
  877. - setArchiveImageData_:s    { [self setArchiveImageData:[s intValue]]; [self revertControlPanel:nil]; return self;  }
  878. - setDrawCorrectly_:s    { [self setDrawCorrectly:[s intValue]]; [self revertControlPanel:nil]; return self; }
  879.  
  880. - rotateTo_:s { [self rotateTo:[s floatValue]];  [self display]; [self revertControlPanel:nil]; return self; }
  881.  
  882. - sizeToImage_:s { [self sizeToImage:s];  [self display]; [self revertControlPanel:nil]; return self; }
  883. - sizeToMovie_:s { [self sizeToMovie:s];  [self display]; [self revertControlPanel:nil]; return self; }
  884.  
  885. - saveImage:sender
  886. {
  887.   static id savePanel=nil;
  888.   NXStream *ts;
  889.  
  890.  
  891.   if (!savePanel) 
  892.   {  savePanel=[SavePanel new];
  893.   }
  894.  
  895.   [savePanel setRequiredFileType:"tiff"];
  896.   if([savePanel runModal])
  897.   {  ts = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  898.      [image writeTIFF:ts allRepresentations:NO usingCompression:NX_TIFF_COMPRESSION_LZW andFactor:1.0];
  899.      NXSaveToFile(ts, [savePanel filename]);
  900.      NXCloseMemory(ts,NX_FREEBUFFER);
  901.   }
  902.  
  903.   return self;
  904. }
  905.  
  906. - saveMovie:sender
  907. {
  908.   static 
  909.       id    savePanel=nil;
  910.   NXStream  *ts;
  911.   int       ret, i;
  912.   char      imageNameBase[MAXPATHLEN+1];
  913.   char      imageFilename[MAXPATHLEN+1];
  914.   char      *animFilename;
  915.  
  916.  
  917.   if (!savePanel) 
  918.   {  savePanel=[SavePanel new];
  919.   }
  920.  
  921.   [savePanel setRequiredFileType:"anim"];
  922.   if([savePanel runModal])
  923.   {  // this is a little dangerous, but hey, it's faster...
  924.      animFilename = (char *)[savePanel filename];
  925.      ret = mkdir(animFilename, 0777);
  926.      if (ret)
  927.      {  NXLogError("couldn't save anim to %s", animFilename);
  928.         return nil;
  929.      }
  930.      basename(animFilename, ".anim", imageNameBase);
  931.  
  932.      for (i = 1; i < frameCount; i++)
  933.      {  ts = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  934.         if (!ts)
  935.         {  NXLogError("unable to open a memory stream!\n");
  936.            return nil;
  937.         }
  938.         if (![[imageList objectAt:(i-1)] writeTIFF:ts allRepresentations:NO usingCompression:NX_TIFF_COMPRESSION_LZW andFactor:1.0])
  939.         {  NXLogError("unable to write image %d to a memory stream!\n", i);
  940.            NXCloseMemory(ts, NX_FREEBUFFER);
  941.            return nil;
  942.         }
  943.         sprintf(imageFilename, "%s/%s.%d.tiff", animFilename, imageNameBase, i);
  944.         if (NXSaveToFile(ts, imageFilename))
  945.         {  NXLogError("unable to save memory stream to file <%s>\n", imageFilename);
  946.            NXCloseMemory(ts, NX_FREEBUFFER);
  947.            return nil;
  948.         }
  949.         NXCloseMemory(ts, NX_SAVEBUFFER);
  950.      }
  951.      ts = NXOpenMemory(NULL, 0, NX_WRITEONLY);
  952.      if (!ts)
  953.      {  NXLogError("unable to open a memory stream!\n");
  954.         return nil;
  955.      }
  956.      if (![[imageList objectAt:(i-1)] writeTIFF:ts allRepresentations:NO usingCompression:NX_TIFF_COMPRESSION_LZW andFactor:1.0])
  957.      {  NXLogError("unable to write image %d to a memory stream!\n", i);
  958.         NXCloseMemory(ts, NX_FREEBUFFER);
  959.         return nil;
  960.      }
  961.      sprintf(imageFilename, "%s/%s.%d.tiff", animFilename, imageNameBase, i);
  962.      if (NXSaveToFile(ts, imageFilename))
  963.      {  NXLogError("unable to save memory stream to file <%s>\n", imageFilename);
  964.         NXCloseMemory(ts, NX_FREEBUFFER);
  965.         return nil;
  966.      }
  967.      NXCloseMemory(ts, NX_FREEBUFFER);
  968.   }
  969.  
  970.   return self;
  971. }
  972.  
  973.  
  974. - windowWillClose:sender
  975. {
  976.   if (controlPanel && (sender == controlPanel))
  977.   { controlPanel = nil;
  978.   }
  979.   return self;
  980. }
  981.  
  982.  
  983.  
  984. #define typeVectorVersion1 "@fifcciiiffcicccc@"
  985. #define typeValuesVersion1 &image, &alpha, &aspectRatioType, &aspectRatio, &imageUnder, &scaleToFit, &borderType, &horizontalLayoutType, &verticalLayoutType, &fps, &frameTimeIncr, &loop, &stationaryBehavior, &sink, &source, &archiveImageData, &archiveMovieData, &imageList
  986.  
  987. #define typeVectorVersion2 "@fifcciiiffcicccc@c"
  988. #define typeValuesVersion2 &image, &alpha, &aspectRatioType, &aspectRatio, &imageUnder, &scaleToFit, &borderType, &horizontalLayoutType, &verticalLayoutType, &fps, &frameTimeIncr, &loop, &stationaryBehavior, &sink, &source, &archiveImageData, &archiveMovieData, &imageList, &drawCorrectly
  989.  
  990. #define typeVector "@fifcciiiffcicccc@ccc"
  991. #define typeValues &image, &alpha, &aspectRatioType, &aspectRatio, &imageUnder, &scaleToFit, &borderType, &horizontalLayoutType, &verticalLayoutType, &fps, &frameTimeIncr, &loop, &stationaryBehavior, &sink, &source, &archiveImageData, &archiveMovieData, &imageList, &drawCorrectly, &imageIsShared, &movieIsShared
  992.  
  993. - read:(NXTypedStream*)stream 
  994. {
  995.     int version;
  996.     [super read:stream];
  997.  
  998.  
  999.     version = NXTypedStreamClassVersion(stream, "WWSimpleMovieView");
  1000.     if (version == 0) NXReadTypes(stream, "i", &version), version=1;
  1001.     if (version == 1)
  1002.     {  NXReadTypes(stream, typeVectorVersion1, typeValuesVersion1);
  1003.        backgroundColor = NXReadColor(stream);
  1004.        drawCorrectly = YES;
  1005.        imageIsShared = NO;
  1006.        movieIsShared = NO;
  1007.     } 
  1008.     if (version == 2)
  1009.     {  NXReadTypes(stream, typeVectorVersion2, typeValuesVersion2);
  1010.        backgroundColor = NXReadColor(stream);
  1011.        imageIsShared = NO;
  1012.        movieIsShared = NO;
  1013.     } 
  1014.     if (version == 3)
  1015.     {  NXReadTypes(stream, typeVector, typeValues);
  1016.        backgroundColor = NXReadColor(stream);
  1017.     } 
  1018.     return self;
  1019. }
  1020.  
  1021.  
  1022. - write:(NXTypedStream *)stream 
  1023. {
  1024.     [super write:stream];
  1025.     NXWriteTypes(stream, typeVector, typeValues);
  1026.     NXWriteColor(stream, backgroundColor);
  1027.  
  1028.     return self;
  1029. }
  1030.  
  1031.     
  1032.  
  1033. @end
  1034.