Return to CompositeView.m CVS log

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

Annotation of Examples/AppKit/CompositeLab/CompositeView.m, revision 1.1

1.1     ! root        1: /*
        !             2: 
        !             3:  You may freely copy, distribute and reuse the code in this example.
        !             4:  NeXT disclaims any warranty of any kind, expressed or implied,
        !             5:  as to its fitness for any particular use.
        !             6: 
        !             7:  CompositeView implements a view with three horizontal, equal-sized areas.
        !             8:  The left-most area is the "source," the middle area is the "destination,"
        !             9:  and the right-most area is the "result." CompositeView assures that the
        !            10:  contents of the result area is always generated by compositing the other
        !            11:  two areas using the compositing mode set in the setOperator: method.
        !            12:  It is also possible to change the contents, color, and alpha of the
        !            13:  source and destination areas; see the methods setSourceColor:, 
        !            14:  setSourceAlpha:, etc.
        !            15: 
        !            16:  CompositeView also demonstrates some of the drag & drop features of
        !            17:  NeXTSTEP 3.0 by acting as a destination for colors & images.
        !            18: 
        !            19:  CompositeView written by Bruce Blumberg and Ali Ozer.
        !            20: 
        !            21:  Color support, NXColorPanel, NXColorWells, and NXImage added during 1990 by Ali.
        !            22:  Color dragging support added Feb 9, 1992, by Ali.
        !            23:  Image dragging support added May 27, 1992, by Ali.
        !            24:  Image dragging problem fixed Sep 29, 1992 (for 3.1), by Ali. See QAP appkit.878.
        !            25: 
        !            26: */
        !            27: 
        !            28: #import <appkit/appkit.h>
        !            29: #import "CompositeView.h"
        !            30: 
        !            31: 
        !            32: @implementation CompositeView
        !            33: 
        !            34: // The possible draw modes for the source.
        !            35: 
        !            36: #define TRIANGLE 0
        !            37: #define CIRCLE   1
        !            38: #define DIAMOND  2
        !            39: #define HEART    3
        !            40: #define FLOWER   4
        !            41: #define CUSTOM   5
        !            42: 
        !            43: // initFrame: creates the view, initializes the rectangles that define the
        !            44: // three areas described above, and creates the bitmaps used for rendering the
        !            45: // source and destination bitmaps. newFrame: is a convenience method.
        !            46: 
        !            47: - initFrame:(const NXRect *)tF
        !            48: {
        !            49:     // Initialize the view
        !            50:     [super initFrame:tF];
        !            51: 
        !            52:     // Make rectangles for source, destination and result
        !            53:     sRect = bounds;
        !            54:     sRect.size.width /= 3.0;
        !            55:     dRect = sRect;
        !            56:     dRect.origin.x = sRect.size.width;
        !            57:     rRect = dRect;
        !            58:     rRect.origin.x = dRect.origin.x + dRect.size.width;
        !            59: 
        !            60:     // Create source, destination, and result images.
        !            61: 
        !            62:     [(source = [[NXImage allocFromZone:[self zone]] initSize:&sRect.size])
        !            63:        useDrawMethod:@selector(drawSource:) inObject:self];
        !            64:     [source setBackgroundColor:NX_COLORCLEAR];
        !            65:     
        !            66:     [(destination = [[NXImage allocFromZone:[self zone]] initSize:&dRect.size])
        !            67:        useDrawMethod:@selector(drawDestination:) inObject:self];
        !            68:     [destination setBackgroundColor:NX_COLORCLEAR];
        !            69: 
        !            70:     [(result = [[NXImage allocFromZone:[self zone]] initSize:&dRect.size])
        !            71:        useDrawMethod:@selector(drawResult:) inObject:self];
        !            72:     [result setBackgroundColor:NX_COLORCLEAR];
        !            73: 
        !            74:     // Set the default operator and source picture. No need to set the default
        !            75:     // colors; these are read from the .nib file when the outlets to the wells
        !            76:     // are estanblished.
        !            77: 
        !            78:     operator = NX_COPY;
        !            79:     sourcePicture = TRIANGLE;
        !            80: 
        !            81:     // Tell the application that alpha should be allowed in the color panel
        !            82:     // and dragged colors. Most apps do not want to bother with this.
        !            83: 
        !            84:     [NXApp setImportAlpha:YES];
        !            85: 
        !            86:     // Finally, register for dragging colors and files. 
        !            87: 
        !            88:     [self registerForDraggedTypes:&NXColorPboardType count:1];
        !            89:     [self registerForDraggedTypes:&NXFilenamePboardType count:1];
        !            90: 
        !            91:     return self;
        !            92: }
        !            93: 
        !            94: // Get handles to the wells and read their initial colors.
        !            95: 
        !            96: - setSourceColorWell:anObject
        !            97: {
        !            98:     sourceColorWell = anObject;
        !            99:     sourceColor = [anObject color];
        !           100:     return self;
        !           101: }
        !           102: 
        !           103: - setDestColorWell:anObject
        !           104: {
        !           105:     destColorWell = anObject;
        !           106:     destColor = [anObject color];
        !           107:     return self;
        !           108: }
        !           109: 
        !           110: - setBackColorWell:anObject
        !           111: {
        !           112:     backColorWell = anObject;
        !           113:     backgroundColor = [anObject color];
        !           114:     return self;
        !           115: }
        !           116: 
        !           117: // drawSource creates the source image in the source bitmap. Note that
        !           118: // drawSource does not render in the view; it renders in the bitmap only.
        !           119: 
        !           120: - drawSource:image
        !           121: {      
        !           122:     NXPoint zeroPoint = {0.0, 0.0};
        !           123: 
        !           124:     NXSetColor(sourceColor);
        !           125:     PSnewpath();
        !           126:     switch (sourcePicture) {
        !           127: 
        !           128:        case TRIANGLE: 
        !           129:            PSmoveto (0.0, 0.0);
        !           130:            PSlineto (0.0, sRect.size.height);
        !           131:            PSlineto (sRect.size.width, sRect.size.height);
        !           132:            break;
        !           133: 
        !           134:        case CIRCLE:
        !           135:            PSscale (sRect.size.width, sRect.size.height);
        !           136:            PSarc (0.5, 0.5, 0.4, 0.0, 360.0);  // diameter is 80% of area
        !           137:            break;
        !           138: 
        !           139:        case DIAMOND:
        !           140:            PSmoveto (0.0, sRect.size.height / 2.0);
        !           141:            PSlineto (sRect.size.width / 2.0, 0.0);
        !           142:            PSlineto (sRect.size.width, sRect.size.height / 2.0);
        !           143:            PSlineto (sRect.size.width / 2.0, sRect.size.height);
        !           144:            break;
        !           145: 
        !           146:        case HEART:
        !           147:            PSscale (sRect.size.width, sRect.size.height);
        !           148:            PSmoveto (0.5, 0.5);
        !           149:            PScurveto (0.3, 1.0, 0.0, 0.5, 0.5, 0.1);
        !           150:            PSmoveto (0.5, 0.5);                        
        !           151:            PScurveto (0.7, 1.0, 1.0, 0.5, 0.5, 0.1);  
        !           152:            break;
        !           153: 
        !           154:        case FLOWER:
        !           155:            PSscale (sRect.size.width, sRect.size.height);
        !           156:            PStranslate (0.5, 0.5);
        !           157:            PSmoveto (0.0, 0.0); 
        !           158:             {int cnt;
        !           159:             for (cnt = 0; cnt < 6; cnt++) {
        !           160:                PSrotate (60.0);
        !           161:                PScurveto (0.4, 0.5, -0.4, 0.5, 0.0, 0.0);
        !           162:             }
        !           163:            }
        !           164:            break;
        !           165: 
        !           166:         case CUSTOM:
        !           167:            if (!customImage) {
        !           168:                customImage = [[NXImage allocFromZone:[self zone]] 
        !           169:                                initSize:&rRect.size];
        !           170:                [customImage setScalable:YES];
        !           171:                [customImage useFromSection:"DefaultCustomImage.eps"];
        !           172:            }
        !           173:            [customImage composite:NX_SOVER toPoint:&zeroPoint];
        !           174:            break;
        !           175:  
        !           176:        default:
        !           177:            break;
        !           178:     }
        !           179:     PSclosepath();
        !           180:     PSfill();
        !           181: 
        !           182:     return self;
        !           183: }
        !           184: 
        !           185: // drawDestination creates the destination image in the destination bitmap. 
        !           186: // Like drawSource, drawDestination only draws in the bitmap, not the view.
        !           187: 
        !           188: - drawDestination:image
        !           189: {
        !           190:     NXSetColor(destColor);
        !           191:     PSnewpath();
        !           192:     PSmoveto(dRect.size.width, 0.0);
        !           193:     PSlineto(dRect.size.width, dRect.size.height);
        !           194:     PSlineto(0.0, dRect.size.height);
        !           195:     PSclosepath();
        !           196:     PSfill();
        !           197:     return self;
        !           198: }
        !           199: 
        !           200: // drawResults creates the resulting image, formed by compositing the
        !           201: // source image after the destination image with the specified operator. 
        !           202: 
        !           203: - drawResult:image
        !           204: {
        !           205:     NXPoint zeroPoint = {0.0, 0.0};
        !           206: 
        !           207:     [destination composite:NX_COPY toPoint:&zeroPoint];
        !           208:     [source composite:operator toPoint:&zeroPoint];
        !           209:     return self;
        !           210: }
        !           211:     
        !           212: // setSourcePicture allows setting the picture to be drawn in the source
        !           213: // bitmap. Buttons connected to this method should have tags that are 
        !           214: // set to the various possible pictures (see the "#define"s, above).
        !           215: //
        !           216: // After setting the sourcePicture instance variable, setSourcePicture redraws
        !           217: // the bitmap and updates the view to reflect the new configuration.
        !           218: 
        !           219: - setSourcePicture:sender
        !           220: {
        !           221:     sourcePicture = [sender selectedTag];
        !           222:     [source recache];
        !           223:     [result recache];
        !           224:     [self display];
        !           225:     return self;
        !           226: }
        !           227: 
        !           228: - (BOOL)changeCustomImageTo:newImage
        !           229: {
        !           230:     if (newImage) {
        !           231:        [newImage setSize:&rRect.size];
        !           232:        [newImage setScalable:YES];
        !           233:        if ([newImage lockFocus]) {     // Is this a good image indeed?
        !           234:            [newImage unlockFocus];
        !           235:            [customImage free];
        !           236:            customImage = newImage;
        !           237:            if (sourcePicture != CUSTOM) {
        !           238:                sourcePicture = CUSTOM;
        !           239:                [sourcePictureMatrix selectCellWithTag:CUSTOM];
        !           240:            }
        !           241:            [source recache];
        !           242:            [result recache];
        !           243:            [self display];
        !           244:            return YES;
        !           245:        }
        !           246:     }
        !           247:     return NO;
        !           248: }
        !           249: 
        !           250: - changeCustomImage:sender
        !           251: {
        !           252:     if ([[OpenPanel new] runModalForTypes:[NXImage imageFileTypes]]) {
        !           253:        const char *fileName = [[OpenPanel new] filename];
        !           254:        (void)[self changeCustomImageTo:[[NXImage allocFromZone:[self zone]] initFromFile:fileName]];
        !           255:     }
        !           256: 
        !           257:     return self;
        !           258: }
        !           259: 
        !           260: // The following methods change the colors and update
        !           261: // the source or destination bitmaps and the view to reflect the change.
        !           262: // They should typically be called by a control capable of returning
        !           263: // a color (for instance, an NXColorWell).
        !           264: 
        !           265: - changeSourceColor:sender
        !           266: {
        !           267:     [self changeSourceColorTo:[sender color] andDisplay:YES];
        !           268:     return self;
        !           269: }
        !           270: 
        !           271: - changeDestColor:sender
        !           272: {
        !           273:     [self changeDestColorTo:[sender color] andDisplay:YES];
        !           274:     return self;
        !           275: }
        !           276: 
        !           277: - changeBackgroundColor:sender
        !           278: {
        !           279:     [self changeBackgroundColorTo:[sender color] andDisplay:YES];
        !           280:     return self;
        !           281: }
        !           282: 
        !           283: - (void)changeSourceColorTo:(NXColor)color andDisplay:(BOOL)flag
        !           284: {
        !           285:     if (!NXEqualColor(sourceColor, color)) {
        !           286:        sourceColor = color;
        !           287:        [source recache];
        !           288:        [result recache];
        !           289:        if (flag) [self display];
        !           290:     }
        !           291: }
        !           292: 
        !           293: - (void)changeDestColorTo:(NXColor)color andDisplay:(BOOL)flag
        !           294: {
        !           295:     if (!NXEqualColor(destColor, color)) {
        !           296:        destColor = color;
        !           297:        [destination recache];
        !           298:        [result recache];
        !           299:        if (flag) [self display];
        !           300:     }
        !           301: }
        !           302: 
        !           303: - (void)changeBackgroundColorTo:(NXColor)color andDisplay:(BOOL)flag
        !           304: {
        !           305:     if (!NXEqualColor(backgroundColor, color)) {
        !           306:        backgroundColor = color;
        !           307:        if (flag) [self display];
        !           308:     }
        !           309: }
        !           310: 
        !           311: // The operator method returns the operator currently in use.
        !           312: 
        !           313: - (int)operator {return operator;}
        !           314: 
        !           315: 
        !           316: // setOperator sets the operator to be used in the compositing operations
        !           317: // and updates the view to reflect the change. Note that setOperator needs
        !           318: // to be connected to a row of buttons.
        !           319: 
        !           320: - setOperator:sender
        !           321: {      
        !           322:     switch ([sender selectedRow]) {
        !           323:        case 0: operator = NX_COPY;             break;
        !           324:        case 1: operator = NX_CLEAR;            break;
        !           325:        case 2: operator = NX_SOVER;            break;
        !           326:        case 3: operator = NX_DOVER;            break;
        !           327:        case 4: operator = NX_SIN;              break;
        !           328:        case 5: operator = NX_DIN;              break;
        !           329:        case 6: operator = NX_SOUT;             break;
        !           330:        case 7: operator = NX_DOUT;             break;
        !           331:        case 8: operator = NX_SATOP;            break; 
        !           332:        case 9: operator = NX_DATOP;            break;
        !           333:        case 10: operator = NX_XOR;             break;
        !           334:        case 11: operator = NX_PLUSD;           break;
        !           335:        case 12: operator = NX_PLUSL;           break;
        !           336:        default: break;
        !           337:     }
        !           338:     [result recache];
        !           339:     [self speedyDraw];
        !           340: 
        !           341:     return self;
        !           342: }
        !           343: 
        !           344:                
        !           345: // drawSelf:: simply redisplays the contents of the view. The source and
        !           346: // destination rectangles are updated from the bitmaps while the result
        !           347: // rectangle is created by compositing the two bitmaps.
        !           348: 
        !           349: - drawSelf:(NXRect *)r :(int) count
        !           350: {
        !           351:     // Erase the whole view
        !           352:     NXSetColor (backgroundColor);
        !           353:     NXRectFill (&bounds);
        !           354: 
        !           355:     // Color for the frame of the three sections...
        !           356:     NXSetColor (NXChangeAlphaComponent (NX_COLORBLACK, 1.0));
        !           357: 
        !           358:     // Draw the source bitmap and then frame it with black
        !           359:     [source composite:NX_SOVER toPoint:&sRect.origin];
        !           360:     NXFrameRect(&sRect);
        !           361: 
        !           362:     // Draw the destination bitmap and frame it with black 
        !           363:     [destination composite:NX_SOVER toPoint:&dRect.origin];
        !           364:     NXFrameRect(&dRect);
        !           365: 
        !           366:     // And now for the result image. Frame it with black as well
        !           367:     [result composite:NX_SOVER toPoint:&rRect.origin];
        !           368:     NXFrameRect(&rRect);
        !           369: 
        !           370:     return self;
        !           371: }
        !           372: 
        !           373: // speedyDraw provides some efficiency in redisplaying the view by assuming
        !           374: // that the source and the destination rectangles are already in place.
        !           375: 
        !           376: - speedyDraw
        !           377: {
        !           378:     [self lockFocus];
        !           379:     NXSetColor (backgroundColor);
        !           380:     NXRectFill (&rRect);
        !           381:     [result composite:NX_SOVER toPoint:&rRect.origin];
        !           382:     NXSetColor (NXChangeAlphaComponent (NX_COLORBLACK, 1.0));
        !           383:     NXFrameRect(&rRect);
        !           384:     [[self window] flushWindow];
        !           385:     [self unlockFocus];
        !           386: 
        !           387:     return self;
        !           388: }
        !           389: 
        !           390: // free method to free all the images along with the view.
        !           391: 
        !           392: - free
        !           393: {
        !           394:     [source free];
        !           395:     [destination free];
        !           396:     [result free];
        !           397:     [customImage free];
        !           398:     return [super free];
        !           399: }
        !           400: 
        !           401: 
        !           402: // Code to support dragging...
        !           403: // This is mostly complicated by the fact that the code wants to demonstrate
        !           404: // how to dynamically give feedback to the user as the colors are
        !           405: // dragged (but not dropped). We don't dynamically give feedback when images
        !           406: // are dragged (as it might take a long time).
        !           407: 
        !           408: // includesType() returns YES if type is included within types.
        !           409: 
        !           410: static BOOL includesType (const NXAtom *types, NXAtom type)
        !           411: {
        !           412:     if (types) while (*types) if (*types++ == type) return YES;
        !           413:     return NO;
        !           414: }
        !           415: 
        !           416: - (NXDragOperation)draggingEntered:(id <NXDraggingInfo>)sender
        !           417: {
        !           418:     return [self draggingUpdated:sender];
        !           419: }
        !           420: 
        !           421: - (NXDragOperation)draggingUpdated:(id <NXDraggingInfo>)sender
        !           422: {
        !           423:     if ([sender draggingSourceOperationMask] & NX_DragOperationGeneric) {
        !           424:        Pasteboard *pboard = [sender draggingPasteboard];
        !           425:         if (includesType([pboard types], NXColorPboardType)) { // Color
        !           426:            NXColor sourceColorSave = sourceColor;
        !           427:            NXColor destColorSave = destColor;
        !           428:            NXColor backgroundColorSave = backgroundColor;
        !           429:            [self doColorDrag:sender];
        !           430:            [self changeSourceColorTo:sourceColorSave andDisplay:NO];
        !           431:            [self changeDestColorTo:destColorSave andDisplay:NO];
        !           432:            [self changeBackgroundColorTo:backgroundColorSave andDisplay:NO];
        !           433:            return NX_DragOperationGeneric;
        !           434:        } else if ([NXImage canInitFromPasteboard:pboard]) {    // Image?
        !           435:            return NX_DragOperationGeneric;
        !           436:        }
        !           437:     }
        !           438:     return NX_DragOperationNone;           
        !           439: }
        !           440: 
        !           441: - draggingExited:sender
        !           442: {
        !           443:     if (includesType([[sender draggingPasteboard] types], NXColorPboardType)) {        // We need to fix the view up
        !           444:        [self display];
        !           445:     }
        !           446:     return self;
        !           447: }
        !           448: 
        !           449: - (BOOL)performDragOperation:(id <NXDraggingInfo>)sender
        !           450: {
        !           451:     return ([self draggingUpdated:sender] == NX_DragOperationNone) ? NO : YES;
        !           452: }
        !           453: 
        !           454: - concludeDragOperation:(id <NXDraggingInfo>)sender
        !           455: {
        !           456:     Pasteboard *pboard = [sender draggingPasteboard];
        !           457: 
        !           458:     if (includesType([pboard types], NXColorPboardType)) {
        !           459:        [self doColorDrag:sender];
        !           460:        [sourceColorWell setColor:sourceColor];
        !           461:        [destColorWell setColor:destColor];
        !           462:        [backColorWell setColor:backgroundColor];
        !           463:     } else {
        !           464:         (void)[self changeCustomImageTo:[[NXImage allocFromZone:[self zone]] initFromPasteboard:pboard]];
        !           465:     }
        !           466:     return self;
        !           467: }
        !           468: 
        !           469: - (void)doColorDrag:(id <NXDraggingInfo>)sender
        !           470: {
        !           471:     NXPoint p = [sender draggingLocation];
        !           472:     NXColor c = NXReadColorFromPasteboard([sender draggingPasteboard]);
        !           473: 
        !           474:     [self convertPoint:&p fromView:nil];
        !           475: 
        !           476:     switch ((int)(3 * p.x / NX_WIDTH(&bounds))) {
        !           477:        case 0:
        !           478:            [self changeSourceColorTo:c andDisplay:YES];
        !           479:            break;
        !           480:        case 1:
        !           481:            [self changeDestColorTo:c andDisplay:YES];
        !           482:            break;
        !           483:        case 2:
        !           484:            [self changeBackgroundColorTo:c andDisplay:YES];
        !           485:            break;
        !           486:        default:
        !           487:            break;      // Shouldn't really happen...
        !           488:     }
        !           489: }
        !           490: 
        !           491: 
        !           492: @end

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