Convert Class Reference

This class is used to convert things from one form to another. Mainly contains static functions. Started life as a series of conversion functions before being made to see the light and profess the one and only true class. At present in the Winoil class as it needs converting to TCHARs and using the MFC forms of scanf and sprintf .. More...

#include <convert.h>

List of all members.

Public Types
typedef BOOL(*	PFNSTRINGTOINT32 )(const StringBase &, INT32 *)
typedef BOOL(*	PFNSTRINGTODOUBLE )(const StringBase &, double *)
Static Public Member Functions
static BOOL	Init ()
	AppPrefsDlg Init method. Called when the kernel initialises. It reads from the Windows ini file the settings for things like the current decimal point character, thousands separator and number of decimal places and stores these for later use.
static BOOL	GetCurrentNumberFormat ()
	Read from the operating system what the user has defined to be their decimal point character and thousands separator character and store these in the class variables. It is now also called from the mainframe message handler, when it receives a WM_WININICHANGE message.
static char	GetDecimalPointChar ()
	To find out what the current decimal point character is.
static char	GetThousandsSepChar ()
	To find out what the current thousands separator character is.
static UINT32	GetNumberDecimalPlaces ()
	To find out what the current number of decimal places is.
static BOOL	SetDecimalPointChar (char NewDecimalPoint)
	Allows the setting up of the character to separate whole part of number from the fractional part in displayed numbers e.g. 56.79 This is read from the OS at present. This function just provided just in case we wish to overide this in the future.
static BOOL	SetThousandsSepChar (char NewThousandsSep)
	Allows the setting up of the character to be used to separate thousands in displayed numbers e.g. 10,000. This is read from the OS at present. This function just provided just in case we wish to overide this in the future.
static BOOL	SetNumberDecimalPlaces (UINT32 NewDPs)
	Allows the setting up of the number of decimal places to display to by default This is read from the OS at present. This function just provided just in case we wish to overide this in the future.
static MILLIPOINT	StringToMillipoints (const StringBase &, UnitType, BOOL *)
	Convert the string into a MILLIPOINT representation of the number of millipoints. eg '1in' would be converted to 72000 millipoints. Does NOT cope with '0.25in0.75in' - this would return 18000 millipoints instead of 72000 millipoints.
static void	NumberToString (MILLIPOINT Number, StringBase *MyString)
	Appends the string representation of the given number to the end of MyString.
static BOOL	MillipointsToString (double, UnitType, StringBase *, INT32 DecimalPlaces=-1)
	Convert a number in MpValue to a string representation of that number in the given units. ie converting 72000 millipoints to inches would give the string '1in'. If DecimalPlaces = -1 then use the default preference value which the user has specified. See Also: DocUnitList.
static double	StringToDouble (const StringBase &, UnitType, BOOL *)
	Convert the string into a floating point representation of the number of millipoints. eg '1in' would be converted to 72000.0 millipoints. Does NOT cope with '0.25in0.75in' - this would return 18000.0 millipoints instead of 72000.0 millipoints. If you want a MILLIPOINT value, use StringToMillipoint to ensure correct rounding.
static BOOL	StringToDouble (const StringBase &InputString, double *Number)
	Converts a string into its double equivalent.
static BOOL	DoubleToString (double Number, StringBase *OutputString, INT32 DecimalPlaces=-1)
	Converts a double to a its string equivalent.
static BOOL	StringToComponents (const StringBase &InputString, double *pValue, UnitType *pUnits)
	General purpose routine for extracting the value and unit components of a string. E.g.1 the string "42.6in" would extract the value 42.6 and the unit type INCHES E.g.2 The string "42.6" would give *pValue=42.6,*pUnits=NOTYPE, and TRUE is returned. E.g.3 "4in5in" gives *pValue=9,*pUnits=INCHES, and returns TRUE E.g.4 "1in2cm" gives *pValue = 1.79,*pUnits=INCHES, and returns TRUE In this case it takes the first unit specified as the dominant unit (INCHES in this case), so the result is 1in plus 2cm converted to INCHES which is about 0.79in.
static double	ConvertToNewUnits (double Value, UnitType Units, UnitType NewUnits)
	Used convert one value into an equivalent value in another unit base E.g. ConvertToNewUnits(3,CENTIMETRES,MILLIMETRES) would return 30.0 because 3cm == 30mm.
static BOOL	ConvertDoubleToMillipoint (double Value, MILLIPOINT *pResult)
	Converts a double to a MILLIPOINT, checking first whether such a conversion is possible. It returns FALSE if Value is beyond the limits of a signed 32 bit integer.
static void	ConvertMillipointToDouble (MILLIPOINT Value, double *pResult)
	Converts a MILLIPOINT to a double. At the moment, this function just does a simple cast. I've only put it in because I did the sister function ConvertDoubleToMillipoint.
static BOOL	LongToString (INT32 Number, StringBase *OutputString)
	Converts a INT32 to a its string equivalent.
static BOOL	StringToLong (const StringBase &InputString, INT32 *Number)
	Converts a string into its INT32 equivalent.
static UINT32	StringToBytes (const StringBase &pString, BOOL *Valid)
	Takes a string with a textual description of an amount of memory, and returns the amount of bytes described by the string.
static BOOL	BytesToString (StringBase *pString, UINT32 Bytes)
	Converts the Bytes number into a string of the following format: Bytes = 0 "0 bytes" Bytes = 1 "1 byte" 2 <= Bytes < 4096 "<n> bytes" 4096 <= Bytes < 4M "<n/1024> K" 4M <= Bytes "<n/1Meg> M".
