// $Id: pagesize.cpp 1668 2006-08-04 11:45:17Z alex $ /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE ================================XARAHEADERSTART=========================== Xara LX, a vector drawing and manipulation program. Copyright (C) 1993-2006 Xara Group Ltd. Copyright on certain contributions may be held in joint with their respective authors. See AUTHORS file for details. LICENSE TO USE AND MODIFY SOFTWARE ---------------------------------- This file is part of Xara LX. Xara LX is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. Xara LX and its component source files are distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Xara LX (see the file GPL in the root directory of the distribution); if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ADDITIONAL RIGHTS ----------------- Conditional upon your continuing compliance with the GNU General Public License described above, Xara Group Ltd grants to you certain additional rights. The additional rights are to use, modify, and distribute the software together with the wxWidgets library, the wxXtra library, and the "CDraw" library and any other such library that any version of Xara LX relased by Xara Group Ltd requires in order to compile and execute, including the static linking of that library to XaraLX. In the case of the "CDraw" library, you may satisfy obligation under the GNU General Public License to provide source code by providing a binary copy of the library concerned and a copy of the license accompanying it. Nothing in this section restricts any of the rights you have under the GNU General Public License. SCOPE OF LICENSE ---------------- This license applies to this program (XaraLX) and its constituent source files only, and does not necessarily apply to other Xara products which may in part share the same code base, and are subject to their own licensing terms. This license does not apply to files in the wxXtra directory, which are built into a separate library, and are subject to the wxWindows license contained within that directory in the file "WXXTRA-LICENSE". This license does not apply to the binary libraries (if any) within the "libs" directory, which are subject to a separate license contained within that directory in the file "LIBS-LICENSE". ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS ---------------------------------------------- Subject to the terms of the GNU Public License (see above), you are free to do whatever you like with your modifications. However, you may (at your option) wish contribute them to Xara's source tree. You can find details of how to do this at: http://www.xaraxtreme.org/developers/ Prior to contributing your modifications, you will need to complete our contributor agreement. This can be found at: http://www.xaraxtreme.org/developers/contribute/ Please note that Xara will not accept modifications which modify any of the text between the start and end of this header (marked XARAHEADERSTART and XARAHEADEREND). MARKS ----- Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara designs are registered or unregistered trademarks, design-marks, and/or service marks of Xara Group Ltd. All rights in these marks are reserved. Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK. http://www.xara.com/ =================================XARAHEADEREND============================ */ // // Encapsulates the page sizes available in Camelot. /* */ #include "camtypes.h" #include "pagesize.h" //#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "units.h" // units - in camtypes.h [AUTOMATICALLY REMOVED] //#include "convert.h" // conversion utilities - in camtypes.h [AUTOMATICALLY REMOVED] //#include "will2.h" //#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "oilfiles.h" //#include "nev.h" #include // INT32_MAX //#include "pagesres.h" // page related error messages and resources // This is not compulsory, but you may as well put it in so that the correct version // of your file can be registered in the .exe DECLARE_SOURCE("$Revision: 1668 $"); // An implement to match the Declare in the .h file. // If you have many classes, it is recommended to place them all together, here at the start of the file CC_IMPLEMENT_DYNAMIC(PageSize, ListItem) CC_IMPLEMENT_DYNAMIC(PageSizesList, List) // This will get Camelot to display the filename and linenumber of any memory allocations // that are not released at program exit #define new CAM_DEBUG_NEW //List PageSize::PageSizeList; // The global list of installed page sizes. enum PsTokenIndex { PsTOKEN_NONE = -1, TOKEN_PAGESIZE, TOKEN_PAGESIZEEND, TOKEN_MILLIMETRES, TOKEN_INCHES, // Add new token indexs BEFORE NUM_TOKENS PsNUM_TOKENS }; static struct { TCHAR* Token; } TokenTable[] = { {_T("PageSize")}, {_T("PageSizeEnd")}, {_T("MILLIMETRES")}, {_T("INCHES")} }; static PsTokenIndex FindToken(const TCHAR* Token) { for (INT32 i = 0; i < PsNUM_TOKENS; i++) if (camStrcmp(TokenTable[i].Token,Token) == 0) return (PsTokenIndex) i; return PsTOKEN_NONE; } /******************************************************************************************** > PageSize::PageSize() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Purpose: Constructor. Errors: SeeAlso: AppPrefsDlg; ********************************************************************************************/ PageSize::PageSize() { // Do nothing } /******************************************************************************************** > BOOL PageSize::Init(PageId NewId, String_32 *Name, double Width, double Height, UnitType Units) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: NewId unique page id for this page size Name textual name for this page (for menus etc.) Width width in the specified units e.g. millimetres Height height in the specified units Units the specified units Purpose: Initialiser. Errors: SeeAlso: PageSize; AppPrefsDlg; ********************************************************************************************/ BOOL PageSize::Init(PageId NewId, String_32 *Name, double Width, double Height, UnitType Units) { // Guard against floating point exceptions by checking the input values // 0.1" or 0.1mm should be a good enough minimim ERROR2IF(Width < 0.1 || Width > (double)INT32_MAX, FALSE, "PageSize::Init bad width"); ERROR2IF(Height < 0.1 || Height > (double)INT32_MAX, FALSE, "PageSize::Init bad width"); Id = NewId; // Copy the page id across PageName = *Name; // Copy the page name across PageWidthInMM = Width; // Copy the width across PageHeightInMM = Height; // Copy the height across // Now work out the equivalent millipoint values // Cannot use the ConvertToNewUnits functions as these require a current doc // and we have not got one yet! Do it the hard way but use the conversion values // specified in units.h switch (Units) { case MILLIMETRES: PageWidth = (INT32)(Width * MM_MP_VAL); PageHeight = (INT32)(Height * MM_MP_VAL); break; case INCHES: PageWidth = (INT32)(Width * IN_MP_VAL); PageHeight = (INT32)(Height * IN_MP_VAL); break; default: ERROR2(FALSE,"Bad units used in PageSize::Init"); break; } //PageWidth = ConvertToNewUnits(Width, MILLIMETRES, MILLIPOINTS); //PageHeight = ConvertToNewUnits(Height, MILLIMETRES, MILLIPOINTS); return TRUE; } /******************************************************************************************** > PageId PageSize::GetPageId() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: The id for this page Purpose: Returns page id SeeAlso: PageSize; AppPrefsDlg; ********************************************************************************************/ PageId PageSize::GetPageId() { return Id; } /******************************************************************************************** > String_32 *PageSize::GetPageName() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: pointer to the name of this page Purpose: Way of finding the name for this page. SeeAlso: PageSize; AppPrefsDlg; ********************************************************************************************/ String_32 *PageSize::GetPageName() { return &PageName; } /******************************************************************************************** > PageSize::GetPageWidth() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: Width of this page in millipoints. Purpose: Way of of finding out the current page width. SeeAlso: PageSize; AppPrefsDlg; ********************************************************************************************/ INT32 PageSize::GetPageWidth() { return PageWidth; } /******************************************************************************************** > INT32 PageSize::GetPageHeight() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: Height of this page in millipoints. Purpose: Way of of finding out the current page height. SeeAlso: PageSize; AppPrefsDlg; ********************************************************************************************/ INT32 PageSize::GetPageHeight() { return PageHeight; } /****************************************************************************************** ********************************************************************************************/ /******************************************************************************************** > PageSizesList::PageSizesList() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Purpose: Constructor. Errors: SeeAlso: AppPrefsDlg; ********************************************************************************************/ PageSizesList::PageSizesList() { // Set up useful defaults // This is the next page id which will be used when the next page is added MaxPageId = (INT32)LASTPAGE; } /******************************************************************************************** > PageSizesList::~PageSizesList() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Purpose: Destructor. Errors: SeeAlso: AppPrefsDlg; ********************************************************************************************/ PageSizesList::~PageSizesList() { // Remove all page sizes from the list ListItem* pItem; while ((pItem = this->RemoveHead()) != NULL) delete pItem; } /******************************************************************************************** > BOOL PageSizesList::InitPageSizes() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: TRUE if initialised ok, FALSE if not. Purpose: Scans all PageSize to find out which PageSize are available for use, and instantiates one of each, and holds them in a list. Errors: Out of memory (if a PageSize fails to initialise for other reasons then an error is reported, but Camelot will still start up ok, i.e. TRUE is returned). SeeAlso: PageSize ********************************************************************************************/ BOOL PageSizesList::InitPageSizes() { // Reset our store for error message identifiers to the 'no error' state. ErrorId = 0; // First, try and read hot keys from resource file BOOL Ok = ReadPageSizes(); // Failed to read in the pages from the resource, tell the user this and what we think // the problem is, then use the bound in pages. if (!Ok) { // For now if we fail, error 3 to tell the user and then use the bound in version. if (ErrorId == 0) ErrorId = _R(IDW_PAGES_UNKNOWNERROR); String_256 ErrorReason; ErrorReason.MakeMsg(ErrorId); // Combine the above error with the main error message String_256 ErrorMsg; ErrorMsg.MakeMsg(_R(IDW_PAGES_FAILEDREADING), (TCHAR*) ErrorReason); Error::SetError(_R(IDW_PAGES_FAILEDREADING), (TCHAR *) ErrorMsg, 0); InformError(); \ TRACEUSER( "Neville", _T("PageSizesList::InitPageSizes failed to read in list from resource, using bound in one")); // Vape any that may have been created this->DeleteAll(); // Create, initialise and install the built in PageSize list PageSize *pPageSize; // First size is implied to be custom i.e. if unknown size. DeclarePageSize(A0, _R(IDS_K_PAGESIZE_A0), 840.0, 1188.0, MILLIMETRES, &pPageSize); DeclarePageSize(A1, _R(IDS_K_PAGESIZE_A1), 594.0, 840.0, MILLIMETRES, &pPageSize); DeclarePageSize(A2, _R(IDS_K_PAGESIZE_A2), 420.0, 594.0, MILLIMETRES, &pPageSize); DeclarePageSize(A3, _R(IDS_K_PAGESIZE_A3), 297.0, 420.0, MILLIMETRES, &pPageSize); DeclarePageSize(A4, _R(IDS_K_PAGESIZE_A4), 210.0, 297.0, MILLIMETRES, &pPageSize); DeclarePageSize(A5, _R(IDS_K_PAGESIZE_A5), 148.5, 210.0, MILLIMETRES, &pPageSize); DeclarePageSize(A6, _R(IDS_K_PAGESIZE_A6), 105.0, 148.5, MILLIMETRES, &pPageSize); DeclarePageSize(USLEGAL, _R(IDS_K_PAGESIZE_USLEGAL), 8.5, 14, INCHES, &pPageSize); DeclarePageSize(USLETTER,_R(IDS_K_PAGESIZE_USLETTER), 8.5, 11, INCHES, &pPageSize); DeclarePageSize(FANFOLD, _R(IDS_K_PAGESIZE_FANFOLD), 8.25, 12, INCHES, &pPageSize); } // All ok return TRUE; } /******************************************************************************************** > void PageSizesList::DeinitPageSizes() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Purpose: Destroy all the PageSize objects. SeeAlso: PageSize ********************************************************************************************/ BOOL PageSizesList::DeinitPageSizes() { // Get rid of our PageSize list this->DeleteAll(); // All ok return TRUE; } /******************************************************************************************** > BOOL PageSizesList::DeclarePageSize(PageId NewId, String_32 *Name, double Width, double Height, UnitType Units, PageSize **ppPageSize) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: NewId unique pageid. Name textual desciption of page size Width width of page in mm. Height height of page in mm. ppPageSize pointer to a page size pointer to be updated Returns: True if page size declared, False if something went wrong. Purpose: A function to declare a new page size to the system. SeeAlso: PageSize ********************************************************************************************/ BOOL PageSizesList::DeclarePageSize(PageId NewId, String_32 *Name, double Width, double Height, UnitType Units, PageSize **ppPageSize) { // First check to see if somebody has actually declared the pointer to be non null. PageSize *pPageSize = new PageSize; if (pPageSize == NULL) return FALSE; if (!pPageSize->Init(NewId, Name, Width, Height, Units)) { /* Error occured - report it and stop trying to initialise the options tab. */ delete pPageSize; // remove the declared page size pPageSize = NULL; // remove the item from the system InformError(); // tell the user about the problem return TRUE; } // Add this new item at the end of the list this->AddTail(pPageSize); *ppPageSize = pPageSize; // update the new end pointer // All ok return TRUE; } /******************************************************************************************** > PageSize *PageSizesList::GetFirstPageSize() Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Returns: Pointer to the first page size NULL if none. Purpose: Iterating through the list of PageSize known to Camelot. This function returns the first PageSize. SeeAlso: PageSizesList::GetNext() Scope: Static ********************************************************************************************/ PageSize *PageSizesList::GetFirstPageSize() { return (PageSize *) this->GetHead(); } /******************************************************************************************** > PageSize *PageSizesList::GetNextPageSize(PageSize *pPageSize) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: pPageSize - pointer to the PageSize to be used to get the following PageSize. Returns: Pointer to the next PageSize, or NULL if none. Purpose: Iterating through the list of PageSize known to Camelot. This function returns the next PageSize. SeeAlso: PageSizesList::GetFirst ********************************************************************************************/ PageSize *PageSizesList::GetNextPageSize(PageSize *pPageSize) { return (PageSize *) this->GetNext(pPageSize); } /******************************************************************************************** > String_32* PageSizesList::GetTextualDescription(PageId ThisId) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: PageId - id of the page that we are searching for Returns: Textual name for the specified page. Purpose: Return the name for the page size specified. SeeAlso: PageSize::GetFirst ********************************************************************************************/ String_32* PageSizesList::GetTextualDescription(PageId ThisId) { PageSize* pPageSize = (PageSize*) this->GetHead(); while (pPageSize != NULL) { if (pPageSize->GetPageId() == ThisId) return pPageSize->GetPageName(); pPageSize = (PageSize*) this->GetNext(pPageSize); } ERROR3("PageSizesList::GetTextualDescription Specified page id not found"); return NULL; } /******************************************************************************************** > PageId PageSizesList::GetPageIdFromSize(INT32 Width INT32 Height) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: Height height of page in millipoints. Width width of page in millipoints. Returns: PageId the Id for the specified page. Purpose: Returns the name for the page size specified or CUSTOM if not found. SeeAlso: PageSize::GetSizeFromPageId() ********************************************************************************************/ PageId PageSizesList::GetPageIdFromSize(INT32 Width, INT32 Height) { PageSize* pPageSize = (PageSize*) this->GetHead(); while (pPageSize != NULL) { // Must give a little leeway either side as otherwise rounding errors may // raise their ugly heads and mean that 841891 != 841892 and hence miss the page size INT32 bodge = (INT32)(0.5 * MM_MP_VAL); // extra leeway on comparison required INT32 FoundWidth = pPageSize->GetPageWidth(); INT32 FoundHeight = pPageSize->GetPageHeight(); if ( (FoundWidth >= (Width - bodge)) && (FoundWidth <= (Width + bodge)) && (FoundHeight >= (Height - bodge)) && (FoundHeight <= (Height + bodge)) ) return pPageSize->GetPageId(); pPageSize = (PageSize*) this->GetNext(pPageSize); } return CUSTOM; } /******************************************************************************************** > BOOL PageSizesList::GetSizeFromPageId(PageId ThisId, INT32 *Width, INT32 *Height) Author: Neville_Humphrys (Xara Group Ltd) Created: 12/12/94 Inputs: PageId - id of the page that we are searching for Returns: Width the width for the specified page in millipoints. Height the height for the specified page in millipoints. Purpose: Returns the width and height the page size specified. SeeAlso: PageSize::GetPageIdFromSize() ********************************************************************************************/ BOOL PageSizesList::GetSizeFromPageId(PageId ThisId, INT32 *Width, INT32 *Height) { // Set up default values in case of early exit *Width = 0; *Height = 0; PageSize* pPageSize = (PageSize*) this->GetHead(); while (pPageSize != NULL) { if (pPageSize->GetPageId() == ThisId) { *Width = pPageSize->GetPageWidth(); // return found page width *Height = pPageSize->GetPageHeight(); // return found page height return TRUE; } pPageSize = (PageSize*) this->GetNext(pPageSize); } // Did not find the specified page return FALSE; } /******************************************************************************************** *** Reading page sizes from the resource or from an ini file ***** ********************************************************************************************/ /******************************************************************************************** > BOOL PageSizesList::ReadPageSizes() Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: - Outputs: - Returns: TRUE if OK, FALSE otherwise Purpose: Reads the page size definitions from somewhere (either file or bound-in resource file). SeeAlso: HotKey::ReadHotKeys; ********************************************************************************************/ BOOL PageSizesList::ReadPageSizes() { BOOL ok = PageSizesList::ReadPageSizesFromDisk(); if (!ok) ok = PageSizesList::ReadPageSizesFromRes(); return (ok); } /******************************************************************************************** > BOOL PageSizesList::ReadPageSizesFromDisk() Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: - Outputs: - Returns: TRUE if OK, FALSE otherwise Purpose: Reads the page size definitions from disk (i.e. writable media) SeeAlso: HotKey::ReadHotKeysFromDisk; ********************************************************************************************/ BOOL PageSizesList::ReadPageSizesFromDisk() { // Not yet implemented return FALSE; } /******************************************************************************************** > BOOL PageSizesList::ReadPageSizesFromRes() Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: - Outputs: - Returns: TRUE if OK, FALSE otherwise Purpose: Reads the hot key definitions from the bound in resource. SeeAlso: HotKey::ReadHotKeysFromRes; ********************************************************************************************/ BOOL PageSizesList::ReadPageSizesFromRes() { // Resource File CCResTextFile file; // Open resource BOOL ok = file.open(_R(IDH_DEFAULT_PAGESIZES), _R(IDT_CAM_PAGESIZES_RES)); if (ok) { ok = PageSizesList::ReadPageSizesFromFile(file); file.close(); } return (ok); } /******************************************************************************************** > BOOL PageSizesList::ReadPageSizesFromFile(CCLexFile& file) Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: file = file that contains the page size definitions Outputs: - Returns: TRUE if OK, FALSE otherwise Purpose: Reads the page size definitions from the given file SeeAlso: HotKey::ReadHotKeysFromFile; ********************************************************************************************/ BOOL PageSizesList::ReadPageSizesFromFile(CCLexFile& file) { 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 PsTokenIndex Token; const TCHAR* TokenBuf = file.GetTokenBuf(); // Token buffer remains constant until lexer deinitialisation while (ok && !finished) { // Grab a token ok = file.GetSimpleToken(); if (ok) { // Look the token up in our table Token = FindToken(TokenBuf); switch (Token) { case TOKEN_PAGESIZE: // Correst line start found so read in the page size info from that line ok = PageSizesList::ReadPageSizesList(file); break; case TOKEN_PAGESIZEEND: // End of table marker found so our job is over finished = TRUE; break; default: TRACEUSER("Neville", _T("PageSizesList: Unexpected token - %s\n"),TokenBuf); ErrorId = _R(IDW_PAGES_UNEXPECTEDMAINTOKEN); ok = FALSE; break; } } else ErrorId = _R(IDW_PAGES_FAILEDTOGETTOKEN); } if (!ok) { TRACEUSER( "Neville", _T("\nPageSizesList: Offending line - %s\n"),file.GetLineBuf()); //ERROR3("Error reading page sizes. See TRACE output for details"); } // We are now finished with the lexer file.DeinitLexer(); return (ok); } /******************************************************************************************** > BOOL PageSizesList::ReadPageSizesList(CCLexFile& file) Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: file = file that contains the page size definitions Outputs: - Returns: TRUE if OK, FALSE otherwise Purpose: Read one page size definition from the given file SeeAlso: - ********************************************************************************************/ BOOL PageSizesList::ReadPageSizesList(CCLexFile& file) { PageSize* pPageSize = NULL; String_32 PageName; double Width = 0.0; double Height = 0.0; UnitType Units = NOTYPE; BOOL ok = PageSizesList::ReadPageSizeDef(file, &PageName, &Width, &Height, &Units); if (ok) { // First size is implied to be custom i.e. if unknown size. DeclarePageSize((PageId)MaxPageId, &PageName, Width, Height, Units, &pPageSize); // Now increment are next new page id MaxPageId++; if (!ok) { ErrorId = _R(IDW_PAGES_FAILEDTOADDPAGE); TRACEUSER( "Neville", _T("PageSizesList: Unable to add page size to the system\n")); } } return (ok); } /******************************************************************************************** > BOOL HotKey::ReadPageSizeDef( CCLexFile& file, String_32* pPageName, double* pWidth, double* pHeight, UnitType* pUnits) Author: Neville_Humphrys (Xara Group Ltd) Created: 22/11/95 Inputs: file = file that contains the key definitions ppKeyPress = Place to put the ptr to a key press object pOpToken = ptr to string to place the op token string ppTextDesc = ptr to a ptr to a String_32 object that describes the key def (e.g. "Ctrl+X") pCheckUnicode = Flag to determine how the hot key is compared with key press objects Outputs: *ppKeyPress = a ptr to a key press object OR NULL *pOpToken = op token of op associated with the key press object OR empty string *ppTextDesc = ptr to a String_32 describing the key combination. If this is NULL, then the key combo has no text description *pCheckUnicode = TRUE if Unicode checking should be done, FALSE otherwise Returns: TRUE if OK FALSE otherwise (syntax error, not enough memory, etc) Purpose: Generates a key press object and op token from the given file SeeAlso: HotKey::ReadKeyDef ********************************************************************************************/ BOOL PageSizesList::ReadPageSizeDef(CCLexFile& file, String_32* pPageName, double* pWidth, double* pHeight, UnitType* pUnits) { // Check the parameters ERROR2IF(pPageName == NULL, FALSE,"PageSizesList::ReadPageSizeDef pPageName is NULL"); ERROR2IF(pWidth == NULL, FALSE,"PageSizesList::ReadPageSizeDef pWidth is NULL"); ERROR2IF(pHeight == NULL, FALSE,"PageSizesList::ReadPageSizeDef pHeight is NULL"); ERROR2IF(pUnits == NULL, FALSE,"PageSizesList::ReadPageSizeDef pUnits is NULL"); // Fill in some useful default values *pPageName = _T(""); *pWidth = 0.0; *pHeight = 0.0; *pUnits = MILLIMETRES; // default to reading in measurements in millimetres PsTokenIndex Token; const TCHAR* TokenBuf = file.GetTokenBuf(); // This set of parameters will combine to form a key press object that represents // the hot key combination // String_32* pTextDesc = NULL; // This is FALSE until we have read the text that describes the page size BOOL TextDescRead = FALSE; // This is FALSE until we have read the first number in, which should be the width BOOL ReadWidth = FALSE; // We haven't finsihed, but we're OK at the mo BOOL finished = FALSE; BOOL ok = TRUE; while (ok && !finished) { // Get the next token ok = file.GetSimpleToken(); if (ok) { // Find out the type of the token LexTokenType TokenType = file.GetTokenType(); switch (TokenType) { case TOKEN_STRING: { // Read that text into the name of the page as this is the only // string that is expected // Make sure the desccription is not too long and there is one INT32 length = camStrlen(TokenBuf); ok = ((length <= pPageName->MaxLength()) && (length > 0) ); if (ok) { // Only take as much as we can take //TokenBuf.Left(pPageName, pPageName->MaxLength()); *pPageName = TokenBuf; // We have read the text desc string TextDescRead = TRUE; } else { TRACEUSER( "Neville", _T("PageSizesList::ReadPageSizeDef blank or too long a page size name!")); ErrorId = _R(IDW_PAGES_BADPAGENAME); } } break; case TOKEN_NORMAL: { Token = FindToken(TokenBuf); switch (Token) { // if we find either of the units then this is the last item // so this page size is all read in case TOKEN_MILLIMETRES: *pUnits = MILLIMETRES; finished = TRUE; break; case TOKEN_INCHES: *pUnits = INCHES; finished = TRUE; break; case PsTOKEN_NONE: { double Number; // Could use this but the routine requires a valid doc! //String_256 Value; //Value = TokenBuf; //ok = Convert::StringToDouble( &Value, &Number); // Could use this but is not unicode compliant! //Number = atof((char *)TokenBuf); ok = (camSscanf(TokenBuf,_T("%lg"),&Number) == 1); if (ok) { if (!ReadWidth) { ReadWidth = TRUE; *pWidth = Number; } else { //ok = (camSscanf(TokenBuf,"%lg",pHeight) == 1); *pHeight = Number; } } else { ErrorId = _R(IDW_PAGES_BADPAGESIZE); TRACEUSER( "Neville", _T("PageSize: Expected a size (width/height) but got : '%s'\n"),TokenBuf); } } break; default: // Flag a bad token so that we stop parsing this line ok = FALSE; TRACEUSER( "Neville", _T("PageSize: Didn't expect to get this token ('%s') in the middle of a hot key def\n"),TokenBuf); ErrorId = _R(IDW_PAGES_BADTOKEN); break; } } break; default: // bad token so stop parsing this line TRACEUSER( "Neville", _T("PageSize: Unexpected token - %s\n"),TokenBuf); ok = FALSE; ErrorId = _R(IDW_PAGES_UNEXPECTEDTOKEN); break; } } } return (ok); }