![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Graph3DDoc.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Graph|
Return to Graph3DDoc.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Graph |
1.1 root 1:
2: /*
3: Graph3DDoc.m
4:
5: The Graph3DDoc represents an open 3D Graph document. Graph3DDoc receives
6: messages from the user interface objects and uses three Expression objects
7: to do calculations, and a RotatorCamera and a PointMesh to display the
8: results.
9:
10: The Graph3DDoc class has one slightly odd external dependency. It requires
11: that the delegate of NXApp be able to provide it with a NXStringTable
12: (via the stringTable method) that it can use to look up strings that
13: are presented to the user. In this application, the delegate of NXApp is
14: always an instance of the GraphApp class.
15:
16: If this were a larger program, the NXStringTable needed by this document
17: class would probably be in its own nib section, which would be loaded once
18: the first time a Graph3DDoc is created, and then shared.
19:
20: You may freely copy, distribute, and reuse the code in this example.
21: NeXT disclaims any warranty of any kind, expressed or implied, as to its
22: fitness for any particular use.
23: */
24:
25: #import "Graph.h"
26:
27: /* declare methods static to this class */
28: @interface Graph3DDoc(Private)
29: - _updateShape;
30: - _updateGraph:(BOOL)finalChange;
31: - (void)_equationChanged;
32: - (BOOL)_parseEquationFrom:(const char *)str using:(Expression *)expr enableVariables:(BOOL *)enableVars;
33: - _uOrVRangeSliderChanged:sender varName:(int)var;
34: - _uOrVRangeTextChanged:sender varName:(int)var;
35: - _write:(const char *)filename;
36: - _read:(const char *)filename;
37: - (void)_initVariable:(int)index enable:(BOOL)flag value:(float)val;
38: - _doSaveWithNewName:(BOOL)doNewName retainName:(BOOL)doRetain;
39: - _writeGraphToPasteboard:(Pasteboard *)pb types:(const char *const *)types num:(int)numTypes;
40: - (void)_setUVRangeOf:(int)var;
41: - (void)_setVariable:(int)index toValue:(float)val;
42: - (void)_setUpLighting;
43: - (void)_setSliderCell:(SliderCell *)slider value:(float)val minLabel:(Cell *)minLabel maxLabel:(Cell *)maxLabel;
44:
45: @end
46:
47: @implementation Graph3DDoc
48:
49: /* variable names must be between A and H */
50: #define MIN_CONST 'A'
51: #define MAX_CONST 'H'
52:
53: /* indices into instance variable arrays */
54: #define X 0
55: #define Y 1
56: #define Z 2
57: #define U 0
58: #define V 1
59:
60: /* default resolution of a new graph */
61: #define DEFAULT_RES 12
62:
63: /* name used for the real document inside a doc wrapper */
64: #define DOC_NAME "/Graph3DDoc.xyzgraph"
65:
66: static void writeCellFloat(Cell *obj, NXTypedStream *ts);
67: static NXTypedStream *openDocStream(const char *filename, int mode);
68: static int removeFile(const char *file);
69:
70: - init {
71: /* the default initialization is to just open a new document */
72: return [self initFromFile:NULL];
73: }
74:
75: /*
76: * Opens a document. If file is NULL, we open an untitiled document. We also
77: * create a NXDataLinkManager and hook ourselves up as its delegate for doing
78: * Object Links.
79: */
80: - initFromFile:(const char *)file {
81: int rows, cols;
82: int i;
83: TextField *aCell;
84: int xyz;
85: RtPoint axis;
86: char realPath[MAXPATHLEN+1];
87:
88: [super init];
89:
90: /* load the UI from the nib section and set attributes not available in IB */
91: [NXApp loadNibSection:"Graph3DDoc.nib" owner:self withNames:NO fromZone:[self zone]];
92: [variableTexts getNumRows:&rows numCols:&cols];
93: for (i = rows; i--; ) {
94: aCell = [variableTexts cellAt:i :0];
95: [aCell setFloatingPointFormat:YES left:3 right:2];
96: [aCell setEnabled:NO];
97: }
98: [minUVText[U] setFloatingPointFormat:YES left:3 right:2];
99: [maxUVText[U] setFloatingPointFormat:YES left:3 right:2];
100: [minUVText[V] setFloatingPointFormat:YES left:3 right:2];
101: [maxUVText[V] setFloatingPointFormat:YES left:3 right:2];
102: [variableSliders setAutosizeCells:YES];
103: [resolutionText setEntryType:NX_POSINTTYPE];
104: [camera setFieldOfViewByAngle:90.0];
105: [self _setUpLighting];
106:
107: /* create Expression objects we will use to evaluate expressions */
108: for (xyz = X; xyz <= Z; xyz++) {
109: expr[xyz] = [[Expression allocFromZone:[self zone]] init];
110: [expr[xyz] setDimensions:2]; /* we eval u * v points */
111: }
112:
113: /* create and position the shape that we will use to show our data */
114: [[camera setWorldShape:[[PointMesh alloc] init]] free];
115: axis[1] = axis[2] = 0;
116: axis[0] = 1.0;
117: [[camera worldShape] rotateAngle:-90.0 axis:axis];
118:
119: if (file) {
120: /* read existing document */
121: if ([self _read:file]) {
122: name = NXCopyStringBufferFromZone(file, [self zone]);
123: if (realpath(name, realPath))
124: realName = NXCopyStringBufferFromZone(realPath, [self zone]);
125: [window setTitleAsFilename:name];
126: [self _updateShape];
127: linkMgr = [[NXDataLinkManager allocFromZone:[self zone]] initWithDelegate:self fromFile:file];
128: } else {
129: [self free]; /* couldn't load file */
130: return nil;
131: }
132: } else {
133: /*
134: * Create a new document. We initialize it with a trivial expression
135: * because that was easier than allowing the state where there is no
136: * current expression.
137: */
138: RtPoint from = {12.0, 8.0, 10.0}, to = {0.0, 0.0, 0.0};
139:
140: [camera setEyeAt:from toward:to roll:0.0];
141: /* set initial shape color to non-white on a color display */
142: if ([camera shouldDrawColor])
143: [[camera worldShape] setColor:NXConvertRGBToColor(51.0/255.0, 153.0/255.0, 116.0/255.0)];
144:
145: [window setTitleAsFilename:[[[NXApp delegate] stringTable] valueForStringKey:"untitled doc"]];
146: [resolutionSlider setIntValue:DEFAULT_RES];
147: [resolutionText setIntValue:DEFAULT_RES];
148: [equation[X] setStringValue:"u"];
149: [equation[Y] setStringValue:"v"];
150: [equation[Z] setStringValue:"A * (u^2 + v^2) + C"];
151: for (xyz = X; xyz <= Z; xyz++) {
152: [expr[xyz] setResolution:DEFAULT_RES];
153: }
154: [self _equationChanged];
155: [self _setUVRangeOf:U];
156: [self _setUVRangeOf:V];
157: [self _updateShape];
158: linkMgr = [[NXDataLinkManager allocFromZone:[self zone]] initWithDelegate:self];
159: }
160:
161: [[NXApp delegate] showThreeDPanel:self];
162: [window makeKeyAndOrderFront:self];
163: return self;
164: }
165:
166: - free {
167: int xyz;
168:
169: for (xyz = X; xyz <= Z; xyz++)
170: [expr[xyz] free];
171: NXZoneFree([self zone], name);
172: NXZoneFree([self zone], realName);
173: [linkMgr free];
174: return [super free];
175: }
176:
177: - (const char *)filename {
178: return name;
179: }
180:
181: - (const char *)realFilename {
182: return realName;
183: }
184:
185: /*
186: * This method is called whenever our window becomes the app's main window.
187: * When this happens we get the 3D Panel and set its camera to our camera, so
188: * the panel reflects the attributes of our window.
189: */
190: - windowDidBecomeMain:sender {
191: [[[NXApp delegate] threeDPanel] setCamera:camera];
192: return self;
193: }
194:
195: #define BUF_MAX 256
196:
197: /*
198: * This method is called when the user has just finished typing in an
199: * expression. This is where we validate that it is a legal expression.
200: * If we dont like the expression, we return YES, which tells the text object
201: * not to accept the user's entry.
202: */
203: - (BOOL)textWillEnd:textObject {
204: BOOL parseError;
205: BOOL enableVars[MAX_CONST - MIN_CONST + 1];
206: NXStringTable *stringTable;
207: Expression *tempExpr = [[Expression allocFromZone:[self zone]] init];
208: char buffer[BUF_MAX];
209: char *newText;
210: int length;
211:
212: /* get the text out of the text object where the expression was typed */
213: length = [textObject byteLength] + 1;
214: if (length > BUF_MAX)
215: newText = NXZoneMalloc(NXDefaultMallocZone(), sizeof(char) * length);
216: else
217: newText = buffer;
218: [textObject getSubstring:newText start:0 length:length];
219:
220: if (*newText) {
221: parseError = [self _parseEquationFrom:newText using:tempExpr enableVariables:enableVars];
222: if (!parseError) {
223: /* parse the new equation into the real expressions */
224: [self _equationChanged];
225:
226: /* update the shape object with current results and display it */
227: [self _updateGraph:YES];
228: }
229: } else
230: parseError = YES;
231:
232: if (parseError) {
233: stringTable = [[NXApp delegate] stringTable];
234: NXRunAlertPanel([stringTable valueForStringKey:"parse alert title"],
235: [stringTable valueForStringKey:"3D parse alert message"],
236: [stringTable valueForStringKey:"ok button"],
237: NULL, NULL);
238: }
239: [tempExpr free];
240: if (length > BUF_MAX)
241: NXZoneFree(NXDefaultMallocZone(), newText);
242: return parseError;
243: }
244:
245: /* This method does most of the work of parsing a new expression. */
246: - (void)_equationChanged {
247: BOOL enableVars[MAX_CONST - MIN_CONST + 1];
248: int i;
249: int xyz;
250: float newVarVal;
251:
252: for (i = 0; i <= MAX_CONST - MIN_CONST; i++)
253: enableVars[i] = NO;
254: for (xyz = X; xyz <= Z; xyz++) {
255: (void)[self _parseEquationFrom:[equation[xyz] stringValue] using:expr[xyz] enableVariables:enableVars];
256: }
257:
258: /* turn on the UI for constants used in these expressions */
259: for (i = 0; i <= MAX_CONST - MIN_CONST; i++) {
260: if ([[variableSliders cellAt:i :0] isEnabled])
261: newVarVal = [[variableSliders cellAt:i :0] floatValue];
262: else
263: newVarVal = 1.0;
264: [self _initVariable:i enable:enableVars[i] value:newVarVal];
265: }
266:
267: /* update the range of the independent variables */
268: [self _setUVRangeOf:U];
269: [self _setUVRangeOf:V];
270: }
271:
272: /*
273: * This method is called after the user typed in a new expression. The
274: * expression has already been verified in our textWillEnd: method.
275: */
276: - equationChanged:sender {
277: /* reselect the equation field so the user can type another */
278: [sender selectCell:[sender selectedCell]];
279: return self;
280: }
281:
282: /* called when either the minu, maxu, minv or maxv slider changes */
283: - _uOrVRangeSliderChanged:sender varName:(int)var {
284: TextFieldCell *text;
285: SliderCell *slider;
286: NXEvent *event;
287:
288: /* update the associated text field */
289: slider = [sender selectedCell];
290: if (slider == maxUVSlider[var])
291: text = maxUVText[var];
292: else if (slider == minUVSlider[var])
293: text = minUVText[var];
294: else
295: text = nil;
296: NX_ASSERT(text, "Funny sender of _uOrVRangeSliderChanged: message");
297: [text setFloatValue:[slider floatValue]];
298:
299: /* update the u or v range in the Expression and display the new graph */
300: [self _setUVRangeOf:var];
301: event = [NXApp currentEvent];
302: [self _updateGraph:event->type == NX_LMOUSEUP];
303: return self;
304: }
305:
306: /* called when either the minu or maxu slider changes */
307: - uRangeSliderChanged:sender {
308: return [self _uOrVRangeSliderChanged:sender varName:U];
309: }
310:
311: /* called when either the minv or maxv slider changes */
312: - vRangeSliderChanged:sender {
313: return [self _uOrVRangeSliderChanged:sender varName:V];
314: }
315:
316: /* called when either the minu, maxu, minv or maxv text changes */
317: - _uOrVRangeTextChanged:sender varName:(int)var {
318: TextFieldCell *text;
319: SliderCell *slider;
320: float val;
321:
322: /*
323: * update the associated slider. If the value typed is outside the current
324: * range of the slider, we extend its range.
325: */
326: text = [sender selectedCell];
327: if (text == maxUVText[var])
328: slider = maxUVSlider[var];
329: else if (text == minUVText[var])
330: slider = minUVSlider[var];
331: else
332: slider = nil;
333: NX_ASSERT(slider, "Funny sender of _uOrVRangeTextChanged: message");
334: val = [text floatValue];
335: [self _setSliderCell:slider value:val minLabel:nil maxLabel:nil];
336:
337: /* update the u or v range in the Expression and display the new graph */
338: [self _setUVRangeOf:var];
339: [self _updateGraph:YES];
340: [sender selectText:self];
341: return self;
342: }
343:
344: /* called when either the minu or maxu text changes */
345: - uRangeTextChanged:sender {
346: return [self _uOrVRangeTextChanged:sender varName:U];
347: }
348:
349: /* called when either the minv or maxv text changes */
350: - vRangeTextChanged:sender {
351: return [self _uOrVRangeTextChanged:sender varName:V];
352: }
353:
354: /* called when one of the variables' sliders changes */
355: - variableSliderChanged:sender {
356: int index;
357: float val;
358: NXEvent *event;
359:
360: /* update the associated text field */
361: index = [variableSliders selectedRow];
362: val = [[variableSliders selectedCell] floatValue];
363: [[variableTexts cellAt:index :0] setFloatValue:val];
364: [self _setVariable:index toValue:val];
365: event = [NXApp currentEvent];
366: [self _updateGraph:event->type == NX_LMOUSEUP];
367: return self;
368: }
369:
370: /* called when one of the variables' text fields changes */
371: - variableTextChanged:sender {
372: int index;
373: float val;
374: TextFieldCell *text;
375: SliderCell *slider;
376:
377: /* update the associated slider */
378: text = [variableTexts selectedCell];
379: index = [variableTexts selectedRow];
380: slider = [variableSliders cellAt:index :0];
381: val = [text floatValue];
382: [self _setSliderCell:slider value:val
383: minLabel:[variableMinLabels cellAt:index :0]
384: maxLabel:[variableMaxLabels cellAt:index :0]];
385:
386: [self _setVariable:index toValue:val];
387: [self _updateGraph:YES];
388: [sender selectCell:text];
389: return self;
390: }
391:
392: /* The maximum allowable resolution. ~10K polygons */
393: #define MAX_RES 100
394:
395: /* called when either the resolution slider or text fields changes */
396: - resolutionChanged:sender {
397: Cell *senderCell, *otherCell;
398: int iVal;
399: float fVal;
400: int xyz;
401: NXEvent *event;
402:
403: if ([[sender cellAt:0 :0] isKindOfClassNamed:"SliderCell"]) {
404: senderCell = resolutionSlider;
405: otherCell = resolutionText;
406: } else {
407: senderCell = resolutionText;
408: otherCell = resolutionSlider;
409: }
410:
411: fVal = [senderCell floatValue];
412: iVal = rint(fVal);
413: if (iVal > MAX_RES)
414: iVal = MAX_RES;
415: [otherCell setIntValue:iVal];
416:
417: /* update the Expression's resolution and display the new graph */
418: for (xyz = X; xyz <= Z; xyz++)
419: [expr[xyz] setResolution:iVal];
420: event = [NXApp currentEvent];
421: [self _updateGraph:event->type != NX_LMOUSEDRAGGED];
422: if (senderCell == resolutionText)
423: [sender selectText:self];
424: return self;
425: }
426:
427: /*
428: * Copies the current view of the graph into the Pasteboard as Renderman code.
429: * This is sent from the Copy Graph menu item.
430: */
431: - copyGraph:sender {
432: Pasteboard *pb;
433: const char *types[2];
434: NXDataLink *link;
435:
436: pb = [Pasteboard new];
437: types[0] = N3DRIBPboardType;
438: types[1] = NXDataLinkPboardType;
439: [self _writeGraphToPasteboard:pb types:types num:2];
440: link = [[NXDataLink alloc] initLinkedToSourceSelection:[NXSelection allSelection] managedBy:linkMgr supportingTypes:&N3DRIBPboardType count:1];
441: [link writeToPasteboard:pb];
442: [link free];
443: return self;
444: }
445:
446: /*
447: * Copies the current view of the graph into the Pasteboard as RIB.
448: * This is used by the Copy Graph menu item and to support Object Links.
449: *
450: * Types must contain N3DRIBPboardType.
451: */
452: - _writeGraphToPasteboard:(Pasteboard *)pb types:(const char *const *)types num:(int)numTypes {
453: NXStream *st;
454: char *data;
455: int dataLen, maxDataLen;
456:
457: /* Open a stream on memory where we will collect the PostScript */
458: st = NXOpenMemory(NULL, 0, NX_WRITEONLY);
459:
460: /* Tell the Pasteboard we're going to copy RIB */
461: [pb declareTypes:types num:numTypes owner:nil];
462:
463: /* writes the RIB for the whole graph into the stream */
464: [camera copyRIBCode:st];
465:
466: /* get the buffered up PostScript out of the stream */
467: NXGetMemoryBuffer(st, &data, &dataLen, &maxDataLen);
468:
469: /* put the buffer in the Pasteboard, free the stream (and the buffer) */
470: [pb writeType:N3DRIBPboardType data:data length:dataLen];
471: NXCloseMemory(st, NX_FREEBUFFER);
472: return self;
473: }
474:
475: /*** Object Links support - methods called by the DataLinkManager ***/
476:
477: /* called by the DataLinkManager when new data is needed for a link */
478: - copyToPasteboard:(Pasteboard *)pboard at:(NXSelection *)selection cheapCopyAllowed:(BOOL)flag {
479: NX_ASSERT([selection isEqual:[NXSelection allSelection]] || [selection isEqual:[NXSelection currentSelection]], "Funny selection passed to copyToPasteboard:at:");
480: [self _writeGraphToPasteboard:pboard types:&N3DRIBPboardType num:1];
481: return self;
482: }
483:
484: /* returns the window for the given selection */
485: - windowForSelection:(NXSelection *)selection {
486: return window; /* all our sels are always in our one window */
487: }
488:
489: /*
490: * We support continuously updating links by tracking changes to links to
491: * us from open documents. This is easy for Graph because all links can
492: * only be to the whole graph, so any change in the graph is a change relevant
493: * to any link.
494: */
495: - (BOOL)dataLinkManagerTracksLinksIndividually:(NXDataLinkManager *)sender {
496: return YES;
497: }
498:
499: /*
500: * Sent when we should start tracking a link. We just keep all links we're
501: * tracking in a list, and send them a message whenever the graph is changed.
502: */
503: - dataLinkManager:(NXDataLinkManager *)sender startTrackingLink:(NXDataLink *)link {
504: if (!linksTracked)
505: linksTracked = [[List allocFromZone:[self zone]] init];
506: [linksTracked addObject:link];
507: return self;
508: }
509:
510: /* Sent when we can forget a links we're tracking */
511: - dataLinkManager:(NXDataLinkManager *)sender stopTrackingLink:(NXDataLink *)link {
512: [linksTracked removeObject:link];
513: if ([linksTracked count] == 0) {
514: [linksTracked free];
515: linksTracked = nil;
516: }
517: return self;
518: }
519:
520: /*
521: * Called by other methods of Graph3DDoc whenever we make a change to the
522: * document. We tell the DataLinkManager about the change, and also notify
523: * any links we are tracking.
524: */
525: - docChanged {
526: [linkMgr documentEdited];
527: [linksTracked makeObjectsPerform:@selector(sourceEdited)];
528: [window setDocEdited:YES];
529: return self;
530: }
531:
532: /* called by ThreeDPanel when it changes something about the document */
533: - threeDPanelDidChangeDoc:(ThreeDPanel *)sender {
534: [self docChanged];
535: return self;
536: }
537:
538:
539: /* called when Save, Save As, or Save To is picked from the menu */
540: - save:sender { return [self _doSaveWithNewName:NO retainName:YES]; }
541: - saveAs:sender { return [self _doSaveWithNewName:YES retainName:YES]; }
542: - saveTo:sender { return [self _doSaveWithNewName:YES retainName:NO]; }
543:
544: /*
545: * All varieties of save go through this routine. It covers all the cases
546: * of running the Save Panel and retaining the name chosen.
547: */
548: - _doSaveWithNewName:(BOOL)doNewName retainName:(BOOL)doRetain {
549: SavePanel *savePanel;
550: const char *saveName; /* filename to save into */
551: NXZone *zone;
552: BOOL previouslySaved = (name != NULL);
553: char realPath[MAXPATHLEN+1];
554:
555: /*
556: * If the file is untitled or we are saving under a different name,
557: * run the save panel to get a new name.
558: */
559: zone = [self zone];
560: if (!name || doNewName) {
561: savePanel = [SavePanel new];
562: [savePanel setRequiredFileType:"xyzgraph"];
563: if ([savePanel runModalForDirectory:NULL file:name]) {
564: /* if we want to keep this name, replace any old name */
565: if (doRetain) {
566: NXZoneFree(zone, name);
567: NXZoneFree(zone, realName);
568: realName = NULL;
569: name = NXCopyStringBufferFromZone([savePanel filename], zone);
570: }
571: saveName = [savePanel filename];
572: } else
573: return nil; /* user canceled */
574: } else
575: /* if we didn't run the Save Panel, save using the existing name */
576: saveName = name;
577: [self _write:saveName];
578: if (!doRetain)
579: [linkMgr documentSavedTo:saveName];
580: else if (!previouslySaved || doNewName)
581: [linkMgr documentSavedAs:saveName];
582: else
583: [linkMgr documentSaved];
584: if (doRetain) {
585: [window setDocEdited:NO];
586: [window setTitleAsFilename:name];
587: if (!realName && realpath(name, realPath)) {
588: realName = NXCopyStringBufferFromZone(realPath, [self zone]);
589: }
590: }
591: return self;
592: }
593:
594: - revertToSaved:sender {
595: int response;
596: NXStringTable *stringTable;
597: const char *shortName;
598: Graph3DDoc *newDoc;
599:
600: if ([window isDocEdited] && name) {
601: stringTable = [[NXApp delegate] stringTable];
602: shortName = strrchr(name, '/') + 1;
603: response = NXRunAlertPanel([stringTable valueForStringKey:"revert alert title"],
604: [stringTable valueForStringKey:"revert alert message"],
605: [stringTable valueForStringKey:"revert button"],
606: [stringTable valueForStringKey:"cancel button"],
607: NULL, shortName);
608: if (response == NX_ALERTDEFAULT) {
609: [window setDelegate:nil];
610: [window close];
611: [NXApp delayedFree:self];
612: [linkMgr documentClosed];
613: [linkMgr free];
614: linkMgr = nil;
615: newDoc = [[Graph3DDoc allocFromZone:[self zone]] initFromFile:name];
616: if (!newDoc) {
617: NXRunAlertPanel(
618: [stringTable valueForStringKey:"open alert title"],
619: [stringTable valueForStringKey:"open alert message"],
620: [stringTable valueForStringKey:"ok button"],
621: NULL, NULL, name);
622: }
623: }
624: }
625: return self;
626: }
627:
628: /* Called when the window is closing. We free the Graph3DDoc. */
629: - windowWillClose:sender {
630: int response;
631: NXStringTable *stringTable;
632: const char *shortName;
633:
634: if ([window isDocEdited]) {
635: stringTable = [[NXApp delegate] stringTable];
636: if (name) {
637: shortName = strrchr(name, '/') + 1;
638: } else {
639: shortName = [stringTable valueForStringKey:"untitled doc"];
640: }
641: response = NXRunAlertPanel([stringTable valueForStringKey:"close alert title"],
642: [stringTable valueForStringKey:"close alert message"],
643: [stringTable valueForStringKey:"save button"],
644: [stringTable valueForStringKey:"dont save button"],
645: [stringTable valueForStringKey:"cancel button"],
646: shortName);
647: if (response != NX_ALERTDEFAULT && response != NX_ALERTALTERNATE) {
648: return nil;
649: } else {
650: if (response == NX_ALERTDEFAULT && ![self save:sender])
651: return nil;
652: }
653: }
654: [NXApp delayedFree:self];
655: [linkMgr documentClosed];
656: return self; /* says its OK to close */
657: }
658:
659: /* Called whenever something changes to update the view of the graph. */
660: - _updateGraph:(BOOL)finalChange {
661: [self _updateShape]; /* update the values that we graph */
662: [camera display]; /* draw the new graph */
663: if (finalChange)
664: [self docChanged];
665: return self;
666: }
667:
668: /* Called whenever something changes to update the values that we graph. */
669: - _updateShape {
670: float *vals[3];
671: int numVals[3];
672: float min[3], max[3];
673: int xyz;
674:
675: /* extract the values from the Expressions. This may cause a recalc. */
676: for (xyz = X; xyz <= Z; xyz++) {
677: [expr[xyz] resultsVector:&vals[xyz] numVals:&numVals[xyz]];
678: [expr[xyz] resultsMin:&min[xyz] max:&max[xyz]];
679: }
680:
681: /* set the points of the graph */
682: [[camera worldShape] setPointsX:vals[X] y:vals[Y] z:vals[Z]
683: minX:min[X] minY:min[Y] minZ:min[Z]
684: maxX:max[X] maxY:max[Y] maxZ:max[Z]
685: numU:[expr[X] resolution] numV:[expr[X] resolution]];
686: return self;
687: }
688:
689: /* parses and validates the text for one equation field */
690: - (BOOL)_parseEquationFrom:(const char *)str using:(Expression *)anExpr enableVariables:(BOOL *)enableVars {
691: BOOL parseError;
692: EXPEnumState state; /* used to run through the vars of the expression */
693: const char *var;
694:
695: parseError = ![anExpr parse:str];
696: if (!parseError) {
697: /*
698: * If it parsed successfully, make sure all the variables are single
699: * letters, and are either "u", "v" or between "A" and "H". As we
700: * find suitable variables, we remember then in the enableVars
701: * array, so we can enable their controls later.
702: */
703: state = [anExpr beginVariableEnumeration];
704: while (var = [anExpr nextVariable:state])
705: if (*var && !var[1] && *var >= MIN_CONST && *var <= MAX_CONST)
706: enableVars[*var - MIN_CONST] = YES;
707: else if ((*var != 'u' && *var != 'v') || var[1])
708: parseError = YES;
709: [anExpr endVariableEnumeration:state];
710: }
711: return parseError;
712: }
713:
714: /*
715: * Writes a document to the given file using typedstreams. We're very careful
716: * about catching exceptions here so we can tell the user if his file didn't
717: * get written out successfully.
718: */
719: - _write:(const char *)filename {
720: NXTypedStream *ts;
721: const char *stringVal;
722: int intVal;
723: char charVal;
724: RtPoint fromPoint;
725: RtPoint toPoint;
726: float aRollAngle;
727: RtMatrix shapeXform;
728: int rows, cols;
729: int numVars;
730: int i;
731: NXStringTable *stringTable;
732: volatile BOOL hadAnError = NO;
733: char buffer[MAXPATHLEN+1];
734: int xyz;
735: NXRect winFrame;
736:
737: /* cons up the name of the backup file and remove it */
738: strcpy(buffer, filename);
739: strcat(buffer, "~");
740: removeFile(buffer);
741:
742: /* move the existing file to the backup */
743: rename(filename, buffer);
744:
745: /* create the new document as a file package (doc wrapper) */
746: strcpy(buffer, filename);
747: strcat(buffer, DOC_NAME);
748: mkdir(filename, 0777);
749: ts = NXOpenTypedStreamForFile(buffer, NX_WRITEONLY);
750: if (ts) {
751: NX_DURING
752: intVal = 2; /* version of this write's data */
753: NXWriteType(ts, "i", &intVal);
754: for (xyz = X; xyz <= Z; xyz++) {
755: stringVal = [expr[xyz] text];
756: NXWriteType(ts, "*", &stringVal);
757: }
758: [variableSliders getNumRows:&rows numCols:&cols];
759: numVars = 0;
760: for (i = 0; i < rows; i++) {
761: if ([[variableSliders cellAt:i :0] isEnabled])
762: numVars++;
763: }
764: NXWriteType(ts, "i", &numVars);
765: for (i = 0; i < rows; i++)
766: if ([[variableSliders cellAt:i :0] isEnabled]) {
767: charVal = MIN_CONST + i;
768: NXWriteType(ts, "c", &charVal);
769: writeCellFloat([variableSliders cellAt:i :0], ts);
770: }
771: intVal = [expr[X] resolution];
772: NXWriteType(ts, "i", &intVal);
773: writeCellFloat(minUVSlider[U], ts);
774: writeCellFloat(maxUVSlider[U], ts);
775: writeCellFloat(minUVSlider[V], ts);
776: writeCellFloat(maxUVSlider[V], ts);
777: NXWriteColor(ts, [[camera worldShape] color]);
778: NXWriteColor(ts, [camera backgroundColor]);
779: intVal = [[camera worldShape] surfaceType];
780: NXWriteType(ts, "i", &intVal);
781: [camera getEyeAt:&fromPoint toward:&toPoint roll:&aRollAngle];
782: NXWriteArray(ts, "f", 3, fromPoint);
783: NXWriteArray(ts, "f", 3, toPoint);
784: NXWriteType(ts, "f", &aRollAngle);
785: [[camera worldShape] getTransformMatrix:shapeXform];
786: NXWriteArray(ts, "f", 4, shapeXform[0]);
787: NXWriteArray(ts, "f", 4, shapeXform[1]);
788: NXWriteArray(ts, "f", 4, shapeXform[2]);
789: NXWriteArray(ts, "f", 4, shapeXform[3]);
790: [window getFrame:&winFrame];
791: NXWriteRect(ts, &winFrame);
792: NXCloseTypedStream(ts);
793: NX_HANDLER
794: hadAnError = YES;
795: NX_DURING
796: NXCloseTypedStream(ts);
797: NX_HANDLER
798: /* ignore any error at this point */
799: NX_ENDHANDLER
800: NX_ENDHANDLER
801: } else
802: hadAnError = YES;
803: if (hadAnError) {
804: stringTable = [[NXApp delegate] stringTable];
805: NXRunAlertPanel([stringTable valueForStringKey:"save alert title"],
806: [stringTable valueForStringKey:"save alert message"],
807: [stringTable valueForStringKey:"ok button"],
808: NULL, NULL, filename);
809: return nil;
810: } else
811: return self;
812: }
813:
814: /* reads a document from the given file using typedstreams */
815: - _read:(const char *)filename {
816: NXTypedStream *ts;
817: char *stringVal;
818: int i;
819: char varName;
820: float floatVal1, floatVal2;
821: int intVal;
822: RtPoint fromPoint;
823: RtPoint toPoint;
824: float aRollAngle;
825: RtMatrix shapeXform;
826: int version;
827: int numVars;
828: BOOL parseError;
829: int xyz, uv;
830: NXRect winFrame;
831:
832: ts = openDocStream(filename, NX_READONLY);
833: if (ts) {
834: NX_DURING
835: NXReadType(ts, "i", &version); /* read file version */
836: NX_ASSERT(version <= 2, "Unknown file version in -read");
837: for (xyz = X; xyz <= Z; xyz++) {
838: NXReadType(ts, "*", &stringVal);
839: [equation[xyz] setStringValue:stringVal];
840: parseError = ![expr[xyz] parse:stringVal];
841: free(stringVal);
842: NX_ASSERT(!parseError, "Bad expression stored in data file");
843: if (parseError)
844: NX_VALRETURN(nil);
845: }
846: NXReadType(ts, "i", &numVars);
847: for (i = 0; i < numVars; i++) {
848: NXReadType(ts, "c", &varName);
849: NXReadType(ts, "f", &floatVal1);
850: [self _initVariable:varName - MIN_CONST enable:YES
851: value:floatVal1];
852: }
853: NXReadType(ts, "i", &intVal); /* read resolution */
854: [resolutionText setIntValue:intVal];
855: [resolutionSlider setIntValue:intVal];
856: for (xyz = X; xyz <= Z; xyz++)
857: [expr[xyz] setResolution:intVal];
858: for (uv = U; uv <= V; uv++) {
859: NXReadType(ts, "f", &floatVal1); /* read min */
860: NXReadType(ts, "f", &floatVal2); /* read max */
861: [minUVText[uv] setFloatValue:floatVal1];
862: [self _setSliderCell:minUVSlider[uv] value:floatVal1
863: minLabel:nil maxLabel:nil];
864: [maxUVText[uv] setFloatValue:floatVal2];
865: [self _setSliderCell:maxUVSlider[uv] value:floatVal2
866: minLabel:nil maxLabel:nil];
867: [self _setUVRangeOf:uv];
868: }
869: [[camera worldShape] setColor:NXReadColor(ts)];
870: [camera setBackgroundColor:NXReadColor(ts)];
871: NXReadType(ts, "i", &intVal); /* read surface type */
872: [camera setSurfaceTypeForAll:intVal chooseHider:YES];
873: NXReadArray(ts, "f", 3, fromPoint);
874: NXReadArray(ts, "f", 3, toPoint);
875: NXReadType(ts, "f", &aRollAngle);
876: [camera setEyeAt:fromPoint toward:toPoint roll:aRollAngle];
877: NXReadArray(ts, "f", 4, shapeXform[0]);
878: NXReadArray(ts, "f", 4, shapeXform[1]);
879: NXReadArray(ts, "f", 4, shapeXform[2]);
880: NXReadArray(ts, "f", 4, shapeXform[3]);
881: [[camera worldShape] setTransformMatrix:shapeXform];
882: NXReadRect(ts, &winFrame);
883: [window placeWindow:&winFrame];
884: NXCloseTypedStream(ts);
885: /* must use NX_VALRETURN to return from inside a NX_DURING */
886: NX_VALRETURN(self);
887: NX_HANDLER
888: NX_DURING
889: NXCloseTypedStream(ts);
890: NX_HANDLER
891: /* ignore any error at this point */
892: NX_ENDHANDLER
893: return nil;
894: NX_ENDHANDLER
895: } else
896: return nil;
897: }
898:
899: /*
900: * Inits a variable to either be on or off. Used when we discover a new
901: * set of variables after a parse, or to set up the variables from a document
902: * that we read from a file.
903: */
904: - (void)_initVariable:(int)index enable:(BOOL)flag value:(float)val {
905: TextFieldCell *text;
906: SliderCell *slider;
907:
908: /* set the initial value in the Expression */
909: if (flag)
910: [self _setVariable:index toValue:val];
911:
912: /* if the enabled status is changing... */
913: if (flag != [[variableSliders cellAt:index :0] isEnabled])
914: if (flag) {
915:
916: /* enable all controls associated with the variable */
917: [[variableLabels cellAt:index :0] setTextGray:NX_BLACK];
918: slider = [variableSliders cellAt:index :0];
919: [slider setEnabled:YES];
920: [self _setSliderCell:slider value:val
921: minLabel:[variableMinLabels cellAt:index :0]
922: maxLabel:[variableMaxLabels cellAt:index :0]];
923: text = [variableTexts cellAt:index :0];
924: [text setEnabled:YES];
925: [text setFloatValue:val];
926: } else if (!flag) {
927:
928: /* disable all controls associated with the variable */
929: [[variableLabels cellAt:index :0] setTextGray:NX_DKGRAY];
930: slider = [variableSliders cellAt:index :0];
931: [slider setFloatValue:[slider minValue]];
932: [slider setEnabled:NO];
933: text = [variableTexts cellAt:index :0];
934: [text setStringValue:NULL];
935: [text setEnabled:NO];
936: }
937: }
938:
939: /*
940: * sets the range of the u or v variable in the Expression.
941: * It ensures that the min value isn't greater than the max value.
942: */
943: - (void)_setUVRangeOf:(int)var {
944: int xyz;
945: float min = [minUVSlider[var] floatValue];
946: float max = [maxUVSlider[var] floatValue];
947: char *varName = (var == U) ? "u" : "v";
948:
949: for (xyz = X; xyz <= Z; xyz++) {
950: [expr[xyz] setVar:varName min:MIN(min, max) max:MAX(min, max)];
951: /* set up two dimensions of evaluation */
952: [expr[xyz] setVar:varName dimension:var];
953: }
954: }
955:
956: /* sets one of the expressions' variables to a value */
957: - (void)_setVariable:(int)index toValue:(float)val {
958: char varName[2];
959: int xyz;
960:
961: varName[0] = MIN_CONST + index;
962: varName[1] = '\0';
963: for (xyz = X; xyz <= Z; xyz++)
964: [expr[xyz] setVar:varName value:val];
965: }
966:
967: /* sets a slider to a value and adjust min/max */
968: - (void)_setSliderCell:(SliderCell *)slider value:(float)val minLabel:(Cell *)minLabel maxLabel:(Cell *)maxLabel {
969: if (val < [slider minValue]) {
970: [window disableDisplay]; /* so slider won't flash to new location */
971: [slider setMinValue:val];
972: [window reenableDisplay];
973: [minLabel setIntValue:floor(val)];
974: } else if (val > [slider maxValue]) {
975: [window disableDisplay]; /* so slider won't flash to new location */
976: [slider setMaxValue:val];
977: [window reenableDisplay];
978: [maxLabel setIntValue:ceil(val)];
979: }
980: [slider setFloatValue:val];
981: }
982:
983: /* sets up some default lights for the camera */
984: - (void)_setUpLighting {
985: RtPoint distantlight_from, distantlight2_from, pointlight_from;
986: RtPoint distantlight_to;
987: RtFloat intensity;
988: N3DLight *pointLight, *distantLight, *distantLight2, *ambientLight;
989:
990: if ([[camera lightList] count] == 4)
991: return; /* we've already added lights to this camera */
992:
993: pointlight_from[0] = 12.0;
994: pointlight_from[1] = -7.0;
995: pointlight_from[2] = 8.5;
996: distantlight_from[0] = 12.0;
997: distantlight_from[1] = -7.0;
998: distantlight_from[2] = 8.5;
999: distantlight2_from[0] = 3.0;
1000: distantlight2_from[1] = 2.0;
1001: distantlight2_from[2] = 8.5;
1002:
1003: distantlight_to[0] = 0.0;
1004: distantlight_to[1] = 0.0;
1005: distantlight_to[2] = 0.0;
1006:
1007: intensity = 60.0;
1008: pointLight = [[N3DLight allocFromZone:[camera zone]] init];
1009: [pointLight makePointFrom:pointlight_from intensity:intensity];
1010: [camera addLight:pointLight];
1011:
1012: intensity = 0.6;
1013: distantLight = [[N3DLight allocFromZone:[camera zone]] init];
1014: [distantLight makeDistantFrom:distantlight_from to:distantlight_to intensity:intensity];
1015: [camera addLight:distantLight];
1016:
1017: intensity = 0.9;
1018: distantLight2 = [[N3DLight allocFromZone:[camera zone]] init];
1019: [distantLight2 makeDistantFrom:distantlight2_from to:distantlight_to intensity:intensity];
1020: [camera addLight:distantLight2];
1021:
1022: intensity = 0.15;
1023: ambientLight = [[N3DLight allocFromZone:[camera zone]] init];
1024: [ambientLight makeAmbientWithIntensity:intensity];
1025: [camera addLight:ambientLight];
1026: }
1027:
1028: /*
1029: * These methods are called as the IB file is unarchived. We override them to
1030: * store these outlets in arrays, since IB doesnt know how to declare arrays
1031: * of outlets.
1032: */
1033: - setEquationX:obj { equation[X] = obj; return self; }
1034: - setEquationY:obj { equation[Y] = obj; return self; }
1035: - setEquationZ:obj { equation[Z] = obj; return self; }
1036: - setMinUSlider:obj { minUVSlider[U] = obj; return self; }
1037: - setMinVSlider:obj { minUVSlider[V] = obj; return self; }
1038: - setMaxUSlider:obj { maxUVSlider[U] = obj; return self; }
1039: - setMaxVSlider:obj { maxUVSlider[V] = obj; return self; }
1040: - setMinUText:obj { minUVText[U] = obj; return self; }
1041: - setMinVText:obj { minUVText[V] = obj; return self; }
1042: - setMaxUText:obj { maxUVText[U] = obj; return self; }
1043: - setMaxVText:obj { maxUVText[V] = obj; return self; }
1044:
1045: @end
1046:
1047: /* little utility proc to write out the float value of a control */
1048: static void writeCellFloat(Cell *obj, NXTypedStream *ts) {
1049: float val;
1050:
1051: val = [obj floatValue];
1052: NXWriteType(ts, "f", &val);
1053: }
1054:
1055: /* Opens a stream on the document regardless of whether its a doc wrapper. */
1056: static NXTypedStream *openDocStream(const char *filename, int mode) {
1057: NXTypedStream *ts = NULL;
1058: struct stat statInfo;
1059: char buffer[MAXPATHLEN+1];
1060:
1061: if (stat(filename, &statInfo) == 0) {
1062: if (statInfo.st_mode & S_IFDIR) {
1063: strcpy(buffer, filename);
1064: strcat(buffer, DOC_NAME);
1065: ts = NXOpenTypedStreamForFile(buffer, mode);
1066: } else {
1067: ts = NXOpenTypedStreamForFile(filename, mode);
1068: }
1069: }
1070: return ts;
1071: }
1072:
1073: /* removes a directory, removing anything inside it. Does not recurse */
1074: static int removeFile(const char *file) {
1075: DIR *dirp;
1076: struct stat st;
1077: struct direct *dp;
1078: char *leaf = NULL;
1079: char path[MAXPATHLEN+1];
1080:
1081: if (!stat(file, &st)) {
1082: if ((st.st_mode & S_IFMT) == S_IFDIR) {
1083: dirp = opendir(file);
1084: for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
1085: if (strcmp(dp->d_name, ".") && strcmp(dp->d_name, "..")) {
1086: if (!leaf) {
1087: strcpy(path, file);
1088: strcat(path, "/");
1089: leaf = path + strlen(path);
1090: }
1091: strcpy(leaf, dp->d_name);
1092: if (unlink(path)) {
1093: closedir(dirp);
1094: return -1;
1095: }
1096: }
1097: }
1098: return rmdir(file);
1099: } else {
1100: return unlink(file);
1101: }
1102: }
1103:
1104: return -1;
1105: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.