static BOOL	ReplaceDecimalPoint (StringBase *pString)
	Searches the specified string for a decimal point and replaces this with the specified DecimalPoint character. It assumes that a check has been made already to see if we are using a non-decimal point character and so this routine is only called when the replacement is actually required. This MUST ALWAYS be after the StripTrailingZeros code. Otherwise, the StripTrailingZeros code would have to search for two items, a decimal point and the international form of the decimal point.
static BOOL	StripTrailingZeros (StringBase *pString)
	Strip trailing zeros (& decimal point) from a string containing a decimal number This MUST ALWAYS be called before the replace decimal point character code. Otherwise, we would have to search for two items, a decimal point and the international form of the decimal point.
static BOOL	IsCharUnitType (TCHAR Char)
	Checks to see if this char could be part of a string that specifies a unit We have to allow most chars so that arbitrary units can be defined like such as pounds, dollars or percentages Illegal unit specifier chars are :- ASCII value <= ' ' Numericals - '1', '2', etc Minus sign - '-' Decimal point - '.' Thousand separator - ',' as in "10,000".
static BOOL	IsCharStartOfNumber (TCHAR Char)
	Checks to see if this char could be the first char in a string that specifies a number Legal number-starting chars are :- Numericals - '1', '2', etc Minus sign - '-' Decimal point - '.'.
static BOOL	ReadUnitType (const StringBase &Str, INT32 *pPos, UnitType *pUnitType)
	General purpose routine for extracting the unit type from a string E.g. "42cm45mm" with *pPos = 2 returns TRUE with *pUnitType == CENTIMETRES & *pPos == 4 "42cm45mm" with *pPos = 6 returns TRUE with *pUnitType == MILLIMETRES & *pPos == 8.
static BOOL	ReadNumber (const StringBase &Str, INT32 *pPos, double *pResult)
	General purpose routine for extracting the number from a string E.g. "42cm45.7mm" with *pPos == 0 returns TRUE with *pResult and 42.0 & *pPos == 2 "42cm-45.7mm" with *pPos == 4 returns TRUE with *pResult and -45.7 & *pPos == 9.
Static Protected Attributes
static char	DecimalPoint = '.'
static char	ThousandSep = ','
static char	MinusSign = '-'
static UINT32	NumDecimalPlaces = 2

---

Detailed Description

This class is used to convert things from one form to another. Mainly contains static functions. Started life as a series of conversion functions before being made to see the light and profess the one and only true class. At present in the Winoil class as it needs converting to TCHARs and using the MFC forms of scanf and sprintf ..

Author:

Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>

Date:

12/9/95

Note by Rik who did the original functions 11/5/93:-

These functions will provide a means of converting from Doc Coords (millipoints) to Strings and visa versa. For example, convert 72000 millipoints to the string 1in or 72pt as well as converting from the string '1in72pt' to 144000 millipoints. The units to convert to can be chosen, as can the number of decimal points. When converting from string back to millipoints, all the valid units are added together. If an error is detected (ie '4cm72zx' ), then everything up to the error will be used (4cm).

See also:

DimScale, Spread, Layer

Definition at line 141 of file convert.h.

---

Member Typedef Documentation

typedef BOOL(* Convert::PFNSTRINGTODOUBLE)(const StringBase &, double *)

Definition at line 196 of file convert.h.

typedef BOOL(* Convert::PFNSTRINGTOINT32)(const StringBase &, INT32 *)

Definition at line 195 of file convert.h.

---

Member Function Documentation

BOOL Convert::BytesToString (  StringBase *  pString, UINT32  Bytes )  [static]

