This is StatusContour.m in view mode; [Download] [Up]
/* * Copyright (C) 1993 Robert Davis * * This program is free software; you can redistribute it and/or * modify it under the terms of Version 2, or any later version, of * the GNU General Public License as published by the Free Software * Foundation. */ static char RCSId[]="$Id: StatusContour.m,v 1.10 1993/05/18 03:55:42 davis Exp $"; #import "DoubleObject.h" #import "DoubleValueSortedList.h" #import "StatusContour.h" #define MAX_DISCRETE_LEVELS 30 extern int draw_contour; extern int contour_kind; extern int contour_pts; extern int contour_order; extern int contour_levels; extern int levels_kind; extern double levels_list[MAX_DISCRETE_LEVELS]; extern int label_contours; @implementation Status (Contour) - initContour { levelDefs = nil; return self; } - freeContour { if (levelDefs) [[levelDefs freeObjects] free]; return self; } - resetCurrentContour { contourBase = NO; contourSurface = NO; s_contour_kind = CONTOUR_KIND_LINEAR; s_contour_pts = 5; s_contour_order = 4; s_contour_levels = 5; s_levels_kind = LEVELS_AUTO; s_levelsSeries.start = -1.0; s_levelsSeries.incr = .25; s_levelsSeries.end = 1.0; s_label_contours = YES; if (levelDefs) [levelDefs freeObjects]; else { levelDefs = [[DoubleValueSortedList allocFromZone:zone] init]; [levelDefs setMax:MAX_DISCRETE_LEVELS]; } return self; } - applyCurrentContour { int i; if (!contourBase && !contourSurface) draw_contour = CONTOUR_NONE; else if (contourBase && contourSurface) draw_contour = CONTOUR_BOTH; else if (contourBase) draw_contour = CONTOUR_BASE; else if (contourSurface) draw_contour = CONTOUR_SRF; contour_kind = s_contour_kind; contour_pts = s_contour_pts; contour_order = s_contour_order; switch (levels_kind = s_levels_kind) { case LEVELS_INCREMENTAL: levels_list[0] = s_levelsSeries.start; levels_list[1] = s_levelsSeries.incr; contour_levels = (s_levelsSeries.end - s_levelsSeries.start) / s_levelsSeries.incr; break; case LEVELS_DISCRETE: contour_levels = [levelDefs count]; for (i = 0; i < contour_levels; i++) levels_list[i] = [[levelDefs objectAt:i] doubleValue]; break; default: contour_levels = s_contour_levels; } label_contours = s_label_contours; return self; } - grabCurrentContour { int i, maxi; switch (draw_contour) { case CONTOUR_NONE: contourBase = contourSurface = NO; break; case CONTOUR_BASE: contourBase = YES; contourSurface = NO; break; case CONTOUR_SRF: contourBase = NO; contourSurface = YES; break; default: contourBase = YES; contourSurface = YES; break; } switch (s_levels_kind = levels_kind) { case LEVELS_INCREMENTAL: s_levelsSeries.start = levels_list[0]; s_levelsSeries.incr = levels_list[1]; s_levelsSeries.end = (contour_levels * levels_list[1]) +levels_list[0]; s_contour_levels = contour_levels; break; case LEVELS_DISCRETE: maxi = [levelDefs count] - 1; for (i = 0; i < contour_levels; i++) { if (i <= maxi) [[levelDefs objectAt:i] setDoubleValue:levels_list[i]]; else { DoubleObject *dobj = [[DoubleObject allocFromZone:zone] initFromDouble:levels_list[i]]; if ([levelDefs addObjectIfDoubleAbsent:dobj] == NX_NOT_IN_LIST) [dobj free]; } } s_contour_levels = [levelDefs count]; break; case LEVELS_AUTO: s_contour_levels = contour_levels; break; } s_contour_pts = contour_pts; s_contour_order = contour_order; s_levels_kind = levels_kind; s_label_contours = label_contours; return self; } - setContourBase:(BOOL) cond { if (contourBase != cond) { contourBase = cond; [self reportSettingsChange:self]; } return self; } - (BOOL) contourBase { return contourBase; } - setContourSurface:(BOOL) cond { if (contourSurface != cond) { contourSurface = cond; [self reportSettingsChange:self]; } return self; } - (BOOL) contourSurface { return contourSurface; } - setContourKind:(int) anInt { if (anInt != s_contour_kind) { s_contour_kind = anInt; [self reportSettingsChange:self]; } return self; } - (int) contourKind; { return s_contour_kind; } - setContourPoints:(int) anInt { if ((anInt != s_contour_pts) && (anInt > 0)) { s_contour_pts = anInt; [self reportSettingsChange:self]; } return self; } - (int) contourPoints { return s_contour_pts; } - setContourOrder:(int) anInt { if ((anInt != s_contour_order) && (anInt >= 2) && (anInt <= 10)) { s_contour_order = anInt; [self reportSettingsChange:self]; } return self; } - (int) contourOrder { return s_contour_order; } - setContourLevels:(int) anInt { if (anInt != [self contourLevels] && (anInt > 0)) { if (s_levels_kind == LEVELS_INCREMENTAL) { s_levelsSeries.end = (anInt * s_levelsSeries.incr) + s_levelsSeries.start; } else if (s_levels_kind == LEVELS_AUTO) { s_contour_levels = anInt; } [self reportSettingsChange:self]; } return self; } - (int) contourLevels { switch (s_levels_kind) { case LEVELS_INCREMENTAL: return (s_levelsSeries.end -s_levelsSeries.start) /s_levelsSeries.incr; case LEVELS_DISCRETE: return [levelDefs count]; default: return s_contour_levels; } } - setContourLevelsKind:(int) anInt; { if (anInt != s_levels_kind) { s_levels_kind = anInt; [self reportSettingsChange:self]; } return self; } - (int) contourLevelsKind { return s_levels_kind; } - setContourLevelsStart:(double)aDouble { if (aDouble != s_levelsSeries.start) { s_levelsSeries.start = aDouble; [self reportSettingsChange:self]; } return self; } - (double)contourLevelsStart { return s_levelsSeries.start; } - setContourLevelsIncr:(double)aDouble { if (aDouble && (aDouble != s_levelsSeries.incr)) { s_levelsSeries.incr = aDouble; [self reportSettingsChange:self]; } return self; } - (double)contourLevelsIncr { return s_levelsSeries.incr; } - setContourLevelsEnd:(double)aDouble { if (aDouble != s_levelsSeries.end) { s_levelsSeries.end = aDouble; [self reportSettingsChange:self]; } return self; } - (double)contourLevelsEnd { return s_levelsSeries.end; } - (DoubleValueSortedList *)levelDefs { return levelDefs; } - setContourInKey:(BOOL) cond { if (cond != s_label_contours) { s_label_contours = cond; [self reportSettingsChange:self]; } return self; } - (BOOL)contourInKey { return s_label_contours; } // Shuts up the compiler about unused RCSId - (const char *) rcsid { return RCSId; } @end
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.