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