Converts the Bytes number into a string of the following format: Bytes = 0 "0 bytes" Bytes = 1 "1 byte" 2 <= Bytes < 4096 "<n> bytes" 4096 <= Bytes < 4M "<n/1024> K" 4M <= Bytes "<n/1Meg> M". Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 26th August 1994 Parameters: String  - The string to store the formatted memory size in. The [INPUTS] existing contents of the string are overwritten. Bytes - The number of bytes which to format and store. Returns: - Definition at line 1368 of file convert.cpp. { ERROR2IF(pString==NULL, FALSE, "NULL output pointer"); ERROR3IF(Bytes<0, "The number of bytes must be positive"); if(Bytes<0) Bytes = 0-Bytes; pString->Empty(); INT32 Number = 0; UINT32 Resource = 0; String_16 Working; String_8 ThousandsSepStr; ThousandsSepStr += (TCHAR)ThousandSep; // Work out which resource string to use depending on the number of bytes if (Bytes == 1) { Number = 1; Resource = _R(IDS_MEMORYFORMAT_BYTE); } else { if (Bytes < 4096) { Number = Bytes; Resource = _R(IDS_MEMORYFORMAT_BYTES); } else { if (Bytes < (4096*1024)) { Number = Bytes/1024; Resource = _R(IDS_MEMORYFORMAT_KILO); } else { Number = Bytes/(1024*1024); Resource = _R(IDS_MEMORYFORMAT_MEGA); } } } // Put the number into a string and add thousand seperator Working._MakeMsg( wxT("#1%lu"), Number ); if (Working.Length() > 3) Working.Insert(ThousandsSepStr, Working.Length()-3); // put the number string into the string resource pString->MakeMsg(Resource, &Working); return TRUE; }

BOOL Convert::ConvertDoubleToMillipoint (  double  Value, MILLIPOINT *  pResult )  [static]

Converts a double to a MILLIPOINT, checking first whether such a conversion is possible. It returns FALSE if Value is beyond the limits of a signed 32 bit integer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: Value  = the fp value to convert [INPUTS] pResult  = the MILLIPOINT var to place the result in [OUTPUTS] Returns: TRUE if the conversion was OK FALSE if the conversion caused an overflow error See also: ConvertMillipointToDouble Definition at line 1228 of file convert.cpp. { Value += 0.5; // Round up the value if ((Value < MIN_MILLIPOINT_VAL) || (Value > MAX_MILLIPOINT_VAL)) return FALSE; *pResult = (MILLIPOINT)Value; return TRUE; }

void Convert::ConvertMillipointToDouble (  MILLIPOINT  Value, double *  pResult )  [static]

Converts a MILLIPOINT to a double. At the moment, this function just does a simple cast. I've only put it in because I did the sister function ConvertDoubleToMillipoint. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: Value  = the MILLIPOINT value to convert [INPUTS] pResult  = the double var to place the result in [OUTPUTS] Returns: - See also: ConvertDoubleToMillipoint Definition at line 1255 of file convert.cpp. { *pResult = (double)Value; }

double Convert::ConvertToNewUnits (  double  Value, UnitType  OldUnits, UnitType  NewUnits )  [static]

Used convert one value into an equivalent value in another unit base E.g. ConvertToNewUnits(3,CENTIMETRES,MILLIMETRES) would return 30.0 because 3cm == 30mm. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: Value  - value to convert [INPUTS] OldUnits- units Value is defined in NewUnits- the units you want Value to be converted toTYPE -  [OUTPUTS] Returns: The new value Definition at line 687 of file convert.cpp. { ENSURE(NewUnits != NOTYPE,"Can't convert to NOTYPE units"); DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList(); Unit* pNewUnit = pDocUnitList->FindUnit(NewUnits); double NumMillipoints = 1.0; if (OldUnits != NOTYPE) { Unit* pOldUnit = pDocUnitList->FindUnit(OldUnits); NumMillipoints = Value * pOldUnit->GetMillipoints(); } else NumMillipoints = Value; return (NumMillipoints / pNewUnit->GetMillipoints()); }

BOOL Convert::DoubleToString (  double  Number, StringBase *  OutputString, INT32  DecimalPlaces = -1 )  [static]

Converts a double to a its string equivalent. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Parameters: Number  - The number you want turning into a string [INPUTS] DecimalPlaces - The number of Decimal places required (0-3). This defaults to -1 which means use the default preference value. Don't override it unless absolutely necessary. OutputString  - The string that gets created [OUTPUTS] Returns: TRUE if the conversion worked, false otherwise See also: StringToDouble This routine is a bit of a bodge Definition at line 1089 of file convert.cpp. { // Generate the output string in a simple char array TCHAR dpformat[32]; TCHAR TempString[32]; // Use the default/preference or desired number of decimal places if (DecimalPlaces < 0) DecimalPlaces = (INT32) NumDecimalPlaces; // Use the preference value camSnprintf( dpformat, 32, _T("%%.%df"), (INT32) DecimalPlaces); // make %.xf formatting string camSnprintf( TempString, 32, dpformat, (double)Number ); // uses FP *OutputString = TempString; // Copy the resulting string into the String // Look for all zeros after decimal point and if so then remove StripTrailingZeros(OutputString); // Extra bodge required so that if the user has specified display values using // a non full stop to show decimal points then we must replace the point that // is present by the specified character. if (DecimalPoint != '.') { ReplaceDecimalPoint(OutputString); } return TRUE; }

BOOL Convert::GetCurrentNumberFormat (   )  [static]

Read from the operating system what the user has defined to be their decimal point character and thousands separator character and store these in the class variables. It is now also called from the mainframe message handler, when it receives a WM_WININICHANGE message. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: CMainFrame::OnWinIniChange() Definition at line 198 of file convert.cpp. { String_8 ThousandsSepStr( _T(",") ); String_8 DecimalPointStr( _T(".") ); NumDecimalPlaces = 2; // Read from the operating system what the user has defined to be their decimal point // character and thousands separator character. LocalEnvironment::GetThousandsSeparator(&ThousandsSepStr); LocalEnvironment::GetDecimalPointChar(&DecimalPointStr); LocalEnvironment::GetNumberOfDecimalPlaces(&NumDecimalPlaces); // Set up the static char variables to reflect these ThousandSep = ((TCHAR *) ThousandsSepStr)[0]; DecimalPoint = ((TCHAR *) DecimalPointStr)[0]; // Check for "testing" of internationalisation. ERROR3IF(ThousandSep == DecimalPoint, "Convert::GetCurrentNumberFormat: decimal point and " "thousands separator are the same"); //char to TCHAR for DBCS TRACEUSER( "Neville", wxT("InitConvert() ThousandsSepStr=%s\n"), (TCHAR *)ThousandsSepStr ); TRACEUSER( "Neville", wxT("InitConvert() DecimalPointStr=%s\n"), (TCHAR *)DecimalPointStr ); TRACEUSER( "Neville", wxT("InitConvert() NumDecimalPlaces=%d\n"), NumDecimalPlaces ); return TRUE; }

char Convert::GetDecimalPointChar (   )  [static]

To find out what the current decimal point character is. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current decimal point character being used. See also: SetDecimalPointChar(); GetCurrentNumberFormat(); Definition at line 242 of file convert.cpp. { return DecimalPoint; }

UINT32 Convert::GetNumberDecimalPlaces (   )  [static]

To find out what the current number of decimal places is. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current number of decimal places being used. See also: SetNumberDecimalPlaces(); Definition at line 281 of file convert.cpp. { return NumDecimalPlaces; }

char Convert::GetThousandsSepChar (   )  [static]

To find out what the current thousands separator character is. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current thousands separator character being used. See also: SetThousandsSepChar(); GetCurrentNumberFormat(); Definition at line 261 of file convert.cpp. { return ThousandSep; }

BOOL Convert::Init (  void   )  [static]

AppPrefsDlg Init method. Called when the kernel initialises. It reads from the Windows ini file the settings for things like the current decimal point character, thousands separator and number of decimal places and stores these for later use. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 25/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: GetCurrentNumberFormat(); Definition at line 163 of file convert.cpp. { // // Declare any preferences that we require. // if ( Camelot.DeclareSection(TEXT("Preferences"), 3) ) // { // // section declared ok so now define the preference option // Camelot.DeclarePref(TEXT("Preferences"), TEXT("DecimalPointChar"), &DecimalPoint, 0, 255); // Camelot.DeclarePref(TEXT("Preferences"), TEXT("ThousandSepChar"), &ThousandSep, 0, 255); // } // Get the current details from the OS about the number format specified by the user // If fails then return this to the caller. return GetCurrentNumberFormat(); }

BOOL Convert::IsCharStartOfNumber (  TCHAR  Char  )  [static]

Checks to see if this char could be the first char in a string that specifies a number Legal number-starting chars are :- Numericals - '1', '2', etc Minus sign - '-' Decimal point - '.'. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: Char  - the character to check [INPUTS] -  [OUTPUTS] Returns: TRUE - This could be the first char of a number FALSE - Sorry, but it's definitely not a number Errors: - Definition at line 519 of file convert.cpp. { return ( (StringBase::IsNumeric(Char)) || (Char == MinusSign) || (Char == DecimalPoint) ); }

BOOL Convert::IsCharUnitType (  TCHAR  Char  )  [static]

Checks to see if this char could be part of a string that specifies a unit We have to allow most chars so that arbitrary units can be defined like such as pounds, dollars or percentages Illegal unit specifier chars are :- ASCII value <= ' ' Numericals - '1', '2', etc Minus sign - '-' Decimal point - '.' Thousand separator - ',' as in "10,000". Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: Char  - the character to check [INPUTS] -  [OUTPUTS] Returns: TRUE - This could be part of a unit type specifier FALSE - Sorry, but it's either a white space or a number Errors: - Definition at line 489 of file convert.cpp. { return ( (unsigned(Char) > unsigned(TEXT(' '))) && (!StringBase::IsNumeric(Char)) && (Char != MinusSign) && (Char != DecimalPoint) && (Char != ThousandSep) ); }

BOOL Convert::LongToString (  INT32  Number, StringBase *  OutputString )  [static]

Converts a INT32 to a its string equivalent. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/93 Parameters: Number  - The number you want turning into a string [INPUTS] OutputString  - The string that gets created [OUTPUTS] Returns: TRUE if the conversion worked, false otherwise See also: StringToLong Definition at line 1049 of file convert.cpp. { OutputString -> Empty(); if (Number < 0) { TCHAR buff[2] ; buff[0] = TEXT('-'); buff[1] = TEXT('\0'); *OutputString += String_8(buff); Number = -Number; } NumberToString( Number, OutputString ); return TRUE; }

BOOL Convert::MillipointsToString (  double  MpValue, UnitType  TheUnit, StringBase *  OutputString, INT32  DecimalPlaces = -1 )  [static]

Convert a number in MpValue to a string representation of that number in the given units. ie converting 72000 millipoints to inches would give the string '1in'. If DecimalPlaces = -1 then use the default preference value which the user has specified. See Also: DocUnitList. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> (rewritten by MarkN to use new units system - 6/7/94) Date: 1/9/93 Parameters: MpValue  - The number of millipoints to be converted [INPUTS] TheUnit - The units that you need the result in OutputString - Stirng to put value into (See outputs) DecimalPlaces - The number of Decimal places required (0-3). This defaults to -1 which means use the default preference value. OutputString  - pointer to a string that is big enough to hold [OUTPUTS] the resulting number plus its type (ie 12.45cm) Returns: TRUE if all went well and the string is valid, FALSE otherwise Definition at line 959 of file convert.cpp. { ERROR2IF(OutputString == NULL,FALSE,"MillipointsToString NULL output string supplied"); // Decimal places will be -1 if the default number is to be used. double Value = 1.0; String_32 Specifier; TCHAR p[256], format[256], dpformat[256]; DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList(); DocUnitList FactoryDefUnits; if(pDocUnitList==NULL) { // certain classes (eg OpDescriptors) may want to call this function to set // values in controls after they have been read in by the bars/dialogs etc... // However at that point (Document::GetCurrent() == NULL) so you can't get // a DocUnitList from the current doc. Hence create our own default units FactoryDefUnits.Init(); FactoryDefUnits.MakeDefaultUnits(); pDocUnitList = &FactoryDefUnits; } Unit* pUnit = pDocUnitList->FindUnit(TheUnit); // Find out how many Units MpValue represents Value = MpValue / pUnit->GetMillipoints(); // Get the specifier of the units we're in Specifier = pUnit->GetSpecifier(); // check if we want the default number of decimal places if (DecimalPlaces == -1) DecimalPlaces = NumDecimalPlaces; //_stprintf(dpformat,"%%.%df",DecimalPlaces); // Makes "%.xf" where x is num dp // Makes the output form "%.xf" where x is num dp. // %g instead of %f gives leading zero supression but then requires number significant // figures rather than number of decimal places. camSnprintf( dpformat, 256, TEXT("%%.%df"), DecimalPlaces) ; // Create the string to stick in an editable field (or wherever you like) if (pUnit->IsPrefix()) { // Prefix units so show units followed by value camSnprintf( format, 256, _T("%%s%s"), (LPCTSTR) dpformat ); // ie. %s %.3f camSnprintf( p, 256, format, (LPCTSTR)Specifier, (double)Value ); // uses FP *OutputString = p; // Look for all zeros after decimal point and if so then remove //StripTrailingZeros(OutputString); } else { // Suffix units so show value followed by units camSnprintf( p, 256, dpformat, (double)Value ); // uses FP *OutputString = p; // Look for all zeros after decimal point and if so then remove StripTrailingZeros(OutputString); // Finally, add in the unit specifier *OutputString += Specifier; } // Extra bodge required so that if the user has specified display values using // a non full stop to show decimal points then we must replace the point that // is present by the specified character. if (DecimalPoint != '.') { ReplaceDecimalPoint(OutputString); } return TRUE; }

void Convert::NumberToString (  MILLIPOINT  Number, StringBase *  MyString )  [static]

Appends the string representation of the given number to the end of MyString. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/93 Parameters: Number  - The number to be turned into a string [INPUTS] MyString  - the string is appended to this string [OUTPUTS] Definition at line 904 of file convert.cpp. { INT32 Factor = 1; TCHAR ch[2]; ch[1] = TEXT('\0'); // Get a factor that while (Factor*10 <= Number) Factor *= 10; while (Factor > 1) { // calculate the most significant digit and remove it from the number INT32 Digit = INT32(Number / Factor); ch[0] = TEXT('0') + Digit; *MyString += String_8(ch); // Add the digit into the string Number = Number - (Digit*Factor); Factor /= 10; } // add in the last character ch[0] = TEXT('0') + (INT32)Number; *MyString += String_8(ch); }

BOOL Convert::ReadNumber (  const StringBase &  Str, INT32 *  pPos, double *  pResult )  [static]

General purpose routine for extracting the number from a string E.g. "42cm45.7mm" with *pPos == 0 returns TRUE with *pResult and 42.0 & *pPos == 2 "42cm-45.7mm" with *pPos == 4 returns TRUE with *pResult and -45.7 & *pPos == 9. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: pStr  - Ptr to the string to get value from [INPUTS] pPos - *pPos = the pos to start scannning the string from (0 is first char) pResult - Ptr to a double *pPos  is the pos the scanning stopped [OUTPUTS] pResult = The number represented at the specified portion of the string Returns: TRUE - a valid number was read FALSE - something's a bit dodgey about that number mate Errors: - Definition at line 613 of file convert.cpp. { INT32 len = Str.Length(); const TCHAR *pChar = Str; BOOL IsNegative = FALSE; double Number = 0.0; //Added for DBCS Strip leading crap while (*pPos < len && iswspace(pChar[*pPos])) //while (*pPos < len && pChar[*pPos] <= ' ') (*pPos)++; // Check for a minus sign; Added for DBCS if( pChar[*pPos] == MinusSign ) //if ( pChar[*pPos] == MinusSign ) { IsNegative = TRUE; (*pPos)++; if (*pPos >= len) return FALSE; } // Get the actual number Added for DBCS while( *pPos < len && ( StringBase::IsNumeric(pChar[*pPos]) || pChar[*pPos] == ThousandSep ) )//|| pChar[*pPos] == ThousandSep) ) { //Added for DBCS if (pChar[*pPos] != ThousandSep ) //if (pChar[*pPos] != ThousandSep) { Number = (Number * 10.0) + ( pChar[*pPos] - TEXT('0') ); } (*pPos)++; } // Check for a decimal place; Added for DBCS if ( pChar[*pPos] == DecimalPoint) //if ( pChar[*pPos] == DecimalPoint ) { (*pPos)++; if (*pPos < len) // If the string ends in a DP, then we return the number now { // Otherwise, we continue reading the fractional part of the string... INT32 DecimalFactor = 10; while ( *pPos < len && StringBase::IsNumeric(pChar[*pPos]) ) { Number += (double)( pChar[*pPos] - TEXT('0') ) / DecimalFactor; DecimalFactor *= 10; (*pPos)++; } } } // If the number started with a minus sign, then make sure it is negative if (IsNegative) Number = -Number; *pResult = Number; return TRUE; }

BOOL Convert::ReadUnitType (  const StringBase &  Str, INT32 *  pPos, UnitType *  pUnitType )  [static]

General purpose routine for extracting the unit type from a string E.g. "42cm45mm" with *pPos = 2 returns TRUE with *pUnitType == CENTIMETRES & *pPos == 4 "42cm45mm" with *pPos = 6 returns TRUE with *pUnitType == MILLIMETRES & *pPos == 8. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: pStr  - Ptr to the string to get unit type [INPUTS] pPos - *pPos = the pos to start scannning the string from (0 is first char) pUnitType - Ptr to a UnitType *pPos  is the pos the scanning stopped [OUTPUTS] pUnitType is the units represented by the string Returns: TRUE - units have been recognised and value stored in *pUnitType is valid OR no units have been specified and *pUnitType == NOTYPE FALSE - What are these units eh? Errors: - Definition at line 549 of file convert.cpp. { INT32 len = Str.Length(); const TCHAR *pChar = (const TCHAR *)Str; TCHAR UnitCharArray[256]; INT32 i; BOOL ok = TRUE; //Added for DBCS; Strip leading crap while (*pPos < len && iswspace(pChar[*pPos])) //while (*pPos < len && pChar[*pPos] <= ' ') (*pPos)++ ; i = 0; if (IsCharUnitType(pChar[*pPos])) { // Copy unit-specifying chars into UnitCharArray // NO LONGER copes with wierd unit specifiers that contain numbers too. e.g. "nu2", "b54c" // as of 18/5/95 (MarkN) while ( *pPos < len && (IsCharUnitType(pChar[*pPos])) && i<256) // || StringBase::IsNumeric(pChar[*pPos])) && UnitCharArray[i++] = pChar[(*pPos)++]; } UnitCharArray[i] = 0; // Visit the string Terminator (I'm a null char; that's what I do) String_256 UnitString = UnitCharArray; //char changed to TCHAR for DBCS // TCHAR* p = UnitString; // for debugging purposes DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList(); if (!UnitString.IsEmpty()) { // if the string isn't empty, then we must recognise the unit // otherwise we'll have to fail *pUnitType = pDocUnitList->FindUnitType(UnitString); ok = (*pUnitType != NOTYPE); } else *pUnitType = NOTYPE; // Empty string means NOTYPE means use a default type from somewhere return (ok); }

BOOL Convert::ReplaceDecimalPoint (  StringBase *  pString  )  [static]

Searches the specified string for a decimal point and replaces this with the specified DecimalPoint character. It assumes that a check has been made already to see if we are using a non-decimal point character and so this routine is only called when the replacement is actually required. This MUST ALWAYS be after the StripTrailingZeros code. Otherwise, the StripTrailingZeros code would have to search for two items, a decimal point and the international form of the decimal point. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 Parameters: pString  - Pointer to the string to be parsed. [INPUTS] pString  - Pointer to the string that should now have the proper decimal point [OUTPUTS] Returns: TRUE if the conversion worked, false otherwise See also: MillipointsToString; DimScale::ConvertToUnits; DoubleToString; Convert::StripTrailingZeros; Definition at line 390 of file convert.cpp. { // Could probably be optimised to be quicker // Make up a string of the new decimal point character String_8 InsertStr; ((TCHAR *) InsertStr)[0] = DecimalPoint; ((TCHAR *) InsertStr)[1] = 0; // Work out the position of the current decimal point character, - 1 if none INT32 Position; String_8 InsertMark(_R(IDS_CONVERT_DP_CHAR)); Position = pString->Sub(InsertMark); // If decimal point was found then put the new decimal point character in place if (Position > 0) { pString->Remove(Position, 1); pString->Insert(InsertStr, Position); } return TRUE; }

BOOL Convert::SetDecimalPointChar (  char  NewDecimalPoint  )  [static]

Allows the setting up of the character to separate whole part of number from the fractional part in displayed numbers e.g. 56.79 This is read from the OS at present. This function just provided just in case we wish to overide this in the future. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if set correctly, False otherwise. See also: GetDecimalPointChar(); GetCurrentNumberFormat(); Definition at line 303 of file convert.cpp. { // Don't allow a blank to be set. //if (NewDecimalPoint = '') return FALSE; DecimalPoint = NewDecimalPoint; return TRUE; }

BOOL Convert::SetNumberDecimalPlaces (  UINT32  NewDPs  )  [static]

Allows the setting up of the number of decimal places to display to by default This is read from the OS at present. This function just provided just in case we wish to overide this in the future. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: NewDPs  new number of decimal places to use [INPUTS] -  [OUTPUTS] Returns: True if set correctly, False otherwise. See also: GetNumberDecimalPlaces(); GetCurrentNumberFormat(); Definition at line 357 of file convert.cpp. { // Set some limit to the number allowed if (NewDPs > 9) return FALSE; NumDecimalPlaces = NewDPs; return TRUE; }

BOOL Convert::SetThousandsSepChar (  char  NewThousandsSep  )  [static]

Allows the setting up of the character to be used to separate thousands in displayed numbers e.g. 10,000. This is read from the OS at present. This function just provided just in case we wish to overide this in the future. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: True if set correctly, False otherwise. See also: GetThousandsSepChar(); GetCurrentNumberFormat(); Definition at line 331 of file convert.cpp. { // Don't allow a blank to be set. //if (NewThousandsSep = '') return FALSE; ThousandSep = NewThousandsSep; return TRUE; }

UINT32 Convert::StringToBytes (  const StringBase &  Str, BOOL *  Valid )  [static]

Takes a string with a textual description of an amount of memory, and returns the amount of bytes described by the string. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/95 Parameters: pStr  - pointer to all manner of memory amount specifying strings [INPUTS] such as "1024k", "1024 bytes", "1024", "1048576", "1Mb". (NB - The above will all return 1024 (and Valid == TRUE)). Valid  - used to flag a valid result. Invalid results will return 0 and [OUTPUTS] flag this variable to FALSE. Any non-numerically starting strings will cause this invalid state. Leading spaces shouldn't pose a problem... Returns: Number of bytes described by input string, so "1k" would produce 1024... Errors: At present we only use simple string matching, so "100 Tera-bytes" will return 100, as Tera is not supported and the bytes section is matched. Also "200 trams" will return 200*1024*1024, as the 'm' of trams is matched as flagging a mega-byte. See also: - Definition at line 1285 of file convert.cpp. { // Set up bad return value until we are fairly happy with the string *Valid = FALSE; //changed char to TCHAR for DBCS const TCHAR *CharStr = (const TCHAR *)Str; double Number = 0.0; INT32 Pos = 0; UINT32 ret = 0; // Try and read the value in using are routine // Cannot use atof as does not cope with non-standard decimal point and thousand // separator characters. // UINT32 ret=_ttoi(CharStr); // Rip the numbers from the start BOOL ok = ReadNumber(Str, &Pos, &Number); if (!ok) return 0; // bad number so return invalid // If negative then return invalid and zero. if (Number < 0) return 0; // If bigger than what can be held in a UINT32 then return the maximum and FALSE. if (Number > (double)UINT32_MAX) return UINT32_MAX; // We have what looks like a fairly valid number so set return flag True; *Valid = TRUE; // If value is zero then return with no more checking as not relevent if (Number == 0) return (0); if ( cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_SMALL_K)) /*"k"*/) || cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_LARGE_K)) /*"K"*/) ) { // Check if K or K is in the string and if so multiply by 1024 Number = Number*1024; // Kilobyte value } else if ( cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_SMALL_M)) /*"m"*/) || cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_LARGE_M)) /*"M"*/) ) { // Check if M or m is in the string and if so multiply by 1024 by 1024 Number = Number*1024*1024; // Megabyte value } else if ( cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_SMALL_G)) /*"g"*/) || cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_LARGE_G)) /*"G"*/) ) { // Check if G or g is in the string and if so multiply by 1024 by 1024 by 1024 Number = Number*1024*1024*1024; // Gigabyte value } else if ( cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_SMALL_BYTE)) /*"byte"*/) || cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_MEDIUM_BYTE)) /*"Byte"*/) || cc_lstrstr(CharStr, (TCHAR *)String_16(_R(IDS_CONVERT_LARGE_BYTE)) /*"BYTE"*/) ) { // Check if byte or variation of specified in which case just return the value // Number = Number; // straight byte value } // if none of the above then assume value is in bytes and hence do nothing // If bigger than what can be held in a UINT32 then return the maximum and FALSE. if (Number > (double)UINT32_MAX) return UINT32_MAX; // We just want the interger part of the number specified as fractional parts are non-valid ret = (UINT32)Number; TRACEUSER( "Neville", _T("%s -> %d\n"), (char *)CharStr, ret ); return ret; }

BOOL Convert::StringToComponents (  const StringBase &  str, double *  pValue, UnitType *  pUnits )  [static]

General purpose routine for extracting the value and unit components of a string. E.g.1 the string "42.6in" would extract the value 42.6 and the unit type INCHES E.g.2 The string "42.6" would give *pValue=42.6,*pUnits=NOTYPE, and TRUE is returned. E.g.3 "4in5in" gives *pValue=9,*pUnits=INCHES, and returns TRUE E.g.4 "1in2cm" gives *pValue = 1.79,*pUnits=INCHES, and returns TRUE In this case it takes the first unit specified as the dominant unit (INCHES in this case), so the result is 1in plus 2cm converted to INCHES which is about 0.79in. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 (changed considerably on 27/6/94 by Markn) Parameters: InputString  - The string to get values from [INPUTS] pValue - The value of the numerical part of the string pUnits - The unit value of the unit part of the string if no units are specified, *pUnits = NOTYPE -  [OUTPUTS] Returns: TRUE - Valid string FALSE - Something wrong with the string Errors: This function can fail if the string was not a valid one. ie the string '12zx'. zx is not a unit that Camelot understands and so fails. Definition at line 733 of file convert.cpp. { TCHAR* MyString; TCHAR Char; INT32 Pos = 0; INT32 len = str.Length(); String_256 InputString( str ); // BOOL IsNegative = FALSE; double Result = 0.0; UnitType MainUnits = NOTYPE; *pValue = 1.0; *pUnits = INCHES; // Make sure that the string is in lower case as per SI units InputString.toLower(); MyString = (TCHAR *)InputString; // I might consider adding this to the base class StringBase, BUT at the moment // its not really necessary .... // // JCF: fixed this to be internationally portable ie. what is alphanumeric in // your language? // while (Pos < len) { if (!StringBase::IsAlphaNumeric(MyString[Pos]) && MyString[Pos] != TEXT('-') && MyString[Pos] != TEXT('.') && MyString[Pos] != TEXT(',')) { return FALSE; } Pos++; } Pos = 0; while (Pos < len) { double Number = 0.0; UnitType Units; // Strip leading crap Added for DBCS while (Pos < len && iswspace( MyString[Pos] )) //while (Pos < len && MyString[Pos] <= ' ') Pos++; Char = MyString[Pos]; if (IsCharStartOfNumber(Char)) { if (!ReadNumber(InputString,&Pos,&Number)) return FALSE; if (!ReadUnitType(InputString,&Pos,&Units)) return FALSE; } else { if (!ReadUnitType(InputString,&Pos,&Units)) return FALSE; if (!ReadNumber(InputString,&Pos,&Number)) return FALSE; } if (MainUnits == NOTYPE) MainUnits = Units; if (MainUnits != Units && MainUnits != NOTYPE) Number = ConvertToNewUnits(Number,Units,MainUnits); Result += Number; } *pUnits = MainUnits; *pValue = Result; return TRUE; }

BOOL Convert::StringToDouble (  const StringBase &  InputString, double *  Number )  [static]

Converts a string into its double equivalent. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 16/12/94 Parameters: InputString  - The string that you want turning into a double [INPUTS] Number  - The number you want turning into a string [OUTPUTS] Returns: TRUE if the conversion worked, false otherwise See also: DoubleToString Used to be a bodge as atof() doesn't work in unicode but converted to use the other functions which should do it properly. Definition at line 1183 of file convert.cpp. { //#if UNICODE //#error "I'm screwed! atof() doesn't work for UNICODE" //#else // *Number = atof((char *)*InputString); // return(TRUE); //#endif // Cannot use atof as does not cope with a non-decimal point character which // the user may be specifying so use our form of atof. // atof will also allow say 26.98mm where we should really be erroring. // ReadNumber ignores everything after a dodgy decimal point which is not correct. // StringToComponents will include units as well. We do not want this part so ignore it. UnitType Units; BOOL ok = StringToComponents(InputString,Number,&Units); // Check if units are NOTYPE and if not then return failure. if (Units != NOTYPE) return FALSE; return ok; }

double Convert::StringToDouble (  const StringBase &  InputString, UnitType  Default, BOOL *  ValidString )  [static]

Convert the string into a floating point representation of the number of millipoints. eg '1in' would be converted to 72000.0 millipoints. Does NOT cope with '0.25in0.75in' - this would return 18000.0 millipoints instead of 72000.0 millipoints. If you want a MILLIPOINT value, use StringToMillipoint to ensure correct rounding. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/3/94 - modified 14/6/94 Parameters: pInputString  - The string to convert to its millipoint value [INPUTS] Default - the Unit type to be used if no other units have been specified in the string ValidString  - The Address of a bool. This will be set to TRUE if [OUTPUTS] the function converted the string without error, FALSE otherwise. Returns: double - the number of Millipoints represented by the string Errors: This function can fail if the string was not a valid one. ie the string '12zx'. zx is not a unit that StringToDouble understands and so fails. See also: StringToMillipoint Definition at line 838 of file convert.cpp. { double Number = 1.0; UnitType Units; *ValidString = StringToComponents( InputString,&Number,&Units); if (Units == NOTYPE) Units = Default; if (*ValidString) { DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList(); Unit* pUnit = pDocUnitList->FindUnit(Units); return (Number * pUnit->GetMillipoints()); // Get the number to millipoints and multiply } else return 72000.0; }

BOOL Convert::StringToLong (  const StringBase &  InputString, INT32 *  pNumber )  [static]

Converts a string into its INT32 equivalent. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/9/93 Parameters: InputString  - The string that you want turning into a number [INPUTS] Number  - The number you want turning into a string [OUTPUTS] Returns: TRUE if the conversion worked, false otherwise See also: LongToString Definition at line 1132 of file convert.cpp. { // Get a pointer version of the string const TCHAR* pMyString = (const TCHAR*)InputString; INT32 nLength = InputString.Length(); INT32 nPos = 0; // Check for a minus sign - added for DBCS BOOL fIsNegative = FALSE; if (pMyString[nPos] == TEXT('-') ) // if (pMyString[Pos] == TEXT('-')) { fIsNegative = TRUE; nPos++; if (nPos >= nLength) return 0; } // Get the actual number INT32 nTotal = 0; while (nPos < nLength && StringBase::IsNumeric(pMyString[nPos])) { nTotal = (nTotal * 10) + pMyString[nPos] - TEXT('0'); nPos++; } // If we have not read in the whole string, then it was not valid if (nPos < nLength && !StringBase::IsSpace(pMyString[nPos])) return FALSE; // If the number started with a minus sign, then make sure it is negative if (fIsNegative) nTotal = -nTotal; *pNumber = nTotal; return TRUE; }

MILLIPOINT Convert::StringToMillipoints (  const StringBase &  InputString, UnitType  Default, BOOL *  ValidString )  [static]

Convert the string into a MILLIPOINT representation of the number of millipoints. eg '1in' would be converted to 72000 millipoints. Does NOT cope with '0.25in0.75in' - this would return 18000 millipoints instead of 72000 millipoints. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/3/94 - modified 14/6/94 Parameters: pInputString  - The string to convert to its millipoint value [INPUTS] Default - the Unit type to be used if no other units have been specified in the string ValidString  - The Address of a bool. This will be set to TRUE if [OUTPUTS] the function converted the string without error, FALSE otherwise. Returns: MILLIPOINT - An integer version of the number of Millipoints represented by the string Errors: This function can fail if the string was not a valid one. ie the string '12zx'. zx is not a unit that StringToDouble understands and so fails. Definition at line 883 of file convert.cpp. { double result = StringToDouble( InputString,Default,ValidString); return (MILLIPOINT)(result+0.5); }

BOOL Convert::StripTrailingZeros (  StringBase *  pString  )  [static]

Strip trailing zeros (& decimal point) from a string containing a decimal number This MUST ALWAYS be called before the replace decimal point character code. Otherwise, we would have to search for two items, a decimal point and the international form of the decimal point. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 12/7/95 Parameters: pString  - string to have trailing zeros removed [INPUTS] pString  - string with trailing zeros removed [OUTPUTS] Returns: FALSE if fails See also: MillipointsToString; DimScale::ConvertToUnits; DoubleToString; Convert::ReplaceDecimalPoint; Definition at line 433 of file convert.cpp. { // Get the decimal point character that we are going to search for into one of our // strings. This MUST be the decimal point character as this is ALWAYS called before // the replace decimal point character. Otherwise, we would have to search for two // items. String_8 DPChar(_R(IDS_CONVERT_DP_CHAR)); const String_8 ZeroChar(_R(IDS_CONVERT_ZERO_CHAR)); // if there is a decimal point in the string ... if (pString->Sub(DPChar)!=-1) { // skip backwards over trailing zeros String_8 TmpStr; INT32 NewStrLen = pString->Length(); do { NewStrLen-=1; pString->Mid(&TmpStr,NewStrLen,1); } while (TmpStr==ZeroChar); // if this previous char is NOT a decimal point DO NOT strip it if (TmpStr!=DPChar) NewStrLen+=1; // remove the trailing zeros from the original string pString->Left(pString,NewStrLen); } return TRUE; }

---

Member Data Documentation

char Convert::DecimalPoint = '.' [static, protected]

Definition at line 200 of file convert.h.

char Convert::MinusSign = '-' [static, protected]

Definition at line 202 of file convert.h.

UINT32 Convert::NumDecimalPlaces = 2 [static, protected]

Definition at line 203 of file convert.h.

char Convert::ThousandSep = ',' [static, protected]

Definition at line 201 of file convert.h.

---

The documentation for this class was generated from the following files:

• wxOil/convert.h (r1785/r1269)
• wxOil/convert.cpp (r1785/r1282)

---