DocUnitList Class Reference

Encapsulates units within Camelot. All units (i.e. default and user-defined ones) are an instance of this class. Each document has its own list of units controlled by an instance of DocUnitList within the Document class. Therefore you should get hold of the DocUnitList within the current doc when you want to add/delete/edit/find a unit. More...

#include <units.h>

Inheritance diagram for DocUnitList:

List of all members.

Public Member Functions
	DocUnitList ()
	Default constructor for a document unit list. Initialises the object.
	~DocUnitList ()
	Default destructor for a document unit list. Deletes all units in the list.
Unit *	FindUnit (UnitType ThisUnit)
	Find a unit using its type.
Unit *	FindUnit (INT32 Index)
	Find a unit by index.
UnitType	FindUnitType (const StringBase &Str)
UnitType	FindUnitTypeFromToken (const StringBase &Str)
INT32	FindUnitIndex (UnitType ThisUnit)
Unit *	FindUserUnit (INT32 Index)
Unit *	FindFirstUserUnit ()
Unit *	FindNextUserUnit (Unit *pThisUnit)
void	UnitHasChanged (UnitType ChangedUnitType)
	This informs the class that the definition of a unit has changed. It ensures that all units that are descendents of the changed unit are recalculated.
BOOL	MakeNewUnit (Unit **ppUnit, BOOL Initialise=TRUE)
	Defines all the default units and places them on the list.
BOOL	MakeDefaultUnits ()
	This creates the default units for a document. It tries to find the default units via three sources (highest priority first): Disk (Not implemented yet) Bound-in resource (defined in winoil.ini) Hard-wired defaults.
INT32	GetNumUnits ()
	Returns the num units in the list.
UnitReason	DeleteUnit (UnitType ThisUnitType)
	Lets you delete a unit from the list.
BOOL	HasDescendents (UnitType ThisUnitType)
	Finds out is there are other units that are decendents of this unit, i.e. other units that are based on this unit either directly or indirectly e.g. A->B->C (B is based on A, C is based on B). Both A nd B have decendents. C does not.
BOOL	IsDescendent (Unit *pThisUnit, UnitType NewBaseUnitType)
	Checks to see if this unit is a descendent of NewUnitType E.g. A->B->C (B is based on A, and C is based on B) Both B and C are descendents of A.
void	RecalcUnit (Unit *pThisUnit)
	Recalculates the number of millipoints in this unit by multiplying the ratio between this and the base unit, with the num millipoints in the base unit. E.g. Recalc Metres : Num Millipoints in metre = Num MP in centimetre * 100; IMPORTANT: This can only recalculate units that are based on another unit. If the unit is not based on another unit (i.e. its base type is NOTYPE) then nothing happens.
BOOL	RecalcUnit (Unit *pThisUnit, UnitType ChangedUnitType)
	This recalcs the unit's definition (i.e. the num millipoints that make it up) if it is a descendent of ChangedUnitType.
BOOL	SetBaseUnitType (Unit *pThisUnit, UnitType NewBaseUnitType)
	Lets you set that base unit type, dude!
UnitType	GetScaleUnits ()
	For getting hold of those pesky scale units.
void	SetScaleUnits (UnitType NewUnits)
	Sets the scale units of the object directly.
UnitType	GetPageUnits ()
	For getting hold of those pesky page units.
void	SetPageUnits (UnitType NewUnits)
	Sets the page units of the object directly.
UnitType	GetFontUnits ()
	For getting hold of those pesky font units.
void	SetFontUnits (UnitType NewUnits)
	Sets the font units of the object directly.
String_32	GetToken (UnitType)
	Easy way of getting a unit token string. IMPORTANT: This is a general function that can cope with special UnitType values like AUTOMATIC and NOTYPE, i.e. types that don't correspond to an actual instance of Unit.
String_32	GetSpecifier (UnitType)
	Easy way of getting a unit specifier string. If bad UnitType and hence no unit found, returns a blank string.
Static Public Member Functions
static BOOL	Init ()
	Initialises the DocUnitList class MUST BE CALLED BEFORE ANY OTHER FUNCTION IN THIS CLASS.
static BOOL	Deinit ()
	Deinitialises the doc unit list class.
static DocUnitList *	GetCurrentDocUnitList ()
	Lets you set that base unit type, dude!
Private Member Functions
BOOL	MakeFactoryDefaultUnits ()
	Defines all the default units for a document and places them on the list. Called early on in the document initialisation routines. NOTE: Added some ERROR2 checks so that problems in the default units can be trapped early on rather than a lot later. Should not normally go off unless some of the error checking has problems.
void	OutputTrace (char *err, const TCHAR *TokenBuf)
	Helper funtion for the token-reading functions.
BOOL	ReadLong (CCLexFile &file, void *pLong, char *err)
	Reads a INT32 value from file and puts it in pLong. If it fails, err is passed to OutputTrace() and FALSE is returned.
BOOL	ReadDouble (CCLexFile &file, double *pDouble, char *err)
	Reads a double value from file and puts it in pDouble. If it fails, err is passed to OutputTrace() and FALSE is returned.
BOOL	ReadString (CCLexFile &file, StringBase *pStr, char *err)
	Reads a string from file and puts it in pStr. If it fails, err is passed to OutputTrace() and FALSE is returned.
BOOL	ReadUnitsFromFile (CCLexFile &file)
	Reads the unit definitions from the given file.
