Return to AnimalView.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / BusyBox

Annotation of Examples/AppKit/BusyBox/AnimalView.m, revision 1.1

1.1     ! root        1: 
        !             2: #import "AnimalView.h"
        !             3: #import <appkit/NXBitmapImageRep.h>
        !             4: #import <appkit/Control.h>
        !             5: #import <sys/param.h>
        !             6: 
        !             7: /* 
        !             8:  * AnimalView.m, a simple view to display an NXBitmapImageRep.  
        !             9:  * Subclass of view that draws an NXBitmapImageRep.  Knows how 
        !            10:  * to flip and rotate itself in response to IB controls.       
        !            11:  * NXBitmapImageRep provides the functionality to deal with images 
        !            12:  * that are stored as bitmaps.  The instances of this class are created by 
        !            13:  * loading TIFF data.  In 1.0, I would have read bitmap data (from TIFF 
        !            14:  * file or Mach-O) and imaged it using NXImageBitmap(). It works out much 
        !            15:  * cleaner using NXBitmapImageRep.
        !            16:  *
        !            17:  * Author: Julie Zelenski, NeXT Developer Support
        !            18:  * You may freely copy, distribute and reuse the code in this example.  
        !            19:  * NeXT disclaims any warranty of any kind, expressed or implied, as to 
        !            20:  * its fitness for any particular use.
        !            21:  */
        !            22:  
        !            23: @implementation AnimalView:View
        !            24: 
        !            25: /* INIT/FREE METHODS */
        !            26: 
        !            27: - initFrame:(NXRect *)frameRect;
        !            28: /* Init method for newly created animal view. It initializes the scaling
        !            29:  * factors to normal, and then grabs the duck for the initial image.
        !            30:  */
        !            31: {
        !            32:     [super initFrame:frameRect];
        !            33:     scaleFactor.x = scaleFactor.y = 1.0;
        !            34:     [self setImageToAnimal:"Duck"];
        !            35:     return self;
        !            36: }
        !            37:    
        !            38: - free;
        !            39: /* Free the image on our way out.
        !            40:  */
        !            41: {
        !            42:     [image free];
        !            43:     return [super free];
        !            44: }
        !            45: 
        !            46: 
        !            47: /* TARGET/ACTION METHODS */
        !            48: 
        !            49: - rotateLeft:sender
        !            50: /* Rotates the view 90 degrees to the left and redisplays.
        !            51:  */
        !            52: {  
        !            53:     [self rotate:(scaleFactor.x*scaleFactor.y)*90.0];
        !            54:     [self display];
        !            55:     return self;
        !            56: }
        !            57: 
        !            58: - rotateRight:sender
        !            59: /* Rotates the view 90 degrees to the right and redisplays.
        !            60:  */
        !            61: {
        !            62:     [self rotate:(scaleFactor.x*scaleFactor.y)*-90.0];
        !            63:     [self display];
        !            64:     return self;
        !            65: }
        !            66: 
        !            67: - flipHorizontal:sender
        !            68: /* Mirrors the view across vertical axis, and updates scale factor to 
        !            69:  * indicate that.  Since rotation can change what is currently vertical, 
        !            70:  * need to rotate to zero, do the scaling, and restore rotation.
        !            71:  */ 
        !            72: {   
        !            73:     float angle;
        !            74:     
        !            75:     angle = [self boundsAngle];
        !            76:     scaleFactor.x *= -1;
        !            77:     [self rotate:-1*angle];
        !            78:     [self scale:-1.0 :1.0];
        !            79:     [self rotate:angle];
        !            80:     [self display];
        !            81:     return self;
        !            82: }
        !            83: 
        !            84: - flipVertical:sender
        !            85: /* Mirrors the view across horizontal axis, and updates scale factor to 
        !            86:  * indicate that.  Since rotation can change what is currently horizontal, 
        !            87:  * need to rotate to zero, do the scaling, and restore rotation.
        !            88:  */ 
        !            89: {
        !            90:     float angle;
        !            91:     
        !            92:     angle = [self boundsAngle];
        !            93:     scaleFactor.y *= -1;
        !            94:     [self rotate:-1*angle];
        !            95:     [self scale:1.0 :-1.0];
        !            96:     [self rotate:angle];
        !            97:     [self display];
        !            98:     return self;
        !            99: }
        !           100: 
        !           101: - changeAnimal:sender
        !           102: /* Target/Action for IB control.  Changes to display image with name of
        !           103:  * cell title.
        !           104:  */
        !           105: {   
        !           106:     [self setImageToAnimal:[[sender selectedCell] title]];
        !           107:     return self;
        !           108: }
        !           109: 
        !           110: 
        !           111: 
        !           112: /* PRIVATE METHODS */
        !           113: 
        !           114: - setImageToAnimal:(const char *)imageName;
        !           115: /* Find the bitmap image rep for the specified name, sets the scaling
        !           116:  * and rotation back to "normal" and displays new image.
        !           117:  */
        !           118: {   char filename[MAXPATHLEN];
        !           119: 
        !           120:     sprintf(filename,"%s.tiff",imageName);
        !           121:     if (image) [image free];
        !           122:     image = [[NXBitmapImageRep alloc] initFromSection:filename];
        !           123:     [self setDrawRotation:0.0];
        !           124:     [self scale:scaleFactor.x :scaleFactor.y];
        !           125:     scaleFactor.x = scaleFactor.y = 1.0;
        !           126:     [self display];
        !           127:     return self;
        !           128: }
        !           129: 
        !           130: - drawSelf:(NXRect *)rects :(int)rectCount;
        !           131: /* Clears the background and has the image draw itself 
        !           132:  */
        !           133: {
        !           134:    NXEraseRect(&bounds);  /* to be sure to clear background */
        !           135:    [image drawIn:&bounds];
        !           136:    return self;
        !           137: }
        !           138: 
        !           139: @end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.