![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to SortApp.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 / SortingInAction|
Return to SortApp.m CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / SortingInAction |
1.1 root 1:
2: /*
3: * This class is in charge of application-wide activity such as handling the
4: * main menu commands, enabling and disabling controls and managing the tick
5: * counter display. It is also responsible for receiving drawing requests
6: * from the sort threads. When any thread needs to draw, it conjures up a
7: * simple Mach message which it sends to the drawing port that the SortApp
8: * monitors. The SortApp will have the appropriate view do the necessary
9: * drawing.
10: *
11: * Author: Julie Zelenski, NeXT Developer Support
12: * You may freely copy, distribute and reuse the code in this example.
13: * NeXT disclaims any warranty of any kind, expressed or implied, as to
14: * its fitness for any particular use.
15: */
16:
17: #import <appkit/appkit.h>
18: #import "SortApp.h"
19: #import "SortController.h"
20: #import "GenericSort.h"
21: #import "SortView.h"
22: #import <mach/cthreads.h>
23: #import <string.h>
24:
25:
26: /* Global variables shared across several class/threads. */
27:
28: BOOL Abort; // global variable to signal abort
29: int TickCount; // global variable of current tick count
30: mutex_t TickLock; // mutual exclusion to protect TickCount
31: condition_t TickUpdated; // signaled when TickCount is increased
32:
33:
34: @implementation SortApp
35:
36:
37: + initialize;
38: /* +initialize is sent to the factory object for SortApp before any
39: * other messages are sent. This is a good place to allocate and initialize
40: * the global variables.
41: */
42: {
43: if (self == [SortApp class]) {
44: Abort = NO;
45: TickCount = 0;
46: TickLock = mutex_alloc();
47: TickUpdated = condition_alloc();
48: }
49: return self;
50: }
51:
52:
53: + new;
54: {
55: self = [super new];
56: teNum = (DPSTimedEntry)0;
57: return self;
58: }
59:
60:
61:
62: /* TARGET-ACTION METHODS */
63:
64: - info:sender
65: /*
66: * The info panel is a separate nib module and only loaded on demand.
67: */
68: {
69: if (!infoPanel) {
70: if (![self loadNibSection:"InfoPanel.nib" owner:self withNames:NO]) {
71: NXLogError ("Could not load InfoPanel.nib");
72: }
73: }
74: [infoPanel makeKeyAndOrderFront:self];
75: return self;
76: }
77:
78:
79: - help:sender
80: /*
81: * The help panel is a separate nib module and only loaded on demand.
82: */
83: {
84: if (!helpPanel) {
85: if (![self loadNibSection:"HelpPanel.nib" owner:self withNames:NO]) {
86: NXLogError ("Could not load HelpPanel.nib");
87: }
88: }
89: [helpPanel makeKeyAndOrderFront:self];
90: return self;
91: }
92:
93:
94: - go:sender
95: /*
96: * This button gets the whole thing going. It disables the controls that
97: * will be inactive while the sort is running, resets the tick counter, and
98: * asks the SortController to start the trial. The SortController will launch
99: * a thread to generate the data and run the sorts, so this method will return
100: * almost immediately. That way the user interface of the program remains
101: * responsive. The user can stop the sort, change the speed, go look at the
102: * Info panel, whatever! When a sort is running, this button becomes the Stop
103: * button, used to cancel a sort in progress.
104: */
105: {
106: if (!strcmp([sender icon],"Stop")) // if sorting, this is "Stop" button
107: return [self stop:self];
108: if ([[goButton window] makeFirstResponder:[goButton window]]) {
109: if ([sortController startSort]) { // if trial got started ok
110: [self setControlsEnabled:NO];
111: [messageField setStringValue:
112: [stringTable valueForStringKey:"Data"]];
113: [tickField setIntValue:0];
114: }
115: }
116: return self;
117: }
118:
119:
120: - stop:sender
121: /*
122: * This method cancels a sort in progress the whole thing going. It stops
123: * the tick counter and sets the global variable Abort to YES. The sorting
124: * threads continually check this variable and when the recognize it they
125: * send one last message to the drawPort which will display the canceled
126: * sort. When they have all check in, the method allFinished will do any
127: * necessary clean up.
128: */
129: {
130: Abort = YES; // threads will pick up on this & report back when killed
131: [messageField setStringValue:[stringTable valueForStringKey:"Canceled"]];
132: condition_broadcast(TickUpdated);
133: [self stopTickCounter];
134: return self;
135: }
136:
137:
138: - setControlsEnabled:(BOOL)value;
139: /* This method is called to disable all the inactive controls in the parameter
140: * window while a sort is in progress (the data set size, percent sorted, etc).
141: * This method is also called to enable those controls when the sorts have
142: * finished.
143: */
144: {
145: [[performRadios window] disableFlushWindow];
146: [performRadios setEnabled:value];
147: [dataSetMatrix setEnabled:value];
148: [algorithmMatrix setEnabled:value];
149: [tickValueMatrix setEnabled:value];
150: [tickMatrix setEnabled:value];
151: if (value)
152: [goButton setIcon:"Go!"];
153: else
154: [goButton setIcon:"Stop"];
155: [[[performRadios window] reenableFlushWindow] flushWindow];
156: return self;
157: }
158:
159:
160: - allFinished;
161: /* This method is sent by the SortController when it has verified that
162: * all sorts have finished in the current trial. It will stop the tick
163: * counter, re-enable the controls, and reset Abort to NO.
164: */
165: {
166: [self stopTickCounter];
167: [self setControlsEnabled:YES];
168: if (!Abort)
169: [messageField setStringValue:[stringTable valueForStringKey:"Done"]];
170: Abort = NO;
171: return self;
172: }
173:
174:
175: - setTickField:anObject
176: /*
177: * The tickField is a text field on the animation window that displays the
178: * tick count. When a sort is running, a timed entry is called every second
179: * to update the tick field. The timed entry runs at a priority one higher
180: * than NXMODALRESPTHRESHOLD. Because of this, the tick field is updated even
181: * during a modal response loop (such as changing the speed slider).
182: */
183: {
184: tickField = anObject;
185: [tickField allocateGState]; // for more efficient lock/unlock focus
186: return self;
187: }
188:
189:
190: static void updateTick (teNum,now,self)
191: DPSTimedEntry teNum;
192: double now;
193: SortApp *self;
194: {
195: mutex_lock(TickLock);
196: [self->tickField setIntValue:TickCount]; // display current tick count
197: mutex_unlock(TickLock);
198: }
199:
200:
201: - startTickCounter;
202: /* This method is called to reset the tick count to zero and to kick off the
203: * timed entry that will update the tick field display every second.
204: */
205: {
206: TickCount = 0;
207: if (teNum)
208: DPSRemoveTimedEntry(teNum);
209: teNum = DPSAddTimedEntry(1.0, &updateTick, self, NX_MODALRESPTHRESHOLD +1);
210: return self;
211: }
212:
213:
214: - stopTickCounter;
215: /* This method is called to remove the timed entry that has been updating the
216: * tick field every second. The tick field will display the current tick
217: * count.
218: */
219: {
220: if (teNum)
221: DPSRemoveTimedEntry(teNum);
222: teNum = (DPSTimedEntry)0;
223: [tickField setIntValue:TickCount];
224: return self;
225: }
226:
227:
228: - stringTable;
229: /* This method simply returns the string table for other objects which need to
230: * access strings.
231: */
232: {
233: return stringTable;
234: }
235:
236: - draw:(simpleMsg *)msg;
237: /* This is the method called by the message handler to do draw requests from
238: * the sorting threads. The messages are configured so that the msg_id field
239: * of the message header indicates what type of message it is (swap, move,
240: * compare, or finished). The first integer in the message is the sortNum
241: * which is the unique integer for the sort sending the message. This integer
242: * can be passed to the SortController to get the Sort object for that sort,
243: * which can be used to get its SortView. The other integers passed in the
244: * message are the parameters for the different draw messages (the values to
245: * swap, the positions to compare, etc). The SortApp then messages the
246: * appropriate SortView, passing the parameters, and the SortView will do the
247: * drawing.
248: */
249: {
250: id view;
251:
252: view = [[sortController findSortWithNum:msg->sortNum] view];
253: switch(msg->h.msg_id) {
254: case SORTING_MSG: if (!Abort) [messageField setStringValue:
255: [stringTable valueForStringKey:"Sorting"]];
256: break;
257: case COMPARE_MSG: [view compare:msg->position[0] value:msg->value[0]
258: with:msg->position[1] value:msg->value[1]];
259: break;
260: case SWAP_MSG: [view swap:msg->position[0] value:msg->value[0]
261: with:msg->position[1] value:msg->value[1]];
262: break;
263: case MOVE_MSG: [view moveValue:msg->value[0] to:msg->position[0]
264: oldValue:msg->value[1]];
265: break;
266: case FINISHED_MSG: [view displayFinished];
267: [sortController sortFinished:msg->sortNum];
268: break;
269: }
270: return self;
271: }
272:
273: static void msgHandler(msg,self)
274: simpleMsg *msg;
275: id self;
276: {
277: [self draw:msg];
278: }
279:
280:
281: - (port_t)drawPort;
282: /* This method returns the port allocated by the main thread. All drawing
283: * messages are sent to this port.
284: */
285: {
286: return drawPort;
287: }
288:
289:
290: /* DELEGATE METHODS */
291:
292: - appDidInit:sender
293: /* This method allocates the port for the main thread where all drawing
294: * messages are sent. Then, it adds the port to those monitored by the
295: * application. Whenever a message is sent to this port, the handler
296: * function is called to draw the message. This port is registered at a
297: * priority of one greater than NX_MODAL RESPTHRESHOLD. Because of this,
298: * the drawing messages will continue to be processed, even during a modal
299: * response loop (such as changing the speed slider). The speed slider sends
300: * message continuously so you can dynamically change the speed and immediately
301: * see the effects of those changes.
302: */
303: {
304: port_allocate(task_self(), &drawPort);
305: DPSAddPort(drawPort,msgHandler,sizeof(simpleMsg),self,NX_MODALRESPTHRESHOLD +1);
306: return self;
307: }
308:
309: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.