BOOL	ReadUnitsFromDisk ()
	Reads the unit definitions from disk (i.e. writable media).
BOOL	ReadUnitsFromRes ()
	Reads the unit definitions from the bound in resource.
Static Private Member Functions
static BOOL	CheckUnitTypesValid ()
	This checks to see if the UnitType enum and the defines that specify unit IDs match up.
Private Attributes
INT32	NumUnits
INT32	NextUnitNum
INT32	NextUnitType
BOOL	DefaultsMade
UnitType	ScaleUnits
UnitType	PageUnits
UnitType	FontUnits
UnitType	LastEditedUnit

---

Detailed Description

Encapsulates units within Camelot. All units (i.e. default and user-defined ones) are an instance of this class. Each document has its own list of units controlled by an instance of DocUnitList within the Document class. Therefore you should get hold of the DocUnitList within the current doc when you want to add/delete/edit/find a unit.

Author:

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

Date:

5/7/94

See also:

DocUnitList,Document

Definition at line 253 of file units.h.

---

Constructor & Destructor Documentation

DocUnitList::DocUnitList (   )

Default constructor for a document unit list. Initialises the object. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 702 of file units.cpp. { NumUnits = 0; NextUnitNum = 0; NextUnitType = NUM_DEFAULT_UNIT_TYPES; DefaultsMade = FALSE; LastEditedUnit = NOTYPE; SetScaleUnits(AUTOMATIC); SetPageUnits(CENTIMETRES); SetFontUnits(COMP_POINTS); }

DocUnitList::~DocUnitList (   )

Default destructor for a document unit list. Deletes all units in the list. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 729 of file units.cpp. { /* Unit* pUnit = (Unit*)this->GetHead(); Unit* pOldUnit; while (pUnit != NULL) { pOldUnit = pUnit; pUnit = (Unit*)this->GetNext(pOldUnit); this->RemoveItem(pOldUnit); delete pOldUnit; } */ ListItem* pItem; while ((pItem = this->RemoveHead()) != NULL) delete pItem; }

---

Member Function Documentation

BOOL DocUnitList::CheckUnitTypesValid (   )  [static, private]

This checks to see if the UnitType enum and the defines that specify unit IDs match up. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if valid, FALSE if not UnitType was originally defined as an enum so that it could by used like a normal type. Later on, internationalisation came along requiring the ability to define the default set of units via an .ini file. This required unit types to be specified using defines so that C preprocessing could be used to make the creation of the built-in .ini file easy to read. This conflict meant that it could be possible for these values to get out of step. This function goes some way to ensure that they don't. Definition at line 666 of file units.cpp. { BOOL ok = TRUE; if (ok) ok = (MILLIMETRES == UNIT_MILLIMETRES); if (ok) ok = (CENTIMETRES == UNIT_CENTIMETRES); if (ok) ok = (METRES == UNIT_METRES); if (ok) ok = (INCHES == UNIT_INCHES); if (ok) ok = (FEET == UNIT_FEET); if (ok) ok = (YARDS == UNIT_YARDS); if (ok) ok = (COMP_POINTS == UNIT_COMP_POINTS); if (ok) ok = (PICAS == UNIT_PICAS); if (ok) ok = (MILLIPOINTS == UNIT_MILLIPOINTS); if (ok) ok = (MILES == UNIT_MILES); if (ok) ok = (KILOMETRES == UNIT_KILOMETRES); if (ok) ok = (PIXELS == UNIT_PIXELS); ERROR2IF(!ok,FALSE,"One or more enum UnitType values are different to the #define UNIT_ values"); return (ok); }

BOOL DocUnitList::Deinit (  void   )  [static]

Deinitialises the doc unit list class. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if deinitialised OK Definition at line 780 of file units.cpp. { return TRUE; }

UnitReason DocUnitList::DeleteUnit (  UnitType  ThisUnitType  )

