diff options
Diffstat (limited to 'applications/rview/rviewUtils.cpp')
| -rw-r--r-- | applications/rview/rviewUtils.cpp | 3630 |
1 files changed, 3630 insertions, 0 deletions
diff --git a/applications/rview/rviewUtils.cpp b/applications/rview/rviewUtils.cpp new file mode 100644 index 0000000..762ee10 --- /dev/null +++ b/applications/rview/rviewUtils.cpp @@ -0,0 +1,3630 @@ +/* +* This file is part of rasdaman community. +* +* Rasdaman community is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* Rasdaman community is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with rasdaman community. If not, see <http://www.gnu.org/licenses/>. +* +* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann / +rasdaman GmbH. +* +* For more information please see <http://www.rasdaman.org> +* or contact Peter Baumann via <baumann@rasdaman.com>. +/ + +/** +* PURPOSE: +* +* Central definitions of shared objects and constants, global tool functions. +* +* - All menu codes used in the program (MENU_...) +* - Global tool functions for handling collections, base types, projection +* strings, X events, ... . See ``Global functions''. +* - rviewFrame class which must be the base class of all frames used in rView. +* - rviewFrameMgr class for handling all of rView's frames (dispatching events +* etc) +* - rviewMultiline class for displaying several lines of non-editable text. +* - rviewDialog class which is the base class for all rView's dialog windows. +* - rviewErrorbox class, derived from rviewDialog. +* - rviewProgress class, derived from rviewDialog. +* - rviewResults class for displaying database results and dispatching object +* viewers. Relies on code provided by rviewMDD for scaling/resampling/endian +* conversions. +* - rviewAbout class for displaying information about rView itself. +* - rviewStringSet class for displaying a set of strings in a scrollable +* list box. +* +* COMMENTS: +* none +*/ + + +// Was file included via header? Then mask out all non-template code +#if (!defined(EARLY_TEMPLATE) || !defined(__EXECUTABLE__)) + +// Standard wxWindows preamble. +#ifdef __GNUG__ +#pragma implementation +#endif + + +// changed in wxWindows 2.4.2: +//#include "wx_prec.h" +#include <wx/wxprec.h> + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + + +#ifndef WX_PRECOMP +#include <wx/wx.h> +#endif + +// #include "wb_timer.h" -- PB 2006-jan-01 + + +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include <iostream.h> + + + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#endif + + +#include "raslib/rmdebug.hh" +#include "raslib/primitivetype.hh" +#include "raslib/structuretype.hh" + +#include "rviewUtils.hh" +#include "rviewMDD.hh" +#include "rviewPrefs.hh" +#include "rviewColMap.hh" +#include "rviewDModes.hh" +#include "rviewOSection.hh" +#include "rviewTypes.hh" +#include "rviewThumb.hh" +#include "rviewSound.hh" +#include "rviewTypeMan.hh" +#include "labelManager.hh" + + +#ifdef __VISUALC__ +const int rview_window_extra_height = 24; +const int rview_choice_sub_width = 0; +#else +const int rview_window_extra_height = 0; +const int rview_choice_sub_width = 32; +#endif + + + + + + +/* + * Global data + */ + +// Base type to string translation tables + +#if (MAXIMUM_DIMENSIONS != 4) +#error "Adapt tables for MAXIMUM DIMENSIONS!" +#endif + +// String names of base types +char *rviewBaseTypes[] = { + "none", + "Boolean", + "Char", + "Octet", + "Short", + "UShort", + "Long", + "ULong", + "RGBPixel", + "Float", + "Double" +}; + +// String names of objects of baseType x and dimension y (-> rviewBaseType) +char *rviewTypeNames[][MAXIMUM_DIMENSIONS] = { + {"?", "?", "?", "?"}, + {"BoolString", "BoolImage", "BoolCube", "BoolCube4"}, + {"GreyString", "GreyImage", "GreyCube", "GreyCube4"}, + {"OctetString", "OctetImage", "OctetCube", "OctetCube4"}, + {"ShortString", "ShortImage", "ShortCube", "ShortCube4"}, + {"UShortString", "UShortImage", "UShortCube", "UShortCube4"}, + {"LongString", "LongImage", "LongCube", "LongCube4"}, + {"ULongString", "ULongImage", "ULongCube", "ULongCube4"}, + {"RGBString", "RGBImage", "RGBCube", "RGBCube4"}, + {"FloatString", "FloatImage", "FloatCube", "FloatCube4"}, + {"DoubleString", "DoubleImage" "DoubleCube", "DoubleCube4"} +}; + +// The same for sets +char *rviewSetNames[][MAXIMUM_DIMENSIONS] = { + {"?", "?", "?", "?"}, + {"BoolSet1", "BoolSet", "BoolSet3", "BoolSet4"}, + {"GreySet1", "GreySet", "GreySet3", "GreySet4"}, + {"OctetSet1", "OctetSet", "OctetSet3", "OctetSet4"}, + {"ShortSet1", "ShortSet", "ShortSet3", "ShortSet4"}, + {"UShortSet1", "UShortSet", "UShortSet3", "UShortSet4"}, + {"LongSet1", "LongSet", "LongSet3", "LongSet4"}, + {"ULongSet1", "ULongSet", "ULongSet3", "ULongSet4"}, + {"RGBSet1", "RGBSet", "RGBSet3", "RGBSet4"}, + {"FloatSet1", "FloatSet", "FloatSet3", "FloatSet4"}, + {"DoubleSet1", "DoubleSet", "DoubleSet3", "DoubleSet4"} +}; + + + +unsigned char lowerCaseTable[256]; + + + +// Various support classes +rviewFrameMgr *frameManager = NULL; + +labelManager *lman = NULL; + + + + + + +/* + * GLOBAL functions + */ + +// Frees all memory allocated by a collection descriptor. +void rviewDeleteCollection(collection_desc *coll) +{ + if (coll != NULL) + { + int i; + collection_desc *ptr = coll; + + if (coll->collName != NULL) delete [] coll->collName; + if (coll->collType != NULL) delete [] coll->collType; + if (coll->collInfo != NULL) delete [] coll->collInfo; + + for (i=0; i<coll->number; i++) + { + if (coll->mddObjs != NULL) + { + if (!coll->mddObjs[i].mdd.is_null()) + { + coll->mddObjs[i].mdd.destroy(); + } + } + else if (coll->strObjs != NULL) + { + if (coll->strObjs[i] != NULL) + { + delete [] coll->strObjs[i]; + } + } + } + if (coll->mddObjs != NULL) delete [] coll->mddObjs; + if (coll->strObjs != NULL) delete [] coll->strObjs; + + delete coll; + } +} + + + +/* + * Support function for rviewParseProjection + */ +static const char *rviewParseIndexMapping(const char *s, int idx, int dims, r_Point *mapIndex) +{ + const char *b, *d; + r_Range value; + + b = s+1; + if (mapIndex == NULL) + { + cerr << "Mode doesn't support reordering of dimensions." << endl; + } + + value = (r_Range)strtol(b, (char**)&d, 0); + if (b == d) return NULL; + + if ((value < 0) || (value >= (r_Range)dims)) + { + cerr << "Bad dimension index " << value << endl; + value = (r_Range)idx; + } + if (mapIndex != NULL) (*mapIndex)[idx] = value; + + while ((*d == ' ') || (*d == '\t')) d++; + if (*d == ']') return d+1; + return NULL; +} + + +/* + * Translate a projection string (now RasDaMan style, i.e. things + * like *:* are also allowed) into two diagonal r_Points. Returns + * number of dimension of projection string for success, 0 for an error. + */ + +int rviewParseProjection(const r_Minterval &interv, r_Point &pt1, r_Point &pt2, const char *projString, unsigned int *freeDims, r_Point *mapIndex) +{ + int dims, i; + const char *b, *d; + r_Range value; + + if (freeDims != NULL) *freeDims = 0; + dims = interv.dimension(); + pt1 = r_Point(dims); pt2 = r_Point(dims); + + b = projString; i = 0; + while (*b != '\0') + { + while ((*b == ' ') || (*b == '\t')) b++; + if (*b == ',') b++; + while ((*b == ' ') || (*b == '\t')) b++; + if (*b == '\0') break; + if (i >= dims) return 0; + if (*b == '*') + { + pt1[i] = interv[i].low(); pt2[i] = interv[i].high(); b++; + } + else + { + value = (r_Range)strtol(b, (char**)&d, 0); + // no valid number found? + if (b == d) return 0; + b = d; + if ((value < interv[i].low()) || (value > interv[i].high())) return 0; + pt1[i] = value; pt2[i] = value; + } + if (mapIndex != NULL) (*mapIndex)[i] = i; + while ((*b == ' ') || (*b == '\t')) b++; + if (*b == '[') // Explicit index-mapping? + { + if ((b = rviewParseIndexMapping(b, i, dims, mapIndex)) == NULL) return 0; + } + else if (*b == ':') // the upper boundaries follow after a colon. + { + if (freeDims != NULL) *freeDims |= (1<<i); + b++; + if (*b == '\0') break; + if (*b == '*') + { + value = interv[i].high(); b++; + } + else + { + value = (r_Range)strtol(b, (char**)&d, 0); + if (b == d) return 0; + b = d; + if ((value < interv[i].low()) || (value > interv[i].high())) return 0; + } + pt2[i] = value; + while ((*b == ' ') || (*b == '\t')) b++; + if (*b == '[') + { + if ((b = rviewParseIndexMapping(b, i, dims, mapIndex)) == NULL) return 0; + } + } + i++; + } + return i; +} + + + + + +/* + * Determine the base type of an MDD object, returning a simple identifier. + */ +rviewBaseType rviewGetBasetype(r_Object *obj) +{ + rviewBaseType baseType; + const r_Type *bt; + + baseType = rbt_none; + + // New type schema... + bt = obj->get_type_schema(); + if (bt->type_id() == r_Type::MARRAYTYPE) + bt = ((r_GMarray*)obj)->get_base_type_schema(); + else if (bt->type_id() == r_Type::COLLECTIONTYPE) + bt = ((r_Collection<r_Ref_Any>*)obj)->get_element_type_schema(); + + if (bt != NULL) + { + if (((r_Type*)bt)->isStructType()) + { + if (((r_Base_Type*)bt)->size() == 3) + baseType = rbt_rgb; + else + baseType = rbt_none; + } + else + { + r_Primitive_Type *pt = (r_Primitive_Type *)bt; + + switch (pt->type_id()) + { + case r_Primitive_Type::BOOL: baseType = rbt_bool; break; + case r_Primitive_Type::CHAR: baseType = rbt_char; break; + case r_Primitive_Type::OCTET: baseType = rbt_uchar; break; + case r_Primitive_Type::SHORT: baseType = rbt_short; break; + case r_Primitive_Type::USHORT: baseType = rbt_ushort; break; + case r_Primitive_Type::LONG: baseType = rbt_long; break; + case r_Primitive_Type::ULONG: baseType = rbt_ulong; break; + case r_Primitive_Type::FLOAT: baseType = rbt_float; break; + case r_Primitive_Type::DOUBLE: baseType = rbt_double; break; + default: baseType = rbt_none; break; + } + } + } + else + { + char *name = (char*)(obj->get_type_name()); + if (name != NULL) + { + if (strcmp(name, "GreyImage") == 0) baseType = rbt_char; + else if (strcmp(name, "BoolImage") == 0) baseType = rbt_bool; + else if (strcmp(name, "RGBImage") == 0) baseType = rbt_rgb; + } + } + return baseType; +} + + + +/* + * rviewPrintTypedCell() prints the contents of a cell with a given base type into the buffer, + * returning the number of characters written. + */ + +// For internal use only +static void printPrimitiveCell(r_Primitive_Type *primType, char **buff, char *data, int numberBase) +{ + char *b = *buff; + + switch (numberBase) + { + case 8: + switch (primType->type_id()) + { + case r_Primitive_Type::BOOL: + b += sprintf(b, "%3o", *((r_Boolean*)data)); break; + case r_Primitive_Type::CHAR: + b += sprintf(b, "%3o", *((r_Char*)data)); break; + case r_Primitive_Type::OCTET: + b += sprintf(b, "%3o", *((r_Octet*)data)); break; + case r_Primitive_Type::SHORT: + b += sprintf(b, "%6o", *((r_Short*)data)); break; + case r_Primitive_Type::USHORT: + b += sprintf(b, "%6o", *((r_UShort*)data)); break; + case r_Primitive_Type::LONG: + b += sprintf(b, "%11lo", *((r_Long*)data)); break; + case r_Primitive_Type::ULONG: + b += sprintf(b, "%11lo", *((r_ULong*)data)); break; + case r_Primitive_Type::FLOAT: + b += sprintf(b, "%011o", *((r_Long*)data)); break; + case r_Primitive_Type::DOUBLE: + b += sprintf(b, "%011o:%011o", ((r_Long*)data)[0], ((r_Long*)data)[1]); break; + default: + break; + } + break; + case 16: + switch (primType->type_id()) + { + case r_Primitive_Type::BOOL: + b += sprintf(b, "%02x", *((r_Boolean*)data)); break; + case r_Primitive_Type::CHAR: + b += sprintf(b, "%02x", *((r_Char*)data)); break; + case r_Primitive_Type::OCTET: + b += sprintf(b, "%02x", *((r_Octet*)data)); break; + case r_Primitive_Type::SHORT: + b += sprintf(b, "%04x", *((r_Short*)data)); break; + case r_Primitive_Type::USHORT: + b += sprintf(b, "%04x", *((r_UShort*)data)); break; + case r_Primitive_Type::LONG: + b += sprintf(b, "%08x", *((r_Long*)data)); break; + case r_Primitive_Type::ULONG: + b += sprintf(b, "%08x", *((r_ULong*)data)); break; + case r_Primitive_Type::FLOAT: + b += sprintf(b, "%08x", *((r_Long*)data)); break; + case r_Primitive_Type::DOUBLE: + b += sprintf(b, "%08x:%08x", ((r_Long*)data)[0], ((r_Long*)data)[1]); break; + default: + break; + } + break; + default: + switch (primType->type_id()) + { + case r_Primitive_Type::BOOL: + b += sprintf(b, "%3d", *((r_Boolean*)data)); break; + case r_Primitive_Type::CHAR: + b += sprintf(b, "%3d", *((r_Char*)data)); break; + case r_Primitive_Type::OCTET: + b += sprintf(b, "%3d", *((r_Octet*)data)); break; + case r_Primitive_Type::SHORT: + b += sprintf(b, "%5d", *((r_Short*)data)); break; + case r_Primitive_Type::USHORT: + b += sprintf(b, "%5d", *((r_UShort*)data)); break; + case r_Primitive_Type::LONG: + b += sprintf(b, "%10ld", *((r_Long*)data)); break; + case r_Primitive_Type::ULONG: + b += sprintf(b, "%10ld", *((r_ULong*)data)); break; + case r_Primitive_Type::FLOAT: + b += sprintf(b, "%g", *((r_Float*)data)); break; + case r_Primitive_Type::DOUBLE: + b += sprintf(b, "%g", *((r_Double*)data)); break; + default: + break; + } + break; + } + *buff = b; +} + +// For internal use only +void printStructuredCell(r_Structure_Type *structType, char **buff, char *data, int numberBase) +{ + r_Type *newType; + unsigned long off; + char *b; + + b = *buff; + *b++ = '{'; + r_Structure_Type::attribute_iterator iter(structType->defines_attribute_begin()); + while (iter != structType->defines_attribute_end()) + { + newType = (*iter).type_of().clone(); + off = (*iter).offset(); + + if (newType->isStructType()) + { + r_Structure_Type *newStructType = (r_Structure_Type*)newType; + printStructuredCell(newStructType, &b, data + off, numberBase); + } + else + { + r_Primitive_Type *newPrimType = (r_Primitive_Type*)newType; + printPrimitiveCell(newPrimType, &b, data + off, numberBase); + } + delete newType; + *b++ = ','; + iter++; + } + b[-1] = '}'; *b = '\0'; + *buff = b; +} + +int rviewPrintTypedCell(const r_Type *baseType, char *buffer, char *data, int numberBase) +{ + char *b = buffer; + + if (((r_Type*)baseType)->isStructType()) + { + r_Structure_Type *structType = (r_Structure_Type*)baseType; + printStructuredCell(structType, &b, data, numberBase); + } + else + { + r_Primitive_Type *primType = (r_Primitive_Type*)baseType; + printPrimitiveCell(primType, &b, data, numberBase); + } + return (int)(b - buffer); +} + + + + +/* + * Quicksort a char *[] + */ + +#define QUICKSORT_STRING_SWAP(x,y) h=array[x]; array[x]=array[y]; array[y]=h; + +void rviewQuicksortStrings(char *array[], int from, int to) +{ + while (from < to) + { + int i, j; + char *h; + + j = (from+to)/2; + QUICKSORT_STRING_SWAP(from, j); j=from; + for (i=from+1; i<=to; i++) + { + if (strcmp(array[i], array[from]) < 0) + { + j++; + QUICKSORT_STRING_SWAP(i, j); + } + } + QUICKSORT_STRING_SWAP(from, j); + + if ((j-from) < (to-j)) + { + rviewQuicksortStrings(array, from, j-1); + from = j+1; + } + else + { + rviewQuicksortStrings(array, j+1, to); + to = j-1; + } + } +} + + + +/* + * Init character lookup tables (e.g. lower case table) + */ +void rviewInitCharacterTables(void) +{ + int i; + + for (i=0; i<256; i++) lowerCaseTable[i] = tolower(i); +} + + + +#define LOOKUP_KEYWORD_CORE \ + while (count != 0) \ + { \ + b = (const unsigned char*)(kti[pos].keyword); \ + d = (const unsigned char*)key; \ + while (TRANSLATE_CHARACTER(b) == TRANSLATE_CHARACTER(d)) \ + { \ + if (*b == 0) break; b++; d++; \ + } \ + if ((*b == 0) && (*d == 0)) return kti[pos].ident; \ + if (TRANSLATE_CHARACTER(b) >= TRANSLATE_CHARACTER(d)) \ + { \ + pos -= step; if (pos < 0) pos = 0; \ + } \ + else \ + { \ + pos += step; if (pos >= tabsize) pos = tabsize - 1; \ + } \ + step = (step+1) >> 1; count >>= 1; \ + } + +/* + * Lookup a keyword in a SORTED keyword_to_ident table. Case sensitivity + * is optional but has to match the sorting order of the table, of course. + */ +int rviewLookupKeyword(const char *key, const keyword_to_ident_c *kti, int tabsize, bool caseSensitive) +{ + int pos, step, count; + const unsigned char *b, *d; + + count = tabsize; + pos = (tabsize + 1) >> 1; if (pos >= tabsize) pos = tabsize - 1; + step = (pos + 1) >> 1; + if (caseSensitive) + { +#define TRANSLATE_CHARACTER(x) (*x) + LOOKUP_KEYWORD_CORE; +#undef TRANSLATE_CHARACTER + } + else + { +#define TRANSLATE_CHARACTER(x) lowerCaseTable[(*x)] + LOOKUP_KEYWORD_CORE; +#undef TRANSLATE_CHARACTER + } + return -1; +} + + + +/* Helper function making sure min/max of the init structure is used by the + colourspace mapper */ + +static void rviewEnsureCspaceRange(colourspaceMapper *csmap, const colourspace_params *cp) +{ + // make sure the min/max values are taken from the init structure as well + if (cp != NULL) + { + // assume it's initialized if either values differs from 0 + if ((cp->minVal != 0.0) || (cp->maxVal != 0.0)) + { + colourspace_params par; + csmap->getParameters(&par); + par.minVal = cp->minVal; + par.maxVal = cp->maxVal; + // do not do auto-update, otherwise we're stuck in an infinite loop + csmap->colourspaceChanged(&par, FALSE); + //cout << "MIN " << par.minVal << ", MAX " << par.maxVal << endl; + } + } +} + + +/* + * Check whether colourspace mapping is possible for the given + * base type and return 1 if so. *csmap must be a pointer to the + * colourspaceMapper to use or NULL if there isn't one yet in + * which case a new one will have been created on returning 1. + * If cmap == NULL the function just returns 0 or 1. If the int* + * arguments are not NULL they're set up correctly on exit too. + */ +int rviewCheckInitCspace(rviewBaseType baseType, colourspaceMapper **csmap, r_Ref<r_GMarray> &mddObj, bool fullRange, r_Minterval *domain, int w, int *newPitch, int *newDepth, int *newPad, int *virtualPitch, const colourspace_params *cp) +{ + colourspace_params par; + + switch (baseType) + { + case rbt_char: + case rbt_uchar: + case rbt_short: + case rbt_ushort: + if (csmap == NULL) return 1; + if (*csmap == NULL) + { + memcpy(&par, (cp == NULL) ? &(prefs->csp) : cp, sizeof(colourspace_params)); + *csmap = new colourspaceMapper(mddObj, baseType, &par, fullRange, domain); + } + else + (*csmap)->bindMapper(mddObj, baseType, fullRange, domain, cp); + + rviewEnsureCspaceRange(*csmap, cp); + + // always call this and let the mapper sort out whether it has to update + (*csmap)->buildCSTab15(); + if (newPitch == NULL) return 1; + if (*newPad < 32) *newPad = 32; + *newDepth = 15; + switch (*newPad) + { + case 32: *newPitch = (w*2 + 3) & ~3; break; + case 64: *newPitch = (w*2 + 7) & ~7; break; + case 128: *newPitch = (w*2 + 15) & ~15; break; + case 256: *newPitch = (w*2 + 31) & ~31; break; + default: + cerr << "Bad pad " << *newPad << endl; + return 0; + } + if (virtualPitch != NULL) *virtualPitch = *newPitch; + return 1; + break; + case rbt_long: + case rbt_ulong: // using 24bpp only makes sense for long + case rbt_float: + case rbt_double: // ... or larger types + { + int baseWidth; + + baseWidth = 4*w; + + if (csmap == NULL) return 1; + if (*csmap == NULL) + { + memcpy(&par, (cp == NULL) ? &(prefs->csp) : cp, sizeof(colourspace_params)); + *csmap = new colourspaceMapper(mddObj, baseType, &par, fullRange, domain); + } + else + (*csmap)->bindMapper(mddObj, baseType, fullRange, domain, cp); + + rviewEnsureCspaceRange(*csmap, cp); + + (*csmap)->buildCSTab24(); + if (newPitch == NULL) return 1; + if (*newPad < 32) *newPad = 32; + *newDepth = 32; + switch (*newPad) + { + case 32: *newPitch = (baseWidth + 3) & ~3; break; + case 64: *newPitch = (baseWidth + 7) & ~7; break; + case 128: *newPitch = (baseWidth + 15) & ~15; break; + case 256: *newPitch = (baseWidth + 31) & ~31; break; + default: cerr << "Bad pad " << *newPad << endl; + return 0; + } + if (virtualPitch != NULL) + *virtualPitch = (baseType == rbt_double) ? 2*(*newPitch) : (*newPitch); + return 1; + } + break; + default: break; + } + return 0; +} + + + +/* + * Smart number conversion functions. They also understand the 0x + * prefix and convert the number correctly. + */ + +long asctol(const char *str) +{ + return stringtol(str, NULL); +} + +int asctoi(const char *str) +{ + return (int)stringtol(str, NULL); +} + +double asctof(const char *str) +{ + return stringtof(str, NULL); +} + +long stringtol(const char *str, char **endptr) +{ + const char *b = str; + long value; + + while (isspace((unsigned int)(*b))) b++; + if ((b[0] == '0') && ((b[1] == 'x') || (b[1] == 'X'))) + { + b += 2; + value = strtol(b, endptr, 16); + } + else + { + value = strtol(b, endptr, 10); + } + if ((endptr != NULL) && ((const char*)(*endptr) == b)) *endptr = (char*)str; + return value; +} + +double stringtof(const char *str, char **endptr) +{ + const char *b = str; + double value; + + while (isspace((unsigned int)(*b))) b++; + if ((b[0] == '0') && ((b[1] == 'x') || (b[1] == 'X'))) + { + b += 2; + value = (double)strtol(b, endptr, 16); + } + else + { + value = strtod(b, endptr); + } + if ((endptr != NULL) && ((const char*)(*endptr) == b)) *endptr = (char*)str; + return value; +} + + + + + +/* + * Dynamic string class for easy management of dynamically allocated string storage + */ + +const char DynamicString::emptyString[] = ""; + + +DynamicString::DynamicString(void) +{ + myString = NULL; +} + +DynamicString::DynamicString(const DynamicString &ms) +{ + if (ms.myString == NULL) + { + myString = NULL; + } + else + { + myString = new char[strlen(ms.myString) + 1]; + strcpy(myString, ms.myString); + } +} + + +DynamicString::DynamicString(const char *str) +{ + if (str == NULL) + { + myString = NULL; + } + else + { + myString = new char[strlen(str) + 1]; + strcpy(myString, str); + } +} + + +DynamicString::~DynamicString(void) +{ + if (myString != NULL) delete [] myString; +} + + +DynamicString &DynamicString::first(const char *str, unsigned int num) +{ + if (myString != NULL) + { + delete [] myString; myString = NULL; + } + if (num != 0) + { + unsigned int len = strlen(str); + if (len > num) len = num; + myString = new char[len + 1]; + strncpy(myString, str, len); + myString[len] = '\0'; + } + return *this; +} + + +DynamicString &DynamicString::operator=(const DynamicString &ms) +{ + if (myString != NULL) + { + delete [] myString; myString = NULL; + } + if (ms.myString != NULL) + { + myString = new char[strlen(ms.myString) + 1]; + strcpy(myString, ms.myString); + } + return *this; +} + + +DynamicString &DynamicString::operator=(const char *str) +{ + if (myString != NULL) + { + delete [] myString; myString = NULL; + } + if (str != NULL) + { + myString = new char[strlen(str) + 1]; + strcpy(myString, str); + } + return *this; +} + + +const char *DynamicString::ptr(void) const +{ + if (myString == NULL) return emptyString; + return myString; +} + +DynamicString::operator const char*(void) const +{ + return ptr(); +} + + +bool DynamicString::operator==(const DynamicString &str) const +{ + return (strcmp(ptr(), str.ptr()) == 0); +} + + +bool DynamicString::operator==(const char *str) const +{ + return (strcmp(ptr(), str) == 0); +} + + + + + + +/* + * Generic handler function for events like button- and key-presses. + * It passes the event to the frameManager which then broadcasts + * it to all the frames it knows. If a frame recognizes obj as one + * of its children it claims the event, thus aborting the broadcast. + */ + +void rviewEventHandler(wxObject &obj, wxEvent &evt) +{ + if (frameManager != NULL) + frameManager->broadcastEvent(obj, evt); + //cout << endl; +} + + + + + + +/* + * rviewFrame member functions. + * This is an abstract class that is only used for deriving other + * (window/frame) classes from it. + */ + +rviewFrame::rviewFrame(wxFrame *parent, char *title, int x, int y, int w, int h) : wxFrame(parent, title, x, y, w, h) +{ + RMDBGONCE( 3, RMDebug::module_applications, "rviewFrame", "rviewFrame( " << this << ", ...)" ); + + if (frameManager != NULL) + frameManager->registerFrame(this); + + parentFrame = NULL; + // Init the size with illegal values to make sure the first OnSize gets through + frameWidth = -1; frameHeight = -1; + // All the frame's children should be destroyed when the frame is destroyed. + frames = new rviewFrameMgr(TRUE); +} + + +rviewFrame::~rviewFrame(void) +{ + RMDBGONCE( 3, RMDebug::module_applications, "rviewFrame", "~rviewFrame() " << this ); + + delete frames; + + if (frameManager != NULL) + frameManager->deregisterFrame(this); + + if (parentFrame != NULL) + { + parentFrame->deregisterChild(this); + } +} + + +const char *rviewFrame::getFrameName(void) const +{ + return "rviewFrame"; +} + +rviewFrameType rviewFrame::getFrameType(void) const +{ + return rviewFrameTypeGeneric; +} + + +void rviewFrame::setParent(rviewFrame *parent) +{ + parentFrame = parent; +} + + +void rviewFrame::registerChild(rviewFrame *child) +{ + child->setParent(this); + frames->registerFrame(child); +} + + +void rviewFrame::deregisterChild(rviewFrame *child) +{ + frames->deregisterFrame(child); + child->setParent(NULL); +} + + +// Called by the global frame manager when the application is about to die. +int rviewFrame::requestQuit(int level) +{ + // Default action on a hard quit: die + if (level != 0) + { + // Do not delete the children, that would upset the frame manager's loop. + frames->setDeleteMode(FALSE); setParent(NULL); + //delete this; + Close(TRUE); + } + return 0; +} + + + +// Called on a user event +int rviewFrame::userEvent(const user_event &ue) +{ + // Default action: nothing. Overload function in derived class if you're + // interested in user messages. + return 0; +} + + +// Called by the rviewFrameMgr object to determine which frame receives an event +int rviewFrame::checkobj(wxObject &obj) +{ + return checkobj_rec((wxWindow*)this, obj); +} + + +// Used internally by rviewFrame::checkobj(); don't access directly. Checks +// recursively all the children of a given frame against obj. +int rviewFrame::checkobj_rec(wxWindow *whence, wxObject &obj) +{ + if (&obj == (wxObject*)whence) return 1; + else + { + int i, n; + wxList *list; + + list = whence->GetChildren(); + n = list->Number(); + for (i=0; i<n; i++) + { + if (checkobj_rec((wxWindow*)(list->Nth(i)->Data()), obj) != 0) return 1; + } + } + return 0; +} + + + +// Virtual function. If a derived frame class should refuse to die in some +// circumstances, it must overload his function. +bool rviewFrame::OnClose(void) +{ + return TRUE; +} + + +void rviewFrame::childMouseEvent(wxWindow *child, wxMouseEvent &mevt) +{ + // by default this is ignored. +} + + + + + + +/* + * rviewFrameMgr member functions + */ + +rviewFrameMgr::rviewFrameMgr(void) +{ + listLength = 0; deleteChildren = FALSE; + frameList = NULL; tailList = NULL; +} + + +rviewFrameMgr::rviewFrameMgr(bool delChild) +{ + listLength = 0; deleteChildren = delChild; + frameList = NULL; tailList = NULL; +} + + +rviewFrameMgr::~rviewFrameMgr(void) +{ + int i; + frame_list *list, *last; + + // Deletes all the frames and their children + // Unlink all frames first! Otherwise there'll be trouble because the Frame Manager + // will loop over the frames and delete them; but if the frames have a valid parent + // they will deregister there which will screw up the Frame Manager's frame list + // _during the loop_ and hence crash. + list = frameList; + for (i=0; i<listLength; i++) + { + last = list; list = list->next; + // If it's the global frame manager it shouldn't delete the children, that's + // wxWindows' job. If it's a manager local to a frame it should delete all + // that frame's children, however. + if (deleteChildren) + { + last->frame->setParent(NULL); + //delete last->frame; + last->frame->Close(TRUE); + } + delete last; + } +} + + +void rviewFrameMgr::registerFrame(rviewFrame *client) +{ + frame_list *entry; + + //cout << "frameManager::registerFrame(" << (void*)client << ")" << endl; + if ((entry = new frame_list) == NULL) + { + //cerr << "frameManager: Unable to claim memory!\n" << endl; + return; + } + + entry->frame = client; entry->next = NULL; + + if (frameList == NULL) + { + frameList = entry; tailList = entry; + } + else + { + tailList->next = entry; + tailList = entry; + } + listLength++; + //cout << "Frame manager: Added frame to list. New length = " << listLength << endl; + //cout << "(anchor = " << (void*)frameList << ", tail = " << (void*)tailList << ")" << endl; +} + + +void rviewFrameMgr::deregisterFrame(rviewFrame *client) +{ + int i; + frame_list *list, *last; + + //cout << "frameManager::deregisterFrame(" << (void*)client << ")" << endl; + list = frameList; last = NULL; + for (i=0; i<listLength; i++) + { + if (list->frame == client) + { + list = list->next; + if (last == NULL) + { + delete frameList; frameList = list; last = list; + } + else + { + delete last->next; last->next = list; + } + listLength--; + if (last == NULL) tailList = NULL; + else + { + while (last->next != NULL) last = last->next; + tailList = last; + } + //cout << "Frame manager: Removed frame from list. New length = " << listLength << endl; + //cout << "(anchor = " << (void*)frameList << ", tail = " << (void*)tailList << ")" << endl; + return; + } + last = list; list = list->next; + } +} + + + +int rviewFrameMgr::numberOfFrames(void) const +{ + return listLength; +} + + + +void rviewFrameMgr::setDeleteMode(bool delChild) +{ + deleteChildren = delChild; +} + + +// Issues re-label requests to all frames. +void rviewFrameMgr::labelAll(void) +{ + int i; + frame_list *list; + + //cout << "frameManager::labelAll()" << endl; + list = frameList; + for (i=0; i<listLength; i++) + { + list->frame->label(); + list = list->next; + } +} + + + +/* + * Broadcasts the event to all frames until one claims the event by returning + * a value != 0. Warning: this function has to be re-entrant! + */ + +void rviewFrameMgr::broadcastEvent(wxObject &obj, wxEvent &evt) +{ + int i; + frame_list *list; + + // Note: the broadcast has to go in two steps, first determining which frame + // knows the object, then terminating the loop and calling the object as the + // last action. The reason is that this function is re-entrant and would + // crash badly if the frame list changed during the loop. + //cout << "frameManager::broadcastEvent()" << endl; + list = frameList; + for (i=0; i<listLength; i++) + { + //cout << "Broadcast to " << (void*)(list->frame) << endl; + if (list->frame->checkobj(obj) != 0) + { + //cout << "Frame manager: object known by frame " << (void*)list->frame << endl; + break; + } + list = list->next; + } + //cout << "Frame manager: broadcast " << ((list == NULL) ? "failed" : "successful") << endl; + + // Now call the frame. + if (list != NULL) {list->frame->process(obj, evt);} + // Uncomment this if there's any doubt it's re-entrant + //cout << "frameManager::broadcastEvent done" << endl; +} + + + +/* + * Broadcast a quit-message to all frames but the first one (the main frame). There + * are currently two levels, 0 means the frames can yet refuse to die by returning a + * value != 0, every other level doesn't give them this option. Returns 0 for failure. + * This must only be called for the _global_ frame manager! + */ + +int rviewFrameMgr::broadcastQuit(int level) +{ + int i, status; + frame_list *list; + + list = frameList->next; status = 1; + for (i=1; i<listLength; i++) + { + //if (level > 0) cout << "delete " << (void*)list << endl; + if (list->frame->requestQuit(level) != 0) status = 0; + list = list->next; + } + if (level == 0) return status; + + //cout << "Hard quit OK" << endl; + return 1; +} + + + +/* + * Broadcast a user event to all frames. + */ + +int rviewFrameMgr::broadcastUserEvent(const user_event &ue) +{ + int i, status; + frame_list *list; + + list = frameList; status = 0; + for (i=0; i<listLength; i++) + { + //cout << "broadcast to " << (void*)(list->frame) << endl; + status += list->frame->userEvent(ue); + list = list->next; + } + return status; // number of clients that recognised the event. +} + + + + + +/* + * rviewMultiline member functions + */ + +const int rviewMultiline::multiline_ppc10 = 63; + +void rviewMultiline::setupVariables(wxPanel *Panel, int X, int Y, int H, int Lines) +{ + int i; + + parent = Panel; lines = Lines; + if ((msg = new wxMessage *[lines]) == NULL) + { + cerr << "rviewMultiline::setupVariables(): " << lman->lookup("errorMemory") << endl; + return; + } + for (i=0; i<lines; i++) msg[i] = NULL; + + x = X; y = Y; lHeight = H; +} + + +rviewMultiline::rviewMultiline(wxPanel *Panel, int X, int Y, int H, int Lines) +{ + setupVariables(Panel, X, Y, H, Lines); +} + + +rviewMultiline::rviewMultiline(wxPanel *Panel, const char *Message, int X, int Y, int W, int H, int Lines) +{ + setupVariables(Panel, X, Y, H, Lines); + + rebuild(Message, W); +} + + +rviewMultiline::~rviewMultiline(void) +{ + // The wxMessage items have been created as children of the panel and will + // be deleted by the panel later on. So just delete the array. + delete [] msg; +} + + +void rviewMultiline::rebuild(const char *Message, int W) +{ + int length, i, cpl, pos; + char *buffer, *b, *base; + + if (msg == NULL) return; + + //cout << "rviewMultiline::rebuild()" << endl; + + cpl = (10*W) / multiline_ppc10; + + if ((buffer = new char[cpl + 1]) == NULL) + { + cerr << "rviewMultiline::rebuild(): " << lman->lookup("errorMemory") << endl; + return; + } + + length = strlen(Message); base = (char*)Message; + + for (i=0, pos=y; (length > 0) && (i<lines); i++, pos+=lHeight) + { + if (length > cpl) + { + b = base + cpl; + while ((*b > 32) && (b > base)) b--; + if (b <= base) b = base + cpl; else b++; + } + else + { + b = base + length; + } + memcpy(buffer, base, (int)(b - base)); buffer[(int)(b - base)] = '\0'; + //cout << buffer << endl; + if (msg[i] == NULL) + { + msg[i] = new wxMessage(parent, buffer, x, pos, W, lHeight, 0, "message"); + } + else + { + msg[i]->SetSize(x, pos, W, lHeight, 0); + msg[i]->SetLabel(buffer); + } + length -= (int)(b - base); base = b; + } + while (i<lines) + { + if (msg[i] != NULL) {delete msg[i]; msg[i] = NULL;} + i++; + } + delete [] buffer; +} + + + +int rviewMultiline::getMessageHeight(void) const +{ + int i; + + for (i=0; i<lines; i++) if (msg[i] == NULL) break; + return(i*lHeight); +} + + + +/* + * More convenient interface to standard widgets + */ + +rviewText::rviewText(wxPanel *parent, const char *value, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, (char*)value, x, y, w, h, wxTE_PROCESS_ENTER) +{ +} + +rviewText::rviewText(long style, wxPanel *parent, const char *value, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, (char*)value, x, y, w, h, style) +{ +} + +rviewText::rviewText(wxPanel *parent, const DynamicString &value, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, NULL, x, y, w, h, wxTE_PROCESS_ENTER) +{ + wxText::SetValue((char*)value.ptr()); +} + +rviewText::rviewText(wxPanel *parent, int value, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, NULL, x, y, w, h, wxTE_PROCESS_ENTER) +{ + char buffer[32]; + sprintf(buffer, "%d", value); + wxText::SetValue(buffer); +} + + +rviewText::rviewText(wxPanel *parent, long value, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, NULL, x, y, w, h, wxTE_PROCESS_ENTER) +{ + char buffer[32]; + sprintf(buffer, "%ld", value); + wxText::SetValue(buffer); +} + + +rviewText::rviewText(wxPanel *parent, double value, bool sciForm, char *label, int x, int y, int w, int h) : wxText(parent, (wxFunction)rviewEventHandler, label, NULL, x, y, w, h, wxTE_PROCESS_ENTER) +{ + char buffer[32]; + sprintf(buffer, (sciForm) ? "%g" : "%f", value); + wxText::SetValue(buffer); +} + +void rviewText::SetValue(char *value) +{ + wxText::SetValue(value); +} + +void rviewText::SetValue(const char *value) +{ + wxText::SetValue((char*)value); +} + +void rviewText::SetValue(const DynamicString &value) +{ + wxText::SetValue((char*)value.ptr()); +} + +void rviewText::SetValue(int value) +{ + char buffer[32]; + sprintf(buffer, "%d", value); + wxText::SetValue(buffer); +} + +void rviewText::SetValue(unsigned int value) +{ + char buffer[32]; + sprintf(buffer, "%u", value); + wxText::SetValue(buffer); +} + +void rviewText::SetValue(long value) +{ + char buffer[32]; + sprintf(buffer, "%ld", value); + wxText::SetValue(buffer); +} + +void rviewText::SetValue(double value, bool sciForm) +{ + char buffer[32]; + sprintf(buffer, (sciForm) ? "%g" : "%f", value); + wxText::SetValue(buffer); +} + +char *rviewText::GetValue(void) +{ + return wxText::GetValue(); +} + +void rviewText::GetValue(DynamicString &value) +{ + value = wxText::GetValue(); +} + +void rviewText::GetValue(int &value) +{ + value = asctoi(wxText::GetValue()); +} + +void rviewText::GetValue(long &value) +{ + value = asctol(wxText::GetValue()); +} + +void rviewText::GetValue(float &value) +{ + value = asctof(wxText::GetValue()); +} + +void rviewText::GetValue(double &value) +{ + value = asctof(wxText::GetValue()); +} + + + +rviewButton::rviewButton(wxPanel *parent, char *label, int x, int y, int w, int h, long style) : wxButton(parent, (wxFunction)rviewEventHandler, label, x, y, w, h, style) +{ +} + +rviewChoice::rviewChoice(wxPanel *parent, int n, char *choices[], char *label, int x, int y, int w, int h, long style) : wxChoice(parent, (wxFunction)rviewEventHandler, label, x, y, w, h, n, choices, style) +{ +} + +// hacked version to make up for wxWindows' lack of const +rviewChoice::rviewChoice(wxPanel *parent, int n, const char *choices[], char *label, int x, int y, int w, int h, long style) : wxChoice(parent, (wxFunction)rviewEventHandler, label, x, y, w, h, n, (char**)choices, style) +{ +} + +rviewCheckBox::rviewCheckBox(wxPanel *parent, char *label, int x, int y, int w, int h) : wxCheckBox(parent, (wxFunction)rviewEventHandler, label, x, y, w, h) +{ +} + +rviewRadioButton::rviewRadioButton(wxPanel *parent, char *label, bool value, int x, int y, int w, int h) : wxRadioButton(parent, (wxFunction)rviewEventHandler, label, value, x, y, w, h) +{ +} + +rviewScrollBar::rviewScrollBar(wxPanel *parent, int x, int y, int w, int h, long style) : wxScrollBar(parent, (wxFunction)rviewEventHandler, x, y, w, h, style) +{ +} + +rviewSlider::rviewSlider(wxPanel *parent, int value, int min_val, int max_val, int width, char *label, int x, int y, long style) : wxSlider(parent, (wxFunction)rviewEventHandler, label, value, min_val, max_val, x, y, style) +{ +} + + + +/* + * The special slider class when arbitrary mouse events are required. + */ + +const int rviewSpecialSlider::dflt_barwidth = 30; +const int rviewSpecialSlider::dflt_barheight = 10; +const int rviewSpecialSlider::dflt_width = 200; +const int rviewSpecialSlider::dflt_height = rviewSpecialSlider::dflt_barheight + 2*rviewSpecialSlider::dflt_border; +const int rviewSpecialSlider::dflt_border = 4; + +rviewSpecialSlider::rviewSpecialSlider(rviewFrame *logParent, wxPanel *parent, int val, int min, int max, int width, const char *label) : + wxCanvas(parent, -1, -1, (width==-1) ? dflt_width : width, dflt_height, wxRETAINED), + background(0x00,0x00,0x00), + foreground(0x00,0xff,0x00), + wellground(0xff,0xff,0xff), + outline(0x00,0x00,0x00), + labelColour(*(parent->GetLabelColour())), + bback(background, wxTRANSPARENT), + bfore(foreground, wxSOLID), + bwell(wellground, wxSOLID), + outlinePen(outline, 1, wxSOLID), + labelFont(12, wxROMAN, wxNORMAL, wxNORMAL), + myLabel(label) +{ + wxBrush *dcb; + logicalParent = logParent; + border = dflt_border; + barwidth = dflt_barwidth; barheight = dflt_barheight; + value = val; + vmin = min; vmax = max; + if (vmax <= vmin) + vmax = vmin+1; + dcb = ((wxPanel*)GetParent())->GetDC()->GetBackground(); + bback = wxBrush(dcb->GetColour(), dcb->GetStyle()); + SetBackground(&bback); + SetFont(&labelFont); + GetDC()->GetTextExtent(myLabel.ptr(), &textx, &texty); +} + +rviewSpecialSlider::~rviewSpecialSlider(void) +{ +} + +int rviewSpecialSlider::GetMin(void) const +{ + return vmin; +} + +int rviewSpecialSlider::GetMax(void) const +{ + return vmax; +} + +int rviewSpecialSlider::GetValue(void) const +{ + return value; +} + +void rviewSpecialSlider::SetRange(int min, int max) +{ + if (min < max) + { + vmin = min; vmax = max; + if (value < vmin) + value = vmin; + if (value > vmax) + value = vmax; + Refresh(TRUE); + } +} + +void rviewSpecialSlider::SetValue(int val) +{ + if ((vmin <= val) && (val <= vmax)) + { + float barx, bary, bheight, newbx; + + getBarParams(barx, bary, bheight); + value = val; + getBarParams(newbx, bary, bheight); + updateWell(barx, newbx, bary, bheight); + } +} + +void rviewSpecialSlider::SetLabel(const char *label) +{ + myLabel = label; + GetDC()->GetTextExtent(myLabel.ptr(), &textx, &texty); + Refresh(TRUE); +} + +bool rviewSpecialSlider::PositionInWell(float posx, float posy) +{ + int y0, y1; + + GetClientSize(&cwidth, &cheight); + getWellVert(y0, y1); + if (((float)y0 <= posy) && (posy <= (float)y1)) + { + if ((posx >= textx + 2*border) && (posx <= (float(cwidth - border)))) + return TRUE; + } + return FALSE; +} + + +void rviewSpecialSlider::getWellVert(int &y0, int &y1) +{ + y0 = cheight - 2*border - barheight; + if (y0 < 0) + y0 = 0; + y0 += border; + y1 = cheight - border; + if (y1 < y0) + y1 = y0; +} + +void rviewSpecialSlider::getBarParams(float &posx, float &posy, float &height) +{ + int y0, y1; + + GetClientSize(&cwidth, &cheight); + + posx = (float)((cwidth - 3*border - barwidth - textx) * (value-vmin)) / (vmax - vmin); + if (posx < 0) + posx = 0; + /*cout << "cwidth " << cwidth << ", textx " << textx << ", value " << value << ", border " << border + << ", barwidth " << barwidth << ", vmin " << vmin << ", vmax " << vmax << ", posx " << posx << endl;*/ + posx += (float)(2*border + textx); + getWellVert(y0, y1); + posy = (float)y0; + height = (float)(y1 - y0); +} + +int rviewSpecialSlider::calcNewValue(float posx, float posy, int &val, bool checky) +{ + int y0, y1; + + GetClientSize(&cwidth, &cheight); + + getWellVert(y0, y1); + if (!checky || ((float)y0 <= posy) && (posy <= (float)y1)) + { + float rem = (float)(cwidth - 3*border - barwidth - textx); + if (rem < 1.0) + rem = 1.0; + val = (int)((((posx - 2*border - textx) * (vmax - vmin)) / rem) + 0.5) + vmin; + if (val < vmin) + val = vmin; + if (val > vmax) + val = vmax; + + return 0; + } + return -1; +} + + +void rviewSpecialSlider::getUpdateInterval(float oldx, float newx, float &clipx, float &clipw) +{ + if (oldx < newx) + { + clipx = oldx; clipw = newx - oldx + barwidth; + } + else + { + clipx = newx; clipw = oldx - newx + barwidth; + } +} + + +void rviewSpecialSlider::updateWell(float oldx, float newx, float posy, float bheight) +{ + float clipx, clipw; + + getUpdateInterval(oldx, newx, clipx, clipw); + //cout << "CLIP " << clipx << ", " << posy << ", " << clipw << ", " << bheight << endl; + // need to enlarge the clipping region somewhat to make sure everything is redrawn + BeginDrawing(); + SetClippingRegion(clipx, 0, clipw+2, cheight); + //Clear(); + redrawCore(newx, posy, bheight); + DestroyClippingRegion(); + EndDrawing(); +} + + +void rviewSpecialSlider::redrawCore(float x, float y, float bheight) +{ + float extx, exty, nx, ny; + char number[32]; + + // first draw the label + SetFont(&labelFont); + SetTextForeground(&labelColour); + DrawText(myLabel.ptr(), 0, y); + + SetPen(&outlinePen); + SetBrush(&bwell); + DrawRectangle(textx + border, y-border, (float)cwidth - textx - border, bheight + 2*border); + SetBrush(&bfore); + DrawRectangle(x, y, (float)barwidth, bheight); + + // then draw the current value on top + sprintf(number, "%d", value); + GetDC()->GetTextExtent(number, &extx, &exty); + nx = x + (barwidth - extx)/2; ny = y - exty - border; + SetPen(NULL); + // must use a non-transparent brush. Finally found the right one! + SetBrush(((wxPanel*)GetParent())->GetDC()->GetBackground()); + DrawRectangle(0, ny, (float)cwidth, exty); + DrawText(number, nx, ny); +} + + +void rviewSpecialSlider::OnPaint(void) +{ + wxRect rect; + float x, y, bheight; + + getBarParams(x, y, bheight); + + BeginDrawing(); + + wxUpdateIterator upd(this); + while (upd) + { + upd.GetRect(&rect); + redrawCore(x, y, bheight); + upd++; + } + EndDrawing(); +} + +void rviewSpecialSlider::OnEvent(wxMouseEvent &mevt) +{ + int type = mevt.GetEventType(); + float barx, bary, bheight; + float mx, my; + int newVal = value; + + getBarParams(barx, bary, bheight); + mevt.Position(&mx, &my); + if ((type == wxEVENT_TYPE_LEFT_DOWN) || (type == wxEVENT_TYPE_RIGHT_DOWN)) + { + if (mx < barx) + { + if (calcNewValue(barx - barwidth, my, newVal, TRUE) != 0) + newVal = value; + } + else if (mx > barx + barwidth) + { + if (calcNewValue(barx + barwidth, my, newVal, TRUE) != 0) + newVal = value; + } + } + else if (type == wxEVENT_TYPE_MOTION) + { + if (mevt.LeftIsDown() || mevt.RightIsDown()) + { + if (calcNewValue(mx - barwidth/2, my, newVal, FALSE) != 0) + { + newVal = value; + } + } + } + if (newVal != value) + { + float newbx, newby, newbh; + + value = newVal; + getBarParams(newbx, newby, newbh); + updateWell(barx, newbx, bary, bheight); + + // additionally we build a regular command event + wxCommandEvent cmd(wxEVENT_TYPE_SLIDER_COMMAND); + //OnCommand(*GetParent(), cmd); + logicalParent->process(*this, cmd); + } + // the entire point of this class is to always pass on the actual mouse event to the parent + logicalParent->childMouseEvent(this, mevt); +} + + + + + + +/* + * rviewDialog member functions. + */ + +const int rviewDialog::dialog_width = 300; +const int rviewDialog::dialog_height = 170; +const int rviewDialog::dialog_border = 8; +const int rviewDialog::dialog_buttonsx = 80; +const int rviewDialog::dialog_buttonsy = 30; +const int rviewDialog::dialog_bheight = rviewDialog::dialog_buttonsy + 16; +const int rviewDialog::dialog_lines = 8; +const int rviewDialog::dialog_lheight = 20; + + +// The strings passed to this function may be labels (first char is a backslash) +// or explicit text. +rviewDialog::rviewDialog(const char *title, const char *message, int buttonNo, const char *buttons[]): + rviewFrame(NULL, "", 0, 0, dialog_width, dialog_height) +{ + int i, x, y; + char *string; + + panel = NULL; buttonNumber = 0; buttonPressed = 0; + + buttonText = new char *[buttonNo + 2]; + but = new rviewButton *[buttonNo]; + + if ((buttonText == NULL) || (but == NULL)) + { + cerr << "rviewDialog::rviewDialog(): " << lman->lookup("errorMemory") << endl; + if (buttonText != NULL) delete [] buttonText; + if (but != NULL) delete [] but; + return; + } + + buttonNumber = buttonNo; + + buttonText[0] = (char*)title; buttonText[1] = (char*)message; + for (i=0; i<buttonNumber; i++) + { + but[i] = NULL; buttonText[i+2] = (char*)buttons[i]; + } + + // Only memorize those strings that are a label identifier (first char a backslash) + for (i=0; i<2+buttonNumber; i++) + { + if (buttonText[i] != NULL) + { + // Don't combine the two ifs with && : there is no defined evaluation order for && ! + // Always memorize the message text. + if ((buttonText[i][0] == '\\') || (i == 1)) + { + // We remove the backslash but need one additional char for the + // line terminator ==> strlen -1 + 1. + if ((string = new char[strlen(buttonText[i]) + ((i==1) ? 1 : 0)]) == NULL) + { + cerr << "rviewDialog::rviewDialog(): " << lman->lookup("errorMemory") << endl; + while (--i >= 0) + { + if (buttonText[i] != NULL) delete [] buttonText[i]; + } + delete [] buttonText; buttonText = NULL; + delete [] but; but = NULL; + buttonNumber = 0; + return; + } + strcpy(string, buttonText[i] + ((i==1) ? 0 : 1)); buttonText[i] = string; + //cout << "buttonText[" << i << "] = " << buttonText[i] << endl; + } + else buttonText[i] = NULL; + } + } + + GetClientSize(&x, &y); + + panel = new wxPanel((wxWindow*)this, 100, 100, 10, 10); + + msg = new rviewMultiline(panel, dialog_border, dialog_border, dialog_lheight, dialog_lines); + + //cout << x << ", " << y << endl; + + // If the strings are not labels then set them now statically, otherwise they will + // be set in the following label() call. + if (title[0] != '\\') + { + SetTitle((char*)title); + } + + // Now handle all buttons. + for (i=0; i<buttonNumber; i++) + { + but[i] = new rviewButton(panel); + if (buttons[i][0] != '\\') + { + but[i]->SetLabel((char*)buttons[i]); + } + else // do this for the button size. + { + but[i]->SetLabel(lman->lookup(buttons[i]+1)); + } + } + + OnSize(x, y); + + label(); + + Show(TRUE); +} + + + +rviewDialog::~rviewDialog(void) +{ + int i; + + // Widgets that were created as children of other wx items are deleted by those items. + // They mustn't be destroyed here! + + if (msg != NULL) delete msg; + //if (panel != NULL) delete panel; + + if (but != NULL) + { + //for (i=0; i<buttonNumber; i++) {if (but[i] != NULL) delete but[i];} + delete [] but; + } + + if (buttonText != NULL) + { + for (i=0; i<2+buttonNumber; i++) {if (buttonText[i] != NULL) delete [] buttonText[i];} + delete [] buttonText; + } +} + + +const char *rviewDialog::getFrameName(void) const +{ + return "rviewDialog"; +} + +rviewFrameType rviewDialog::getFrameType(void) const +{ + return rviewFrameTypeDialog; +} + + +void rviewDialog::OnSize(int w, int h) +{ + int x, y, empty, pos, i; + + RMDBGONCE( 3, RMDebug::module_applications, "rviewDialog", "OnSize( " << x << ", " << h << " )" ); + + GetClientSize(&x, &y); + if ((frameWidth == x) && (frameHeight == y)) return; + frameWidth = x; frameHeight = y; + + x -= 2*dialog_border; y -= dialog_border; + panel->SetSize(0, 0, x, y); + + if (buttonText[1][0] == '\\') + msg->rebuild(lman->lookup(buttonText[1]+1), x); + else + msg->rebuild(buttonText[1], x); + + // Space out the buttons on the available space. + if (buttonNumber == 0) return; + + empty = (x - buttonNumber*dialog_buttonsx) / buttonNumber; + if(empty <0 ) + empty=0; + + pos = empty/2; + + for (i=0; i<buttonNumber; i++) + { + but[i]->SetSize(pos, y - (dialog_bheight + dialog_buttonsy)/2, dialog_buttonsx, dialog_buttonsy); + pos += empty + dialog_buttonsx; + } +} + + + +void rviewDialog::label(void) +{ + int i, x, y; + + //cout << "rviewDialog::label()" << endl; + // If the widgets are labels then set their new values. + + panel->GetClientSize(&x, &y); + if (buttonText[0] != NULL) + { + SetTitle(lman->lookup(buttonText[0])); + } + + // The message is always stored. + if (buttonText[1][0] == '\\') + msg->rebuild(lman->lookup(buttonText[1]+1), x); + else + msg->rebuild(buttonText[1], x); + + for (i=0; i<buttonNumber; i++) + { + if (buttonText[2+i] != NULL) + { + but[i]->SetLabel(lman->lookup(buttonText[2+i])); + } + } +} + + + + +/* + * Process events which are broadcast by the frame manager. + */ + +int rviewDialog::process(wxObject &obj, wxEvent &evt) +{ + int i, type; + + //cout << "rviewDialog::process()" << endl; + for (i=0; i<buttonNumber; i++) + { + if (&obj == (wxObject*)but[i]) break; + } + + if (i >= buttonNumber) return 0; + + type = evt.GetEventType(); + + if (type == wxEVENT_TYPE_BUTTON_COMMAND) + { + buttonPressed = i+1; + } + else + { + buttonPressed = 0; + } + //cout << "rviewDialog::process():" << (void*)this << " Button " << buttonPressed << endl; + + return buttonPressed; +} + + + +/* + * Polling interface to the dialog box. Returns the number of the button that + * was pressed, starting from 1 (0 means none). On reading the button number + * is reset to 0. + */ + +int rviewDialog::GetButton(void) +{ + int val = buttonPressed; + + buttonPressed = 0; + return val; +} + + + + + +/* + * Error box + * (an intrinsically modal special case of a dialog box) + */ + +char *rviewErrorboxDefaultButton[1] = {"\\textOK"}; + +rviewErrorbox::rviewErrorbox(const char *message): rviewDialog("\\errorFrom", message, 1, (const char**)rviewErrorboxDefaultButton) +{ + //place this in log file + cerr << lman->lookup("errorFrom") << ' ' << message << endl; +} + + +rviewErrorbox::rviewErrorbox(const char *title, const char *message, int buttonNo, const char *buttons[]): rviewDialog(title, message, buttonNo, buttons) +{ + //place this in log file + cerr << lman->lookup("errorFrom") << ' ' << message << endl; +} + + +rviewErrorbox::~rviewErrorbox(void) {;} + + +const char *rviewErrorbox::getFrameName(void) const +{ + return "rviewErrorbox"; +} + +rviewFrameType rviewErrorbox::getFrameType(void) const +{ + return rviewFrameTypeErrorbox; +} + + +int rviewErrorbox::activate(void) +{ + int pressed; + + MakeModal(TRUE); + while ((pressed = GetButton()) == 0) ::wxYield(); + MakeModal(FALSE); + return pressed; +} + + +// static member functions +char *rviewErrorbox::buildErrorMessage(const char *message, const char *classname, const char *funcname) +{ + char *buffer, *b; + int bsize = strlen(message) + 1; + + if (classname != NULL) + { + bsize += strlen(classname) + 3; // ": " + + // funcname is ignored unless class name is given + if (funcname != NULL) + bsize += strlen(funcname) + 3; // "::" + } + + buffer = new char[bsize]; + b = buffer; + + if (classname != NULL) + { + b += sprintf(b, "%s", classname); + + if (funcname != NULL) + b += sprintf(b, "::%s", funcname); + + b += sprintf(b, ": "); + } + b += sprintf(b, "%s", message); + + return buffer; +} + + +rviewErrorbox *rviewErrorbox::newErrorbox(const char *message, const char *classname, const char *funcname) +{ + char *msg; + rviewErrorbox *box; + + msg = buildErrorMessage(message, classname, funcname); + box = new rviewErrorbox(msg); + delete [] msg; + + return box; +} + + +rviewErrorbox *rviewErrorbox::newErrorbox(const char *title, const char *message, int buttonNo, const char *buttons[], const char *classname, const char *funcname) +{ + char *msg; + rviewErrorbox *box; + + msg = buildErrorMessage(message, classname, funcname); + box = new rviewErrorbox(msg); + delete [] msg; + + return box; +} + + +int rviewErrorbox::reportError(const char *message, const char *classname, const char *funcname) +{ + rviewErrorbox *box; + int but; + + box = newErrorbox(message, classname, funcname); + but = box->activate(); + box->Close(TRUE); + + return but; +} + + +int rviewErrorbox::reportError(const char *title, const char *message, int buttonNo, const char *buttons[], const char *classname, const char *funcname) +{ + rviewErrorbox *box; + int but; + + box = newErrorbox(title, message, buttonNo, buttons, classname, funcname); + but = box->activate(); + box->Close(TRUE); + + return but; +} + + + + + +/* + * rviewProgress members + */ + +rviewProgress::rviewProgress(const char *message): rviewDialog("\\messageFrom", message, 1, (const char**)rviewErrorboxDefaultButton) +{ + int x, y; + + RMDBGONCE( 3, RMDebug::module_applications, "rviewProgress", "rviewProgress( " << lman->lookup("messageFrom") << message << " )" ); + + GetSize(&x, &y); + y = 2*dialog_border + msg->getMessageHeight() + dialog_bheight; + SetSize(-1, -1, x, y); + + // Have to do this to make sure you actually see anything in the window + // Crude, but nothing else seems to work... + Refresh(TRUE); ::wxYield(); + // Wait 300ms + ::wxStartTimer(); + while (::wxGetElapsedTime(FALSE) < 300) ::wxYield(); +} + + + + +rviewProgress::~rviewProgress(void) {;} + + +int rviewProgress::process(wxObject &obj, wxEvent &evt) +{ + if (rviewDialog::process(obj, evt) != 0) + { + this->Close(TRUE); + return 1; + } + return 0; +} + + +const char *rviewProgress::getFrameName(void) const +{ + return "rviewProgress"; +} + +rviewFrameType rviewProgress::getFrameType(void) const +{ + return rviewFrameTypeProgress; +} + + + + +/* + * rviewResult members + */ + +const int rviewResult::result_x = 0; +const int rviewResult::result_y = 0; +const int rviewResult::result_width = 320; +const int rviewResult::result_height = 296; +const int rviewResult::result_border = 8; +const int rviewResult::result_lheight = 20; +const int rviewResult::result_header = (8 * rviewResult::result_lheight); +const int rviewResult::result_cwidth = 150; +const int rviewResult::result_twidth = 90; +const int rviewResult::result_theight = 30; +const int rviewResult::result_bwidth = 60; +const int rviewResult::result_bheight = 30; + +rviewResult::rviewResult(void): rviewFrame(NULL, "", result_x, result_y, result_width, result_height) +{ + RMDBGONCE( 3, RMDebug::module_applications, "rviewResult", "rviewResult() " << this); + + setupVariables(); + configureGrey(); + Show(FALSE); +} + +rviewResult::rviewResult(collection_desc *collection): rviewFrame(NULL, "", result_x, result_y, result_width, result_height) +{ + setupVariables(); + setCollection(collection); +} + + +rviewResult::~rviewResult(void) +{ + RMDBGONCE( 3, RMDebug::module_applications, "rviewResult", "rviewResult() " << this ); + + int i; + collection_desc *ptr = coll; + user_event ue; + + // give all viewers a chance to clean up + ue.type = usr_mdd_dying; + for (i=0; i<coll->number; i++) + { + ue.data = (void*)&(coll->mddObjs[i].mdd); + frames->broadcastUserEvent(ue); + } + + // All the widgets are deleted automatically. + if (selectedItems != NULL) delete [] selectedItems; + if (typeManager != NULL) {typeManager->unlinkParent(); typeManager->Close(TRUE);} + + rviewDeleteCollection(coll); +} + + +const char *rviewResult::getFrameName(void) const +{ + return "rviewResult"; +} + +rviewFrameType rviewResult::getFrameType(void) const +{ + return rviewFrameTypeResult; +} + + +void rviewResult::setCollection(collection_desc *collection) +{ + int x, y, i; + char res_string[STRINGSIZE]; + + // In case this is called when the frame already displays a result (shouldn't + // normally happen, though) + if (coll != NULL) + { + rviewDeleteCollection(coll); + delete list; + } + coll = collection; + + // Init flags + for (i=0; i<coll->number; i++) + { + coll->mddObjs[i].flags = 0; + } + + GetClientSize(&x, &y); + + list = new wxListBox(panel, (wxFunction)&rviewEventHandler, "", wxMULTIPLE, result_border, result_border + result_header, x, y - result_header, 0, NULL, wxALWAYS_SB | wxLB_MULTIPLE); + + ostrstream memstr(res_string, STRINGSIZE); + for (i=0; i<coll->number; i++) + { + list->Append(mddDescriptorString(memstr, i)); + } + + if (selectedItems != NULL) delete [] selectedItems; + i = (coll->number + 7) >> 3; + if ((selectedItems = new char[i]) == NULL) + { + cerr << "rviewResult::setCollection(): " << lman->lookup("errorMemory") << endl; + this->Close(TRUE); + return; + } + memset(selectedItems, 0, i); + + configureGrey(); + + label(); + + // Force resize + frameWidth = -1; frameHeight = -1; + OnSize(x, y); + + Show(TRUE); +} + + + +char *rviewResult::mddDescriptorString(ostrstream &memstr, int number) +{ + r_GMarray *mdd = coll->mddObjs[number].mdd.ptr(); + r_Data_Format fmt = mdd->get_current_format(); + + memstr.width(3); + memstr << number << ": ("; memstr.width(0); + memstr << mdd->get_type_length() << ") " + << mdd->spatial_domain() << ' ' + << fmt << '\0'; + memstr.seekp(0); + + return memstr.str(); +} + + +void rviewResult::label(void) +{ + char buffer[STRINGSIZE]; + + //cout << "labelling " << (void*)mBar << endl; + + SetTitle(lman->lookup("titleResult")); + + if (mBar != NULL) + { + // Configure all the text in the menu bar + mBar->SetLabel(MENU_RSLT_ITEM_OPENALL, lman->lookup("menRsltItemOpAll")); + mBar->SetLabel(MENU_RSLT_ITEM_THUMBALL, lman->lookup("menRsltItemThumbAll")); + mBar->SetLabel(MENU_RSLT_ITEM_CLOSE, lman->lookup("menRsltItemClose")); + mBar->SetHelpString(MENU_RSLT_ITEM_OPENALL, lman->lookup("helpRsltItemOpAll")); + mBar->SetHelpString(MENU_RSLT_ITEM_THUMBALL, lman->lookup("helpRsltItemThumbAll")); + mBar->SetHelpString(MENU_RSLT_ITEM_CLOSE, lman->lookup("helpRsltItemClose")); + + mBar->SetLabel(MENU_RSLT_SLCT_SLCTALL, lman->lookup("menRsltSlctSlctAll")); + mBar->SetLabel(MENU_RSLT_SLCT_CLEAR, lman->lookup("menRsltSlctClear")); + mBar->SetLabel(MENU_RSLT_SLCT_OPEN, lman->lookup("menRsltSlctOpen")); + mBar->SetLabel(MENU_RSLT_SLCT_THUMB, lman->lookup("menRsltSlctThumb")); + mBar->SetLabel(MENU_RSLT_SLCT_DELETE, lman->lookup("menRsltSlctDel")); + mBar->SetLabel(MENU_RSLT_SLCT_ENDIAN, lman->lookup("menRsltSlctEndian")); + mBar->SetLabel(MENU_RSLT_SLCT_TYPEMAN, lman->lookup("menRsltSlctTypeMan")); + mBar->SetLabel(MENU_RSLT_SLCT_INFO, lman->lookup("menRsltSlctInfo")); + mBar->SetHelpString(MENU_RSLT_SLCT_SLCTALL, lman->lookup("helpRsltSlctSlctAll")); + mBar->SetHelpString(MENU_RSLT_SLCT_CLEAR, lman->lookup("helpRsltSlctClear")); + mBar->SetHelpString(MENU_RSLT_SLCT_OPEN, lman->lookup("helpRsltSlctOpen")); + mBar->SetHelpString(MENU_RSLT_SLCT_THUMB, lman->lookup("helpRsltSlctThumb")); + mBar->SetHelpString(MENU_RSLT_SLCT_DELETE, lman->lookup("helpRsltSlctDel")); + mBar->SetHelpString(MENU_RSLT_SLCT_ENDIAN, lman->lookup("helpRsltSlctEndian")); + mBar->SetHelpString(MENU_RSLT_SLCT_TYPEMAN, lman->lookup("helpRsltSlctTypeMan")); + mBar->SetHelpString(MENU_RSLT_SLCT_INFO, lman->lookup("helpRsltSlctInfo")); + + mBar->SetLabelTop(0, lman->lookup("menRsltItem")); + mBar->SetLabelTop(1, lman->lookup("menRsltSlct")); + } + + if (list != NULL) + { + list->SetLabel(lman->lookup("textResult")); + } + + if (group != NULL) + { + group->SetLabel(lman->lookup("textCollHeader")); + sprintf(buffer, "%s: %s", lman->lookup("textCollName"), (coll->collName == NULL) ? "" : coll->collName); + collName->SetLabel(buffer); + sprintf(buffer, "%s: %s", lman->lookup("textCollType"), (coll->collType == NULL) ? "?" : coll->collType); + collType->SetLabel(buffer); + sprintf(buffer, (coll->collInfo == NULL) ? "" : coll->collInfo); + collInfo->SetLabel(buffer); + + if (choice != NULL) + { + choice->SetLabel(lman->lookup("dispModeLabel")); + } + } + resampBut->SetLabel(lman->lookup("textOK")); + + //cout << "labelled OK" << endl; +} + + + +void rviewResult::OnSize(int w, int h) +{ + if (panel != NULL) + { + int x, y; + + RMDBGONCE( 3, RMDebug::module_applications, "rviewResult", "OnSize( " << w << ", " << h << " )"); + + GetClientSize(&x, &y); + if ((frameWidth == x) && (frameHeight == y)) return; + frameWidth = x; frameHeight = y; + + panel->SetClientSize(x, y); + x -= 2*result_border; y -= 2*result_border; + + if (list != NULL) + list->SetSize(result_border, + result_lheight + result_border + result_header, + x, + y - result_header - result_lheight); + + if (group != NULL) + { + group->SetSize(result_border, + result_border, + x, + result_header); + //group->GetClientSize(&x, &y); + x -= 2*result_border; y -=2*result_border; + if (collName != NULL) + collName->SetSize(2*result_border, + result_lheight + result_border, + x, + result_lheight); + if (collType != NULL) + collType->SetSize(2*result_border, + 2*result_lheight + result_border, + x, + result_lheight); + if (collInfo != NULL) + collInfo->SetSize(2*result_border, + 3*result_lheight + result_border, + x, + result_lheight); + if (choice != NULL) + choice->SetSize(2*result_border, + 4*result_lheight + result_border, + result_cwidth - cbfactor, + result_lheight); + } + scaleMode->SetSize(3*result_border/2, + 6*result_lheight + result_border, + result_cwidth - 2*cbfactor, + result_lheight); + resampText->SetSize(3*result_border/2 + result_cwidth - cbfactor, + 6*result_lheight + result_border, + result_twidth, + result_theight); + resampBut->SetSize(3*result_border/2 + result_cwidth - cbfactor/2 + result_twidth, + 6*result_lheight + result_border, + result_bwidth, + result_bheight); + } +} + + + +void rviewResult::openViewer(int itemNo) +{ + + RMDBGONCE( 3, RMDebug::module_applications, "rviewResult", "openViewer( " << itemNo << " )" ); + + if ((itemNo < 0) || (itemNo >= coll->number)) return; + + rviewDisplay *newDisplay=NULL; + + switch (prefs->lastDisplay) + { + case 0: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_IMGFLAT) == 0) + { + newDisplay = new rviewFlatImage(coll->mddObjs + itemNo); + } + } + break; + case 1: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_IMGVOLM) == 0) + { + newDisplay = new rviewVolumeImage(coll->mddObjs + itemNo); + } + } + break; + case 2: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_IMGOSECT) == 0) + { + newDisplay = new rviewOSectionFullImage(coll->mddObjs + itemNo); + } + } + break; + case 3: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_IMGHGHT) == 0) + { + newDisplay = new rviewHeightImage(coll->mddObjs + itemNo); + } + } + break; + case 4: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_CHART) == 0) + { + newDisplay = new rviewChart(coll->mddObjs + itemNo); + } + } + break; + case 5: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_TABLE) == 0) + { + newDisplay = new rviewTable(coll->mddObjs + itemNo); + } + } + break; + case 6: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_SOUND) == 0) + { + newDisplay = new rviewSoundPlayer(coll->mddObjs + itemNo); + } + } + break; + case 7: + { + if ((coll->mddObjs[itemNo].flags & RVIEW_RESDISP_STRVIEW) == 0) + { + newDisplay = new rviewStringViewer(coll->mddObjs + itemNo); + } + } + break; + default: + cerr << "Unsupported display mode " << prefs->lastDisplay << endl; + return; + } + + if (newDisplay != NULL) + { + if (newDisplay->openViewer() != 0) + newDisplay->Close(TRUE); + else + { + coll->mddObjs[itemNo].flags |= newDisplay->getViewerType(); + registerChild(newDisplay); + } + } +} + + + +/* + * This function must be called whenever the selections of the list box + * change (click / double click) or items in the listbox are modified or + * deleted (this seems to be some wxWindows-internal bug that always + * deselects listbox items if an item was changed). + */ +int rviewResult::updateSelection(void) +{ + int i, changes, sel=-1; + char val; + + if (selectedItems == NULL) return -1; + + changes = 0; + for (i=0; i<coll->number; i++) + { + val = selectedItems[i>>3] & (1<<(i&7)); + if (list->Selected(i)) + { + if (val == 0) {sel=i; changes++;} + selectedItems[i>>3] |= (1<<(i&7)); + } + else + { + if (val != 0) {sel=i; changes++;} + selectedItems[i>>3] &= ~(1<<(i&7)); + } + } + if (changes > 1) + { + cerr << "Warning: more than one selection changed!" << endl; + } + + configureGrey(); + + return sel; +} + + + +void rviewResult::operationPrologue(void) +{ + ::wxBeginBusyCursor(); + ::wxStartTimer(); +} + + +void rviewResult::operationEpilogue(const char *opname) +{ + int elapsed = ::wxGetElapsedTime(); + + ::wxEndBusyCursor(); + + if (opname != NULL) + { + char buffer[STRINGSIZE]; + + sprintf(buffer, "%s \"%s\": %dms", lman->lookup("textOpTime"), opname, elapsed); + cout << buffer << endl; + SetStatusText(buffer); + } +} + + +int rviewResult::parseResampleString(const char *resStr, double *values) +{ + int i; + const char *b; + + b = resStr; i = 0; + while (*b != 0) + { + while ((*b == ' ') || (*b == '\t')) b++; + if (*b == ',') b++; + if (*b != 0) + { + if (values != NULL) values[i] = atof(b); + while ((*b != ' ') && (*b != '\t') && (*b != ',') && (*b != 0)) b++; + i++; + } + } + return i; +} + + +int rviewResult::resampleSelection(void) +{ + int i, j, res; + double *scale; + r_Dimension dim; + r_Minterval oldInterv, useInterv, newInterv; + r_Ref<r_GMarray> newMdd; + rviewBaseType baseType; + char buffer[STRINGSIZE]; + user_event usr; + char *valStr; + int dimString; + int smode; + const char *operation=NULL; + + ostrstream memstr(buffer, STRINGSIZE); + + valStr = resampText->GetValue(); + dimString = parseResampleString(valStr, NULL); + scale = new double[dimString]; + parseResampleString(valStr, scale); + + for (i=0; i<dimString; i++) + { + if (scale[i] <= 0.0) return 0; + if (scale[i] != 1.0) break; + } + + smode = scaleMode->GetSelection(); + + operationPrologue(); + + res = 0; + for (i=0; i<coll->number; i++) + { + if (list->Selected(i)) + { + double totalScale = 1.0; + + baseType = rviewGetBasetype((r_Object*)(&(*(coll->mddObjs[i].mdd)))); + oldInterv = (coll->mddObjs[i].mdd)->spatial_domain(); + dim = oldInterv.dimension(); + newInterv = r_Minterval(dim); useInterv = r_Minterval(dim); + for (j=0; j<(int)dim; j++) + { + double h; + + // Use the entire source object for scaling + useInterv << oldInterv[j]; + h = (j < dimString) ? scale[j] : scale[dimString-1]; totalScale *= h; + newInterv << r_Sinterval((r_Range)(oldInterv[j].low()), (r_Range)(oldInterv[j].low() + h*(oldInterv[j].high() - oldInterv[j].low() + 1) - 1)); + } + if (smode == 0) // resampling mode + { + if (totalScale > 1.0) + { + operation = lman->lookup("operationUpsamp"); + j = mdd_objectScaleInter(coll->mddObjs[i].mdd, useInterv, newMdd, newInterv); + } + else + { + operation = lman->lookup("operationDownsamp"); + j = mdd_objectScaleAverage(coll->mddObjs[i].mdd, useInterv, newMdd, newInterv); + } + } + else // simple scale mode + { + operation = lman->lookup("operationScale"); + j = mdd_objectScaleSimple(coll->mddObjs[i].mdd, useInterv, newMdd, newInterv); + } + if (j != 0) + { + usr.type = usr_mdd_dying; usr.data = (void*)(&((coll->mddObjs[i]).mdd)); + frames->broadcastUserEvent(usr); + coll->mddObjs[i].flags = 0; + (coll->mddObjs[i].mdd).destroy(); + coll->mddObjs[i].mdd = newMdd; + res++; + list->SetString(i, mddDescriptorString(memstr, i)); + selectedItems[i>>3] &= ~(1<<(i&7)); + } + } + } + + operationEpilogue(operation); + + delete [] scale; + + lastSelected = updateSelection(); + + return res; +} + + +int rviewResult::process(wxObject &obj, wxEvent &evt) +{ + int type = evt.GetEventType(); + + if (&obj == (wxObject*)list) + { + if (type == wxEVENT_TYPE_LISTBOX_COMMAND) + { + //cout << "rviewResult::process Listbox command" << endl; + lastSelected = updateSelection(); + return 1; + } + if (type == wxEVENT_TYPE_LISTBOX_DCLICK_COMMAND) + { + if ((lastSelected >= 0) && (lastSelected < coll->number)) + { + // This check is necessary + if (!list->Selected(lastSelected)) + { + list->SetSelection(lastSelected, TRUE); + if (selectedItems != NULL) selectedItems[lastSelected>>3] |= (1<<(lastSelected&7)); + } + openViewer(lastSelected); + } + return 1; + } + } + if (&obj == (wxObject*)choice) + { + if (type == wxEVENT_TYPE_CHOICE_COMMAND) + { + prefs->lastDisplay = choice->GetSelection(); + prefs->markModified(); + return 1; + } + } + if (&obj == (wxObject*)resampText) + { + if (type == wxEVENT_TYPE_TEXT_ENTER_COMMAND) + { + resampleSelection(); + return 1; + } + } + if (&obj == (wxObject*)resampBut) + { + if (type == wxEVENT_TYPE_BUTTON_COMMAND) + { + resampleSelection(); + return 1; + } + } + + return 0; +} + + + +int rviewResult::userEvent(const user_event &ue) +{ + if (ue.type == usr_viewer_closed) + { + mdd_frame *mf = (mdd_frame*)(ue.data); + int i; + + //{FILE *fp=fopen("xxx", "a+"); fprintf(fp, "Received viewer closed %p --- %p, %d\n", mf->mdd.ptr(), coll->mddObjs[0].mdd.ptr(), mf->flags); fclose(fp);} + for (i=0; i<coll->number; i++) + { + // must compare pointers, comparing r_Refs has strange effects on Win + if (mf->mdd.ptr() == coll->mddObjs[i].mdd.ptr()) break; + } + if (i < coll->number) + { + coll->mddObjs[i].flags &= ~(mf->flags); + return 1; + } + } + else if (ue.type == usr_child_closed) + { + if (ue.data == (void*)typeManager) typeManager = NULL; + return 1; + } + else if (ue.type == usr_typeman_convert) + { + convertSelectedItems(); + typeManager->Close(TRUE); typeManager = NULL; + return 1; + } + else if (ue.type == usr_close_viewers) + { + Close(TRUE); + return 1; + } + + return 0; +} + + + +void rviewResult::convertSelectedItems(void) +{ + int itemNo; + user_event usr; + char buffer[STRINGSIZE]; + ostrstream memstr(buffer, STRINGSIZE); + + operationPrologue(); + + for (itemNo=0; itemNo < coll->number; itemNo++) + { + if ((list->Selected(itemNo)) && (!coll->mddObjs[itemNo].mdd.is_null())) + { + r_Ref<r_GMarray> newMdd; + + if (typeManager->convert(coll->mddObjs[itemNo].mdd, newMdd) == 0) + { + usr.type = usr_mdd_dying; usr.data = (void*)(&((coll->mddObjs[itemNo]).mdd)); + frames->broadcastUserEvent(usr); + coll->mddObjs[itemNo].mdd.destroy(); + coll->mddObjs[itemNo].mdd = newMdd; + list->SetString(itemNo, mddDescriptorString(memstr, itemNo)); + } + else + { + newMdd.destroy(); + } + } + } + + operationEpilogue(lman->lookup("operationTypeProj")); + + lastSelected = updateSelection(); +} + + + +// Set up some variables and widgets in the frame. +void rviewResult::setupVariables(void) +{ + int x, y; + char *displayModes[RVIEW_RESDISP_NUMBER]; + char *scaleModes[2]; + wxMenu *mbarMenus[2]; + char buffer[STRINGSIZE]; + + coll = NULL; panel = NULL; list = NULL; collName = NULL; collType = NULL; + group = NULL; mBar = NULL; typeManager = NULL; + lastSelected = -1; + selectedItems = NULL; + + CreateStatusLine(1); + + mbarMenus[0] = new wxMenu; + mbarMenus[0]->Append(MENU_RSLT_ITEM_OPENALL, ""); + mbarMenus[0]->Append(MENU_RSLT_ITEM_THUMBALL, ""); + mbarMenus[0]->Append(MENU_RSLT_ITEM_CLOSE, ""); + + mbarMenus[1] = new wxMenu; + mbarMenus[1]->Append(MENU_RSLT_SLCT_SLCTALL, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_CLEAR, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_OPEN, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_THUMB, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_DELETE, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_ENDIAN, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_TYPEMAN, ""); + mbarMenus[1]->Append(MENU_RSLT_SLCT_INFO, ""); + + mBar = new wxMenuBar; + sprintf(buffer, "&%s", lman->lookup("menRsltItem")); + mBar->Append(mbarMenus[0], buffer); + sprintf(buffer, "&%s", lman->lookup("menRsltSlct")); + mBar->Append(mbarMenus[1], buffer); + + GetClientSize(&x, &y); + panel = new wxPanel((wxWindow*)this, 0, 0, x, y); + x -= 2*result_border; y -= 2*result_border; + + // Create a group box surrounding the collection-items + group = new wxGroupBox(panel, "", 0, 0, x, result_header, wxBORDER); + x -= 2*result_border; y -= 2*result_border; + // Create the message widget showing the collection name + collName = new wxMessage(panel, "", 2*result_border, result_lheight + 2*result_border, x, result_lheight, 0, "message"); + // The same for the collection base type + collType = new wxMessage(panel, "", 2*result_border, 2*result_lheight + 2*result_border, x, result_lheight, 0, "message"); + // The info string + collInfo = new wxMessage(panel, "", 2*result_border, 3*result_lheight + 2*result_border, x, result_lheight, 0, "message"); + + // And the choice item for the display modes. + // In contrast to the menu stuff non-persistent objects are OK here. + displayModes[0] = lman->lookup("dispModeImage"); + displayModes[1] = lman->lookup("dispModeVolume"); + displayModes[2] = lman->lookup("dispModeOrtho"); + displayModes[3] = lman->lookup("dispModeHeight"); + displayModes[4] = lman->lookup("dispModeChart"); + displayModes[5] = lman->lookup("dispModeTable"); + displayModes[6] = lman->lookup("dispModeSound"); + displayModes[7] = lman->lookup("dispModeString"); + choice = new rviewChoice(panel, RVIEW_RESDISP_NUMBER, displayModes, lman->lookup("dispModeLabel")); + choice->SetSelection(prefs->lastDisplay); + + scaleModes[0] = lman->lookup("textResample"); + scaleModes[1] = lman->lookup("textScale"); + scaleMode = new rviewChoice(panel, 2, scaleModes); + scaleMode->SetSelection(0); + scaleMode->SetLabel(""); + + sprintf(buffer, "%f", 1.0); + resampText = new rviewText(panel, buffer); + resampBut = new rviewButton(panel, lman->lookup("textOK")); + + choice->GetSize(&x, &y); + cbfactor = x - result_cwidth; + + SetMenuBar(mBar); +} + + + + +void rviewResult::OnMenuCommand(int id) +{ + switch (id) + { + case MENU_RSLT_ITEM_OPENALL: + { + for (int i=0; i<coll->number; i++) + { + openViewer(i); + } + } + break; + case MENU_RSLT_ITEM_THUMBALL: + { + int i; + rviewThumb *thumb; + + thumb = new rviewThumb; + for (i=0; i<coll->number; i++) + { + thumb->addMDD(coll->mddObjs[i].mdd); + } + registerChild((rviewFrame*)thumb); + } + break; + case MENU_RSLT_ITEM_CLOSE: + { + this->Close(TRUE); + } + break; + case MENU_RSLT_SLCT_SLCTALL: + { + for (int i=0; i<coll->number; i++) + { + if (!list->Selected(i)) + { + list->SetSelection(i, TRUE); + } + } + if (selectedItems != NULL) memset(selectedItems, 0xff, (coll->number + 7) >> 3); + configureGrey(); + } + break; + case MENU_RSLT_SLCT_CLEAR: + { + for (int i=0; i<coll->number; i++) + { + if (list->Selected(i)) + { + list->SetSelection(i, FALSE); + } + } + if (selectedItems != NULL) memset(selectedItems, 0, (coll->number + 7) >> 3); + configureGrey(); + } + break; + case MENU_RSLT_SLCT_OPEN: + { + int i; + + for (i=0; i<coll->number; i++) + { + if (list->Selected(i)) + openViewer(i); + } + } + break; + case MENU_RSLT_SLCT_THUMB: + { + int i; + + for (i=0; i<coll->number; i++) + { + if (list->Selected(i)) break; + } + if (i < coll->number) + { + rviewThumb *thumb; + + thumb = new rviewThumb; + for (i=0; i<coll->number; i++) + { + if (list->Selected(i)) + thumb->addMDD(coll->mddObjs[i].mdd); + } + registerChild((rviewFrame*)thumb); + } + } + break; + case MENU_RSLT_SLCT_DELETE: + { + int itemNo, j; + user_event usr; + + do + { + for (itemNo=0; itemNo < coll->number; itemNo++) + if (list->Selected(itemNo)) break; + + if (itemNo >= coll->number) break; + list->Delete(itemNo); + // Notify all open display frames that a particular mdd object will die + usr.type = usr_mdd_dying; usr.data = (void*)(&((coll->mddObjs[itemNo]).mdd)); + frames->broadcastUserEvent(usr); + if (!coll->mddObjs[itemNo].mdd.is_null()) + { + coll->mddObjs[itemNo].mdd.destroy(); + } + (coll->number)--; + for (j=itemNo; j<coll->number; j++) + { + coll->mddObjs[j] = coll->mddObjs[j+1]; + // Don't forget to copy the selection too + selectedItems[j>>3] &= ~(1<<(j&7)); + if ((selectedItems[(j+1)>>3] & (1<<((j+1)&7))) != 0) selectedItems[j>>3] |= (1<<(j&7)); + } + } + while (1); + lastSelected = updateSelection(); + configureGrey(); + } + break; + case MENU_RSLT_SLCT_ENDIAN: + { + int itemNo; + user_event ue; + + operationPrologue(); + + ue.type = usr_mdd_dying; + for (itemNo = 0; itemNo < coll->number; itemNo++) + { + if ((list->Selected(itemNo)) && (!coll->mddObjs[itemNo].mdd.is_null())) + { + r_Minterval useInterv; + + ue.data = (void*)(&((coll->mddObjs[itemNo]).mdd)); + frames->broadcastUserEvent(ue); // close all open viewers + useInterv = coll->mddObjs[itemNo].mdd->spatial_domain(); + mdd_objectChangeEndianness(coll->mddObjs[itemNo].mdd, useInterv); + } + } + operationEpilogue(lman->lookup("operationEndian")); + } + break; + case MENU_RSLT_SLCT_TYPEMAN: + if (typeManager == NULL) + { + int itemNo; + const r_Type *sampleType = NULL; + + for (itemNo = 0; itemNo < coll->number; itemNo++) + { + if ((list->Selected(itemNo)) && (!coll->mddObjs[itemNo].mdd.is_null())) + { + sampleType = coll->mddObjs[itemNo].mdd->get_base_type_schema(); + break; + } + } + /*try { + sampleType = r_Type::get_any_type("struct { struct { float u, float v, float w }, float p, float te, float ed, float den, float vis }"); + } catch (r_Error &err) { + cerr << err.what() << endl; + }*/ + if (sampleType != NULL) + { + if (typeManager == NULL) + typeManager = new rviewTypeMan(this, sampleType); + } + } + break; + case MENU_RSLT_SLCT_INFO: break; + default: break; + } +} + + + +void rviewResult::configureGrey(void) +{ + int i; + + mBar->Enable(MENU_RSLT_ITEM_OPENALL, (coll->number > 0)); + mBar->Enable(MENU_RSLT_ITEM_THUMBALL, (coll->number> 0)); + + for (i=0; i<coll->number; i++) + { + if (list->Selected(i)) break; + } + bool enable = (i < coll->number); + + mBar->Enable(MENU_RSLT_SLCT_CLEAR, enable); + mBar->Enable(MENU_RSLT_SLCT_OPEN, enable); + mBar->Enable(MENU_RSLT_SLCT_THUMB, enable); + mBar->Enable(MENU_RSLT_SLCT_DELETE, enable); + mBar->Enable(MENU_RSLT_SLCT_ENDIAN, enable); + mBar->Enable(MENU_RSLT_SLCT_TYPEMAN, enable); + mBar->Enable(MENU_RSLT_SLCT_INFO, enable); +} + + + + + +/* + * rView about window + */ + +const int rviewAbout::about_width = 300; +const int rviewAbout::about_height = 150; +const int rviewAbout::about_border = 8; +const int rviewAbout::about_pheight = 50; +const int rviewAbout::about_bwidth = 80; +const int rviewAbout::about_bheight = 30; +const int rviewAbout::about_mheight = 16; + +rviewAbout::rviewAbout(void) : rviewFrame(NULL, "", -1, -1, about_width, about_height) +{ + labels = NULL; numlines = 0; + panel = new wxPanel((wxWindow*)this, 0, 0, about_width, about_height); + okBut = new rviewButton(panel); + + label(); + + OnSize(about_width, about_height); +} + + +rviewAbout::~rviewAbout(void) +{ + // the messages themselves will be sorted out by the panel destructor. + if (labels != NULL) delete [] labels; +} + + +const char *rviewAbout::getFrameName(void) const +{ + return "rviewAbout"; +} + +rviewFrameType rviewAbout::getFrameType(void) const +{ + return rviewFrameTypeAbout; +} + + +void rviewAbout::deleteLabels(void) +{ + if (labels != NULL) + { + int i; + + for (i=0; i<numlines; i++) delete labels[i]; + delete [] labels; labels = NULL; numlines = 0; + } +} + + +void rviewAbout::label(void) +{ + int i, number, x, y; + + SetTitle(lman->lookup("titleAbout")); + okBut->SetLabel(lman->lookup("textOK")); + + deleteLabels(); + + GetClientSize(&x, &y); + y = about_border; + number = atoi(lman->lookup("rviewAboutLineNum")); + if (number >= 1) + { + char lineName[64]; + + numlines = number; + labels = new wxMessage *[numlines]; x -= 2*about_border; + for (i=0; i<number; i++) + { + sprintf(lineName, "rviewAboutLine%d", i); + labels[i] = new wxMessage(panel, lman->lookup(lineName), about_border, y, x, about_mheight, 0, "message"); + y += about_mheight; + } + } + SetSize(-1, -1, x, y + about_pheight + rview_window_extra_height); +} + + +int rviewAbout::process(wxObject &obj, wxEvent &evt) +{ + if ((&obj == (wxObject*)okBut) && (evt.GetEventType() == wxEVENT_TYPE_BUTTON_COMMAND)) + { + Show(FALSE); return 1; + } + return 0; +} + + +void rviewAbout::OnSize(int w, int h) +{ + int x, y; + + GetClientSize(&x, &y); + + panel->SetSize(0, 0, x, y); + x -= 2*about_border; y = about_border; + if (panel != NULL) + { + for (int i=0; i<numlines; i++) + { + labels[i]->SetSize(about_border, y, x, about_mheight); + y += about_mheight; + } + } + x -= about_bwidth; y += (about_pheight - about_bheight)/2; + okBut->SetSize(x/2, y, about_bwidth, about_bheight); +} + + + + + +/* + * rviewStringSet window + */ + +const int rviewStringSet::strset_width = 300; +const int rviewStringSet::strset_height = 250; +const int rviewStringSet::strset_border = 8; +const int rviewStringSet::strset_reserve = 50; +const int rviewStringSet::strset_bwidth = 70; +const int rviewStringSet::strset_bheight = 40; +const int rviewStringSet::strset_mheight = 20; + +rviewStringSet::rviewStringSet(collection_desc *desc) : rviewFrame(NULL, "", -1, -1, strset_width, strset_height) +{ + int w, h; + char buffer[STRINGSIZE]; + + panel = new wxPanel((wxWindow*)this, 0, 0, strset_width, strset_height); + list = new wxListBox(panel, (wxFunction)rviewEventHandler, "", wxSINGLE, 0, 0, strset_width, strset_height, desc->number, desc->strObjs, wxALWAYS_SB); + dismiss = new rviewButton(panel); + + sprintf(buffer, "%s: %s", lman->lookup("textCollName"), (desc->collName == NULL) ? "" : desc->collName); + collName = new wxMessage(panel, buffer, 0, 0, 10, 10, 0, "message"); + sprintf(buffer, "%s: %s", lman->lookup("textCollType"), (desc->collType == NULL) ? "" : desc->collType); + collType = new wxMessage(panel, buffer, 0, 0, 10, 10, 0, "message"); + char* tmpChar1 = "message"; + char* tmpChar2 = ""; + collInfo = new wxMessage(panel, (desc->collInfo == NULL) ? tmpChar2 : desc->collInfo, 0, 0, 10, 10, 0, tmpChar1); + + GetClientSize(&w, &h); + + label(); + + OnSize(w, h); + + Show(TRUE); +} + + +rviewStringSet::~rviewStringSet(void) +{ +} + + +const char *rviewStringSet::getFrameName(void) const +{ + return "rviewStringSet"; +} + +rviewFrameType rviewStringSet::getFrameType(void) const +{ + return rviewFrameTypeStrSet; +} + + +void rviewStringSet::label(void) +{ + SetTitle(lman->lookup("titleStringSet")); + list->SetLabel(lman->lookup("strSetList")); + dismiss->SetLabel(lman->lookup("textClose")); +} + + +void rviewStringSet::OnSize(int w, int h) +{ + int x, y; + int head; + + GetClientSize(&x, &y); + panel->SetSize(0, 0, x, y); + head = 3*(strset_mheight + strset_border); + x -= 2*strset_border; y -= 2*strset_border; + collName->SetSize(strset_border, strset_border, x, strset_mheight); + collType->SetSize(strset_border, strset_mheight + 2*strset_border, x, strset_mheight); + collInfo->SetSize(strset_border, 2*strset_mheight + 3*strset_border, x, strset_mheight); + + list->SetSize(strset_border, strset_border + head, x, y - head - strset_reserve); + dismiss->SetSize((x - strset_bwidth) / 2, y + 2*strset_border - (strset_reserve + strset_bheight) / 2, strset_bwidth, strset_bheight); +} + + +int rviewStringSet::process(wxObject &obj, wxEvent &evt) +{ + if (&obj == (wxObject*)dismiss) + { + this->Close(TRUE); + return 1; + } + return 0; +} + + +int rviewStringSet::getNumItems(void) +{ + return list->Number(); +} + + +void rviewStringSet::addItem(const char *string) +{ + list->Append((char*)string); +} + + +char *rviewStringSet::getItem(int number) +{ + return list->GetString(number); +} + + +#ifdef EARLY_TEMPLATE +#undef __EXECUTABLE__ +#endif + +#endif // !defined(EARLY_TEMPLATE) || !defined(__EXECUTABLE__) + + + +#if (!defined(EARLY_TEMPLATE) || defined(__EXECUTABLE__)) + +/* + * Templates + */ + +// For placement new (DynamicStack template) +#include <new> + +/* + * Use malloc/free, placement new and explicit calls to destructors. + * Use placement new when initializing on the stack because that's + * raw memory, use assignment when initializing parameters + */ +template<class T> +DynamicStack<T>::DynamicStack(unsigned int gran) +{ + number = 0; max = 0; + if ((stack = (T*)malloc(gran * sizeof(T))) != NULL) + { + granularity = gran; + max = granularity; + memset(stack, 0, max * sizeof(T)); + } +} + + +template<class T> +DynamicStack<T>::DynamicStack(const DynamicStack<T> &src) +{ + number = 0; max = 0; + if ((stack = (T*)malloc(src.max * sizeof(T))) != NULL) + { + granularity = src.granularity; + max = src.max; + memset(stack, 0, max*sizeof(T)); + number = src.number; + + unsigned int i; + + // use loop for class safety + for (i=0; i<number; i++) + new(stack + i) T(src.stack[i]); // placement new + } +} + + +template<class T> +DynamicStack<T>::~DynamicStack(void) +{ + unsigned int i; + + for (i=0; i<number; i++) + stack[i].~T(); // direct destructor call + + if (stack != NULL) + free(stack); +} + + +template<class T> +int DynamicStack<T>::push(const T &item) +{ + if (ensureFree() != 0) return -1; + new(stack + number++) T(item); // placement new + return 0; +} + + +template<class T> +int DynamicStack<T>::pop(T &item) +{ + if (number == 0) return -1; + item = stack[--number]; // assignment + stack[number].~T(); // direct destructor call + return 0; +} + + +template<class T> +int DynamicStack<T>::peek(T &item) const +{ + if (number == 0) return -1; + item = stack[number-1]; // assignment + return 0; +} + + +template<class T> +unsigned int DynamicStack<T>::getNumber(void) const +{ + return number; +} + + +template<class T> +int DynamicStack<T>::ensureFree(void) +{ + if (number >= max) + { + if ((stack = (T*)realloc(stack, (max + granularity) * sizeof(T))) == NULL) + { + max = 0; number = 0; return -1; + } + memset(stack + max, 0, granularity * sizeof(T)); + max += granularity; + } + return 0; +} + +#endif |