Lets you delete a unit from the list. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/7/94 Parameters: ThisUnitType  = the type of the unit to delete [INPUTS] -  [OUTPUTS] Returns: UNITREASON_OK - The unit has been deleted UNITREASON_HASDESCENDENTS - Other units are based on this unit e.g. cm is based on mm UNITREASON_BEINGUSED - This unit type is being used in the document e.g. page units may use this unit Errors: Can only be called once per instance. Errors if called again. Definition at line 865 of file units.cpp. { if (HasDescendents(ThisUnitType)) return UNITREASON_HASDESCENDENTS; if (PageUnits == ThisUnitType || ScaleUnits == ThisUnitType || FontUnits == ThisUnitType) return UNITREASON_BEINGUSED; // Tell everybody that the unit is about to be deleted) BROADCAST_TO_ALL(UnitMsg(this,ThisUnitType,UnitMsg::BEFOREDELETE)); this->RemoveItem(FindUnit(ThisUnitType)); NumUnits--; // Tell everybody that the unit is about to be deleted) BROADCAST_TO_ALL(UnitMsg(this,NOTYPE,UnitMsg::AFTERDELETE)); return UNITREASON_OK; }

Unit * DocUnitList::FindFirstUserUnit (   )

Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Created: 5/7/94 Inputs: - Outputs: - Returns: Ptr to the first user (or non-default) unit in the list NULL is returned if all the units are default ones, or the list is empty Purpose: Lets you get hold of that elusive first user-defined unit. All units are either default or user-defined units. Definition at line 1112 of file units.cpp. { // Get a pointer to the first unit in the list Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { if (!pUnit->IsDefault()) return pUnit; pUnit = (Unit*) this->GetNext(pUnit); } return (pUnit); }

Unit * DocUnitList::FindNextUserUnit (  Unit *  pUnit  )

Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Created: 5/7/94 Inputs: pUnit = ptr to a unit in the list Outputs: - Returns: Ptr to the first user (or non-default) unit in the list NULL is returned if all the units are default ones, or the list is empty Purpose: Lets you get hold of that elusive first user-defined unit. All units are either default or user-defined units. Definition at line 1144 of file units.cpp. { pUnit = (Unit*) this->GetNext(pUnit); while (pUnit != NULL) { if (!pUnit->IsDefault()) return pUnit; pUnit = (Unit*) this->GetNext(pUnit); } return (pUnit); }

Unit * DocUnitList::FindUnit (  INT32  Index  )

Find a unit by index. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/94 Parameters: Index  = indexes directly into the unit list (0 = first unit in list) [INPUTS] -  [OUTPUTS] Returns: Ptr to the unit. NULL is returned if not found. Definition at line 950 of file units.cpp. { ERROR3IF(Index < 0,"DocUnitList::FindUnit A negative index? Now there's a novelty"); ERROR3IF(Index >= NumUnits,"DocUnitList::FindUnit Index is greater than num units in system"); if (Index < 0 || Index >= NumUnits) return NULL; // Problem, so return quickly Unit* pUnit = (Unit*) this->GetHead(); while ((pUnit != NULL) && (Index > 0)) { pUnit = (Unit*) this->GetNext(pUnit); Index--; } ERROR3IF(pUnit == NULL,"DocUnitList::FindUnit Can't find the unit"); return pUnit; }

Unit * DocUnitList::FindUnit (  UnitType  ThisUnit  )

Find a unit using its type. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: ThisUnit  = the unit type of the unit we want [INPUTS] -  [OUTPUTS] Returns: Ptr to the unit. NULL is returned if not found. Definition at line 919 of file units.cpp. { Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { if (pUnit->GetUnitType() == ThisUnit) return pUnit; pUnit = (Unit*) this->GetNext(pUnit); } ERROR3IF(pUnit == NULL,"Can't find the unit"); return NULL; }

INT32 DocUnitList::FindUnitIndex (  UnitType  ThisUnit  )

Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Created: 5/7/94 Inputs: ThisUnit = Type of unit you want Returns: The position of this unit in the list of units. Purpose: Get the position of the unit in the list of units. Used mainly in conjunction with drop-down lists of units Definition at line 1079 of file units.cpp. { Unit* pUnit = (Unit*) this->GetHead(); INT32 Index = 0; while ((pUnit != NULL) && (pUnit->GetUnitType() != ThisUnit)) { pUnit = (Unit*) this->GetNext(pUnit); Index++; } ERROR3IF(pUnit == NULL,"Can't find the unit"); if (pUnit == NULL) Index = 0; // Safe for retail builds return Index; }

UnitType DocUnitList::FindUnitType (  const StringBase &  Str  )

Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Created: 5/7/94 Inputs: Str = string specifying a unit specifier Returns: The type of unit represented by the string passed in Purpose: Identifies the unit by the unit specifier string E.g. 'cm', 'km','mi', 'bananas', etc If the unit is not recognised, NOTYPE is returned SeeAlso: DocUnitList::FindUnitTypeFromToken; Definition at line 985 of file units.cpp. { String_32 Specifier; String_32 SearchStr; INT32 len = min(32,Str.Length()); const TCHAR* p1 = (const TCHAR *) Str; TCHAR* p2 = (TCHAR *) SearchStr; // Copy param Str into SearchStr INT32 i; for (i=0;i<len;i++) p2[i] = p1[i]; p2[i] = 0; // Terminate SearchStr.toLower(); // and convert to lower case Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { Specifier = pUnit->GetSpecifier(); Specifier.toLower(); if (Specifier == SearchStr) return (pUnit->GetUnitType()); pUnit = (Unit*) this->GetNext(pUnit); } return NOTYPE; }

UnitType DocUnitList::FindUnitTypeFromToken (  const StringBase &  Str  )

Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Created: 1/9/95 Inputs: Str = string specifying a unit token Returns: The type of unit represented by the string passed in Purpose: Identifies the unit by the unit token string E.g. 'cm', 'km','mi', 'bananas', etc If the unit is not recognised, NOTYPE is returned SeeAlso: DocUnitList::FindUnitType; Definition at line 1033 of file units.cpp. { String_32 Token; String_32 SearchStr; INT32 len = min(32,Str.Length()); const TCHAR* p1 = Str; TCHAR* p2 = SearchStr; // Copy param Str into SearchStr INT32 i; for (i=0;i<len;i++) p2[i] = p1[i]; p2[i] = 0; // Terminate SearchStr.toLower(); // and convert to lower case Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { Token = pUnit->GetToken(); Token.toLower(); if (Token == SearchStr) return (pUnit->GetUnitType()); pUnit = (Unit*) this->GetNext(pUnit); } return NOTYPE; }

Unit * DocUnitList::FindUserUnit (  INT32  Index  )

Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Created: 7/7/94 Inputs: Index = the index into the list of user-defined units Outputs: - Returns: Ptr to the Index-th user (or non-default) unit in the list NULL is returned if there isn't an Index-th user unit Purpose: Lets you get hold of that elusive Index-th user-defined unit. SeeAlso: FindFirstUserUnit,FindNextUserUnit Definition at line 1175 of file units.cpp. { if (Index < 0) return NULL; Unit* pUnit = FindFirstUserUnit(); while (pUnit != NULL && Index > 0) { pUnit = FindNextUserUnit(pUnit); Index--; } return (pUnit); }

DocUnitList * DocUnitList::GetCurrentDocUnitList (   )  [static]

Lets you set that base unit type, dude! Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Ptr to the doc unit list object of the current doc, or NULL if there isn't one Definition at line 1431 of file units.cpp. { // Get the current doc and return if there is not one Document* pDoc = Document::GetCurrent(); //ERROR3IF(pDoc==NULL, "Can't find the current doc"); if (pDoc==NULL) return NULL; // get the Unit list and return it #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) ERROR3IF(pDoc->GetDocUnitList()==NULL, "Can't find the doc unit list in the current doc"); #endif return (pDoc->GetDocUnitList()); }

UnitType DocUnitList::GetFontUnits (   )

For getting hold of those pesky font units. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The font units of this object See also: - Definition at line 1555 of file units.cpp. { return (FontUnits); }

INT32 DocUnitList::GetNumUnits (   )

Returns the num units in the list. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The num defined units in the list Definition at line 900 of file units.cpp. { return NumUnits; }

UnitType DocUnitList::GetPageUnits (   )

For getting hold of those pesky page units. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The page units of this object See also: - Definition at line 1517 of file units.cpp. { return (PageUnits); }

UnitType DocUnitList::GetScaleUnits (   )

For getting hold of those pesky scale units. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The scale units of this object See also: - Definition at line 1479 of file units.cpp. { return ScaleUnits; }

String_32 DocUnitList::GetSpecifier (  UnitType  ThisUnitType  )

Easy way of getting a unit specifier string. If bad UnitType and hence no unit found, returns a blank string. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/95 Parameters: ThisUnitType  = type of unit you want specfier of [INPUTS] -  [OUTPUTS] Returns: The Specifier for the unit, i.e. the string that describes the unit e.g. "cm" See also: DocUnitList::GetToken; Unit::GetToken Definition at line 1624 of file units.cpp. { String_32 Str = _T(""); Unit* pUnit = NULL; pUnit = FindUnit(ThisUnitType); if (pUnit) Str = pUnit->GetSpecifier(); return Str; }

String_32 DocUnitList::GetToken (  UnitType  ThisUnitType  )

Easy way of getting a unit token string. IMPORTANT: This is a general function that can cope with special UnitType values like AUTOMATIC and NOTYPE, i.e. types that don't correspond to an actual instance of Unit. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: ThisUnitType  = type of unit you want token of [INPUTS] -  [OUTPUTS] Returns: The token for the unit, i.e. the string that describes the unit e.g. "Centimetres" See also: DocUnitList::GetSpecifier; Unit::GetSpecifier; Definition at line 1578 of file units.cpp. { String_32 Str; switch (ThisUnitType) { case AUTOMATIC : Str = String_32(_R(IDS_AUTOMATIC)); break; case NOTYPE : Str = String_32(_R(IDS_NOTYPE)); break; default : { Unit * pUnit = NULL; pUnit = FindUnit(ThisUnitType); if (pUnit) Str = pUnit->GetToken(); else Str = String_32(_R(IDS_NOTYPE)); } break; } return Str; }

BOOL DocUnitList::HasDescendents (  UnitType  ThisUnitType  )

Finds out is there are other units that are decendents of this unit, i.e. other units that are based on this unit either directly or indirectly e.g. A->B->C (B is based on A, C is based on B). Both A nd B have decendents. C does not. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/7/94 Parameters: ThisUnitType  = The unit type to check for decendents [INPUTS] -  [OUTPUTS] Returns: TRUE - This unit is has one or more descendents FALSE - No other unit is based on this unit Definition at line 1370 of file units.cpp. { Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { if (pUnit->GetUnitType() != ThisUnitType) { if (IsDescendent(pUnit,ThisUnitType)) return TRUE; } pUnit = (Unit*) this->GetNext(pUnit); } return FALSE; }

BOOL DocUnitList::Init (  void   )  [static]

Initialises the DocUnitList class MUST BE CALLED BEFORE ANY OTHER FUNCTION IN THIS CLASS. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from SimpleCCObject. Definition at line 762 of file units.cpp. { return CheckUnitTypesValid(); }

BOOL DocUnitList::IsDescendent (  Unit *  pThisUnit, UnitType  NewUnitType )

Checks to see if this unit is a descendent of NewUnitType E.g. A->B->C (B is based on A, and C is based on B) Both B and C are descendents of A. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: pThisUnit  = ptr to unit in question [INPUTS] NewUnitType = the unit type to check against accendency -  [OUTPUTS] Returns: TRUE - This unit is a descendent of NewUnitType FALSE - Never heard of the unit guv. Definition at line 1340 of file units.cpp. { if (pThisUnit->GetBaseUnitType() == NOTYPE) return FALSE; if (pThisUnit->GetBaseUnitType() == NewUnitType) return TRUE; Unit* pBaseUnit = FindUnit(pThisUnit->GetBaseUnitType()); return (IsDescendent(pBaseUnit,NewUnitType)); }

BOOL DocUnitList::MakeDefaultUnits (   )

This creates the default units for a document. It tries to find the default units via three sources (highest priority first): Disk (Not implemented yet) Bound-in resource (defined in winoil.ini) Hard-wired defaults. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 1692 of file units.cpp. { ERROR3IF(DefaultsMade,"MakeDefaultUnits has already been called for this instance of DocUnitList"); if (DefaultsMade) return TRUE; // Ensure the list is empty before proceeding DeleteAll(); BOOL ok = TRUE; ok = ReadUnitsFromDisk(); #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) if (!ok) ok = ReadUnitsFromRes(); #endif if (!ok) ok = MakeFactoryDefaultUnits(); DefaultsMade = ok; return (ok); }

BOOL DocUnitList::MakeFactoryDefaultUnits (   )  [private]

Defines all the default units for a document and places them on the list. Called early on in the document initialisation routines. NOTE: Added some ERROR2 checks so that problems in the default units can be trapped early on rather than a lot later. Should not normally go off unless some of the error checking has problems. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - successfully added all default units to the doc unit list FALSE - Can't add all the units to the list (lack of memory most likely) (Markn 23/11/95 - The name of this function has changed so that it is no longer the routine called by the document initialisation code) Returns: Errors: Can only be called once per instance. Errors if called again. Definition at line 2115 of file units.cpp. { // Remove all previously defined units. We're starting from scratch DeleteAll(); Unit* pUnit = NULL; BOOL ok = TRUE; // Default unit - Millimetres if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_MILLIMETRES)); String_32 SpecifierStr(_R(IDS_MM)); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetUnitType(MILLIMETRES); ok = pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr) && pUnit->SetBaseUnitType(NOTYPE) && pUnit->SetMillipoints(MM_MP_VAL); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad MILLIMETRES"); } else return FALSE; // Default unit - Centimetres if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_CENTIMETRES)); String_32 SpecifierStr(_R(IDS_CM)); pUnit->SetUnitType(CENTIMETRES); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(MILLIMETRES); ok = pUnit->SetBaseNumerator(10) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(CM_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad CENTIMETRES"); } else return FALSE; // Default unit - Metres if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_METRES)); String_32 SpecifierStr(_R(IDS_M)); pUnit->SetUnitType(METRES); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(CENTIMETRES); ok = pUnit->SetBaseNumerator(100) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(M_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad METRES"); } else return FALSE; // Default unit - Kilometres if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_KILOMETRES)); String_32 SpecifierStr(_R(IDS_KM)); pUnit->SetUnitType(KILOMETRES); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(METRES); ok = pUnit->SetBaseNumerator(1000) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(KM_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad KILOMETRES"); } else return FALSE; // Default unit - Millipoints if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_MILLIPOINTS)); String_32 SpecifierStr(_R(IDS_MP)); pUnit->SetUnitType(MILLIPOINTS); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(NOTYPE); ok = pUnit->SetMillipoints(MP_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad MILLIPOINTS"); } else return FALSE; // Default unit - Computer points if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_COMP_POINTS)); String_32 SpecifierStr(_R(IDS_PT)); pUnit->SetUnitType(COMP_POINTS); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(MILLIPOINTS); ok = pUnit->SetBaseNumerator(1000) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(PT_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad COMP_POINTS"); } else return FALSE; // Default unit - Picas if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_PICAS)); String_32 SpecifierStr(_R(IDS_PI)); pUnit->SetUnitType(PICAS); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(COMP_POINTS); ok = pUnit->SetBaseNumerator(12) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(PI_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad PICAS"); } else return FALSE; // Default unit - Inches if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_INCHES)); String_32 SpecifierStr(_R(IDS_IN)); pUnit->SetUnitType(INCHES); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(PICAS); ok = pUnit->SetBaseNumerator(6) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(IN_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad INCHES"); } else return FALSE; // Default unit - Feet if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_FEET)); String_32 SpecifierStr(_R(IDS_FT)); pUnit->SetUnitType(FEET); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(INCHES); ok = pUnit->SetBaseNumerator(12) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(FT_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad FEET"); } else return FALSE; // Default unit - Yards if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_YARDS)); String_32 SpecifierStr(_R(IDS_YD)); pUnit->SetUnitType(YARDS); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(FEET); ok = pUnit->SetBaseNumerator(3) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(YD_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad YARDS"); } else return FALSE; // Default unit - Miles if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_MILES)); String_32 SpecifierStr(_R(IDS_MI)); pUnit->SetUnitType(MILES); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(YARDS); ok = pUnit->SetBaseNumerator(1760) && pUnit->SetBaseDenominator(1) && pUnit->SetMillipoints(MI_MP_VAL) && pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad MILES"); } else return FALSE; // Default unit - Pixels if (MakeNewUnit(&pUnit,FALSE)) { String_32 TokenStr(_R(IDS_PIXELS)); String_32 SpecifierStr(_R(IDS_PX)); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(FALSE); pUnit->SetUnitType(PIXELS); ok = pUnit->SetToken(TokenStr) && pUnit->SetSpecifier(SpecifierStr) && pUnit->SetBaseUnitType(NOTYPE) && pUnit->SetMillipoints(PX_MP_VAL); ERROR2IF(!ok,FALSE,"DocUnitList::MakeFactoryDefaultUnits bad PIXELS"); } else return FALSE; return TRUE; }

BOOL DocUnitList::MakeNewUnit (  Unit **  ppUnit, BOOL  Initialise = TRUE )

Defines all the default units and places them on the list. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: ppUnit  = ptr to ptr to a unit [INPUTS] Initialise - if TRUE then the new unit is initialised with senisble values. Also, UnitMsg::NEW is only broadcast when this is TRUE If  OK, *ppUnit = ptr to the new unit [OUTPUTS] Returns: TRUE if OK, i.e. successfully created and initialised a new unit Errors: Can only be called once per instance. Errors if called again. Definition at line 802 of file units.cpp. { Unit* pUnit = new Unit; if (pUnit == NULL) return FALSE; if (Initialise) { String_32 num(_R(IDS_UNITS_NEW_UNIT_ABBREV)); String_32 abbrev(_R(IDS_UNITS_NEW_UNIT_ABBREV)); INT32 i; for( i = 0;i<(NextUnitNum / 20) && i<10;i++) num += abbrev; ((LPTSTR) num)[i] += ((NextUnitNum++) % 20); String_32 TokenStr(_R(IDS_UNITS_NEW_UNIT_NAME)); String_32 SpecifierStr(_R(IDS_UNITS_NEW_UNIT_SPECIFIER)); TokenStr += num; SpecifierStr += num; pUnit->SetUnitType((UnitType) NextUnitType++); pUnit->SetDefaultState(FALSE); pUnit->SetPrefixState(FALSE); pUnit->SetBaseUnitType(MILLIMETRES); pUnit->SetBaseNumerator(10); pUnit->SetBaseDenominator(1); pUnit->SetMillipoints(CM_MP_VAL); pUnit->SetToken(TokenStr); pUnit->SetSpecifier(SpecifierStr); } this->AddTail(pUnit); *ppUnit = pUnit; NumUnits++; if (Initialise) { // Tell everybody that the unit has been created BROADCAST_TO_ALL(UnitMsg(this,pUnit->GetUnitType(),UnitMsg::NEW)); } return TRUE; }

void DocUnitList::OutputTrace (  char *  err, const TCHAR *  TokenBuf )  [private]

Helper funtion for the token-reading functions. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/95 Parameters: err  = ptr to a string to appear in the trace output [INPUTS] TokenBuf = ptr to buffer holding last token read -  [OUTPUTS] Returns: - See also: - Definition at line 1788 of file units.cpp. { #if 0 != wxUSE_UNICODE size_t cch = camMbstowcs( NULL, err, 0 ) + 1; wchar_t *pwsz = (wchar_t *)alloca( cch * 2 ); camMbstowcs( pwsz, err, cch ); TRACE( pwsz ); #else TRACE( err ); #endif TRACE( _T(", but got %s\n"), TokenBuf ); }

BOOL DocUnitList::ReadDouble (  CCLexFile &  file, double *  pDouble, char *  err )  [private]

Reads a double value from file and puts it in pDouble. If it fails, err is passed to OutputTrace() and FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/95 Parameters: file  = file to read INT32 value from [INPUTS] pDouble = ptr to place to store the double value err = ptr to a string to appear in the trace output if things go wrong *pDouble  = double value read [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 1854 of file units.cpp. { ERROR2IF(pDouble == NULL,FALSE,"pDouble == NULL"); const TCHAR *TokenBuf = file.GetTokenBuf(); BOOL ok = file.GetSimpleToken(); if (ok) ok = ( camSscanf( TokenBuf, _T("%lg"), pDouble ) == 1 ); if (!ok) OutputTrace( err, TokenBuf ); return ok; }

BOOL DocUnitList::ReadLong (  CCLexFile &  file, void *  pLong, char *  err )  [private]

Reads a INT32 value from file and puts it in pLong. If it fails, err is passed to OutputTrace() and FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/95 Parameters: file  = file to read INT32 value from [INPUTS] pLong = ptr to place to store the INT32 value err = ptr to a string to appear in the trace output if things go wrong *pLong  = INT32 value read [OUTPUTS] Returns: TRUE if successful, FALSE otherwise Note: pLong is a void* so that any INT32 type var can be passed in, like enum types. See also: - Definition at line 1822 of file units.cpp. { ERROR2IF(pLong == NULL,FALSE,"pLong == NULL"); const TCHAR *TokenBuf = file.GetTokenBuf(); BOOL ok = file.GetSimpleToken(); if (ok) ok = ( camSscanf( TokenBuf, _T("%li"), pLong ) == 1 ); if (!ok) OutputTrace( err, TokenBuf ); return ok; }

BOOL DocUnitList::ReadString (  CCLexFile &  file, StringBase *  pStr, char *  err )  [private]

Reads a string from file and puts it in pStr. If it fails, err is passed to OutputTrace() and FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/95 Parameters: file  = file to read INT32 value from [INPUTS] pStr = ptr to place to store the string err = ptr to a string to appear in the trace output if things go wrong *pStr  = string value read [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 1886 of file units.cpp. { ERROR2IF(pStr == NULL,FALSE,"pStr == NULL"); const TCHAR *TokenBuf = file.GetTokenBuf(); BOOL ok = file.GetSimpleToken(); if (ok) { pStr->Empty(); INT32 len = pStr->MaxLength(); if (len > 0) { TCHAR *pBuf = *pStr; INT32 i; for ( i = 0; TBYTE(TokenBuf[i]) > TBYTE(' ') && i < len; i++ ) pBuf[i] = TokenBuf[i]; pBuf[i] = 0; } } if (!ok) OutputTrace(err,TokenBuf); return ok; }

BOOL DocUnitList::ReadUnitsFromDisk (   )  [private]

Reads the unit definitions from disk (i.e. writable media). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 1728 of file units.cpp. { // Not yet implemented return FALSE; }

BOOL DocUnitList::ReadUnitsFromFile (  CCLexFile &  file  )  [private]

Reads the unit definitions from the given file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/95 Parameters: file  = file that contains the unit definitions [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 1926 of file units.cpp. { BOOL finished = FALSE; BOOL ok;; // Initialise lexing routines, and aspects of the lexer ok = file.InitLexer(); file.SetDelimiters("\r\n"); // Set token delimiting characters file.SetCommentMarker(';'); // Set comment marker char file.SetWhitespace(" \t"); // Set whitespace chars file.SetStringDelimiters("\"\""); // Set string delimiters UnTokenIndex Token; const TCHAR *TokenBuf = file.GetTokenBuf(); // Token buffer remains constant until lexer deinitialisation while (ok && !finished) { // Grab a token ok = file.GetSimpleToken(); // Look the token up in our table Token = FindToken( TokenBuf ); switch (Token) { case TOKEN_UNIT: { Unit* pUnit; // Defining a unit. Firstly make a new blank unit to put the definition in if (MakeNewUnit(&pUnit,FALSE)) { // We have a blank unit, now read its definition fields double NumMillipoints; String_32 NameStr; String_32 SpecifierStr; UnitType TheUnitType,BaseUnitType; BOOL Prefix; double BaseNumerator,BaseDenominator; // Read in all the fields of the unit definition if (ok) ok = ReadLong( file,&TheUnitType, "Expected the unit's type"); if (ok) ok = ReadString(file,&NameStr, "Expected the unit's name"); if (ok) ok = ReadString(file,&SpecifierStr, "Expected the unit's specifier"); if (ok) ok = ReadDouble(file,&NumMillipoints, "Expected the unit's millipoint value"); if (ok) ok = ReadLong( file,&Prefix, "Expected the unit's prefix flag"); if (ok) ok = ReadLong( file,&BaseUnitType, "Expected the unit's base type"); if (ok) ok = ReadDouble(file,&BaseNumerator, "Expected the unit's base numerator"); if (ok) ok = ReadDouble(file,&BaseDenominator, "Expected the unit's base denominator"); if (ok) { // If it's based on another unit, get a pointer to the base unit Unit* pBaseUnit = NULL; if (BaseUnitType != UNIT_NOTYPE) pBaseUnit = FindUnit(BaseUnitType); // If no base unit AND no millipoint value, error if (pBaseUnit == NULL && NumMillipoints <= 0.0) { TRACE( _T("Base unit not found AND the number of millipoints <= 0.0\n")); TRACE( _T("Either the base unit is not yet defined, or the millipoint value is wrong\n")); ok= FALSE; } else { if (pBaseUnit != NULL) { // If Millipoint value is based on another, calculate it // (error if denominator is 0 - we don't want to divide by this value) if (BaseDenominator != 0.0) NumMillipoints = (pBaseUnit->GetMillipoints()*BaseNumerator)/BaseDenominator; else { TRACE( _T("Base denominator is 0\n")); ok = FALSE; } } // If we still have a silly millipoint value, error if (NumMillipoints <= 0.0) { TRACE( _T("The millipoint value is <= 0.0\n")); ok = FALSE; } if (ok) { // Apply the read values pUnit->SetUnitType(TheUnitType); pUnit->SetDefaultState(TRUE); pUnit->SetPrefixState(Prefix); pUnit->SetBaseUnitType(BaseUnitType); pUnit->SetBaseNumerator(BaseNumerator); pUnit->SetBaseDenominator(BaseDenominator); pUnit->SetMillipoints(NumMillipoints); if (ok) { ok = pUnit->SetToken(NameStr); if (!ok) TRACE( _T("There's a problem with the name string : %s\n"),(TCHAR*)NameStr); } if (ok) { ok = pUnit->SetSpecifier(SpecifierStr); if (!ok) TRACE( _T("There's a problem with the specifier string : %s\n"),(TCHAR*)NameStr); } } } } } } break; case TOKEN_PAGEUNITS: { UnitType TheUnitType; if (ok) ok = ReadLong(file,&TheUnitType,"Expected the Page unit's type"); if (ok) { ok = (FindUnit(TheUnitType) != NULL); if (!ok) TRACE( _T("The PageUnit specified cannot be found\n")); } if (ok) SetPageUnits(TheUnitType); } break; case TOKEN_FONTUNITS: { UnitType TheUnitType; if (ok) ok = ReadLong(file,&TheUnitType,"Expected the Font unit's type"); if (ok) { ok = (FindUnit(TheUnitType) != NULL); if (!ok) TRACE( _T("The FontUnit specified cannot be found\n")); } if (ok) SetFontUnits(TheUnitType); } break; case TOKEN_UNITSEND: finished = TRUE; break; default: TRACE( _T("DocUnitList: Unexpected token - %s\n"),TokenBuf); break; } } if (!ok) { TRACE( _T("\nDocUnitList: Offending line - %s\n"),file.GetLineBuf()); ERROR3("Error reading units. See TRACE output for details"); } // We are now finished with the lexer file.DeinitLexer(); return (ok); }

BOOL DocUnitList::ReadUnitsFromRes (   )  [private]

Reads the unit definitions from the bound in resource. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 1749 of file units.cpp. { PORTNOTETRACE("other","Removed DocUnitList::ReadUnitsFromRes()"); #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // Remove all previously defined units. We're starting from scratch DeleteAll(); CCResTextFile file; // Resource File BOOL ok = file.open(_R(IDM_DEFAULT_UNITS),_R(IDT_CAM_UNITS)); // Open resource if (ok) { ok = ReadUnitsFromFile(file); file.close(); } return (ok); #else return FALSE; #endif }

BOOL DocUnitList::RecalcUnit (  Unit *  pThisUnit, UnitType  ChangedUnitType )

This recalcs the unit's definition (i.e. the num millipoints that make it up) if it is a descendent of ChangedUnitType. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: pThisUnit  = Unit to ask to recalculate [INPUTS] ChangedUnitType = the unit type that has changed it's definition i.e. the unit's Millipoint value has changed -  [OUTPUTS] Returns: TRUE - This unit has changed also as a result of unit ChangedUnitType changing FALSE - Hasn't changed Definition at line 1259 of file units.cpp. { if (pThisUnit->GetBaseUnitType() == NOTYPE) return FALSE; if (pThisUnit->GetBaseUnitType() == ChangedUnitType) { RecalcUnit(pThisUnit); return TRUE; } Unit* pBaseUnit = FindUnit(pThisUnit->GetBaseUnitType()); if (RecalcUnit(pBaseUnit,ChangedUnitType)) { RecalcUnit(pThisUnit); return TRUE; } return FALSE; }

void DocUnitList::RecalcUnit (  Unit *  pThisUnit  )

Recalculates the number of millipoints in this unit by multiplying the ratio between this and the base unit, with the num millipoints in the base unit. E.g. Recalc Metres : Num Millipoints in metre = Num MP in centimetre * 100; IMPORTANT: This can only recalculate units that are based on another unit. If the unit is not based on another unit (i.e. its base type is NOTYPE) then nothing happens. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: pThisUnit  = unit to recalculate [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1210 of file units.cpp. { if (pThisUnit->GetBaseUnitType() == NOTYPE) return; Unit* pBaseUnit = FindUnit(pThisUnit->GetBaseUnitType()); double ratio = pThisUnit->GetBaseNumerator() / pThisUnit->GetBaseDenominator(); pThisUnit->SetMillipoints(pBaseUnit->GetMillipoints() * ratio); }

BOOL DocUnitList::SetBaseUnitType (  Unit *  pThisUnit, UnitType  NewBaseUnitType )

Lets you set that base unit type, dude! Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7//94 Parameters: NewBaseUnitType  = the unit this unit is based on [INPUTS] -  [OUTPUTS] Returns: TRUE if all went OK FALSE if NewBaseUnitType is this unit or a descendent of this unit Definition at line 1401 of file units.cpp. { if (pThisUnit->GetUnitType() == NewBaseUnitType) return FALSE; if (NewBaseUnitType != NOTYPE) { Unit* pNewBaseUnit = FindUnit(NewBaseUnitType); if (IsDescendent(pNewBaseUnit,pThisUnit->GetUnitType())) return FALSE; } pThisUnit->SetBaseUnitType(NewBaseUnitType); return TRUE; }

void DocUnitList::SetFontUnits (  UnitType  NewUnits  )

Sets the font units of the object directly. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: NewUnits  = the new units to use [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1536 of file units.cpp. { FontUnits = NewUnits; }

void DocUnitList::SetPageUnits (  UnitType  NewUnits  )

Sets the page units of the object directly. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: NewUnits  = the new units to use [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1498 of file units.cpp. { PageUnits = NewUnits; }

void DocUnitList::SetScaleUnits (  UnitType  NewUnits  )

Sets the scale units of the object directly. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: NewUnits  = the new units to use [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1460 of file units.cpp. { ScaleUnits = NewUnits; }

void DocUnitList::UnitHasChanged (  UnitType  ChangedUnitType  )

This informs the class that the definition of a unit has changed. It ensures that all units that are descendents of the changed unit are recalculated. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/94 Parameters: ChangedUnitType  = the unit type that has changed it's definition [INPUTS] i.e. the unit's Millipoint value has changed -  [OUTPUTS] Returns: - Definition at line 1297 of file units.cpp. { Unit* pUnit = (Unit*) this->GetHead(); while (pUnit != NULL) { RecalcUnit(pUnit,ChangedUnitType); pUnit = (Unit*) this->GetNext(pUnit); } // Tell everybody that the unit has changed BROADCAST_TO_ALL(UnitMsg(this,ChangedUnitType,UnitMsg::CHANGED)); }

---

Member Data Documentation

BOOL DocUnitList::DefaultsMade [private]

Definition at line 321 of file units.h.

UnitType DocUnitList::FontUnits [private]

Definition at line 325 of file units.h.

UnitType DocUnitList::LastEditedUnit [private]

Definition at line 326 of file units.h.

INT32 DocUnitList::NextUnitNum [private]

Definition at line 318 of file units.h.

INT32 DocUnitList::NextUnitType [private]

Definition at line 319 of file units.h.

INT32 DocUnitList::NumUnits [private]

Definition at line 317 of file units.h.

UnitType DocUnitList::PageUnits [private]

Definition at line 324 of file units.h.

UnitType DocUnitList::ScaleUnits [private]

Definition at line 323 of file units.h.

---

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

• Kernel/units.h (r1785/r1261)
• Kernel/units.cpp (r1785/r1282)

---