PrintMarksCache Class Reference

The print marks cache. This class contains a list of cached printmarks kept by the print marks manager. It is split into its own class here to avoid complications will the mark managers handling of cache marks and document component marks. More...

#include <prnmks.h>

List of all members.

Public Member Functions
	PrintMarksCache ()
	Construct the PrintMarksCache object. This used to be part of the print marks manager but I've now split it into its own class to prevent confusion with the handling of cache marks and document marks. Various functions do similar things so it could become confusing without a scope resolution operator PMMCache::FindMark as opposed to Doc::FindMark.
	~PrintMarksCache ()
	Destroys the cached marks completely.
PrintMarkItem *	GetFirstMark () const
	Return a pointer to the first cached mark.
PrintMarkItem *	GetNextMark (PrintMarkItem *pCurrItem) const
	Returns the next print mark item beyond pCurrMark.
PrintMarkItem *	FindMark (UINT32 SearchHandle)
	Try to find a print mark in the cache, using its handle.
Private Member Functions
	CC_DECLARE_MEMDUMP (PrintMarksCache)
BOOL	DecodeCachedLayers (Document *pDocument)
	Given a document, we scan each layer in the document. For each layer we check the loaded layer name. If the layer name contains a % at the begining (meaning its a format string) and the format is PRINTMARK, we take the first group in the layer (+ all its contents) and assign a new print mark item to this group. This group object will (if successfully) loaded, become a new print mark.
BOOL	DecodeCachedLayer (Layer *pLayer)
	Given a layer, if the layer contains a print mark, strip the print mark out and try to add it to the PrintMarksMan cache.
BOOL	DecodeMarkFormat (const String_256 *pFormatString, PrintMark *pMark)
	Decode the string pointed to by pFormatString, placing each format identifier into the output mark.
UINT32	DecodeToMarkType (const String_256 *Name) const
	Have a look at the string passed in and check to see it matches any of the known mark type names. If so return the proper mark type enum, otherwise 'Unkown' is returned.
BOOL	DoesMarkExist (PrintMark *pCheckMark) const
	Try to find a print mark in the cache.
UINT32	AddNewMark (PrintMarkItem *pCheckMark, NodeGroup *pGroup)
	A simple way of adding a prebuilt mark to the list. The mark must be in a renderable format, in that it should be a group with all needed attrs as children, followed by a child group containing all the ink objects.
void	UpdateMarkGlyph (PrintMarkItem *pMarkItem, NodeGroup *pGroup)
	Change the mark glyph to this new mark.
BOOL	CreateTextInfoMark ()
	This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text....
BOOL	CreateCropMark ()
BOOL	UpdateTextInfoMark (Document *pDocument, RenderRegion *pRRegion)
	This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text....
void	DestroyTextInfoMark ()
	Throw away any cached print information mark.
void	BuildTextInfoString (Document *pDocument, RenderRegion *pRegion, String_256 *pString)
BOOL	SetInfoMarkAttributes (TextStory *pStory, String_64 *pFontName, MILLIPOINT FontSize)
	This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text....
BOOL	DeleteChildAttribute (NodeRenderableInk *pParent, CCRuntimeClass *pReqdAttrib)
	Delete a child attribute of a specified type from this parent.
UINT32	GetUniqueHandle ()
	Generate a unique print mark handle. All handles will be >=1 and hence an illegal handle is given the value 0.
void	Invalidate ()
	Invalidate the cache list. If we do this, all the mark references in existing document will reference nothing. As we create new marks new handles will be built, so it might be necessary to delete references made in all doc components. Use with care.
Private Attributes
UINT32	NextHandle
UINT32	TextInfoHandle
UINT32	CropMarkHandle
List	PrintMarkCache
String_256	CachedTime
Friends
class	PrintMarksMan
class	LoadPrintMarks
class	PrintMarksComponent

---

Detailed Description

The print marks cache. This class contains a list of cached printmarks kept by the print marks manager. It is split into its own class here to avoid complications will the mark managers handling of cache marks and document component marks.

Author:

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

Date:

23/07/96

See also:

Definition at line 647 of file prnmks.h.

---

Constructor & Destructor Documentation

PrintMarksCache::PrintMarksCache (   )

Construct the PrintMarksCache object. This used to be part of the print marks manager but I've now split it into its own class to prevent confusion with the handling of cache marks and document marks. Various functions do similar things so it could become confusing without a scope resolution operator PMMCache::FindMark as opposed to Doc::FindMark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Definition at line 714 of file prnmks.cpp. { NextHandle=0; TextInfoHandle=0; CropMarkHandle=0; }

PrintMarksCache::~PrintMarksCache (   )

Destroys the cached marks completely. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Definition at line 732 of file prnmks.cpp. { Invalidate(); }

---

Member Function Documentation

UINT32 PrintMarksCache::AddNewMark (  PrintMarkItem *  pNewMark, NodeGroup *  pGroup )  [private]

A simple way of adding a prebuilt mark to the list. The mark must be in a renderable format, in that it should be a group with all needed attrs as children, followed by a child group containing all the ink objects. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: pNewMark  = a pointer to the new mark to add [INPUTS] pGroup = a pointer to the glyph to use. Returns: The handle of the newly added mark Definition at line 1012 of file prnmks.cpp. { // Add a handle to this mark UINT32 hndle = GetUniqueHandle(); pNewMark->SetHandle(hndle); pNewMark->pMarkGlyph = pGroup; // Hey hey, we've finally done it! cool! PrintMarkCache.AddTail(pNewMark); return hndle; }

void PrintMarksCache::BuildTextInfoString (  Document *  pDocument, RenderRegion *  pRRegion, String_256 *  pString )  [private]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pMark  = a print mark item pointer [INPUTS] pForm = a mark format object pointer Definition at line 1672 of file prnmks.cpp. { // First add the doc title to the string (*pString) = pDocument->GetTitle(); (*pString) += TEXT(" "); // now add the date and time (set up by StartPrinting above) (*pString) += CachedTime; // ok add the plate name of the plate we're rendering ColourPlate *pColPlate = pRRegion->GetRenderView()->GetColourPlate(); if (pColPlate!=NULL) { String_64 PlateName; pColPlate->GetDescription(&PlateName); (*pString) += TEXT(" ("); (*pString) += PlateName; (*pString) += TEXT(")"); } }

PrintMarksCache::CC_DECLARE_MEMDUMP (  PrintMarksCache   )  [private]

BOOL PrintMarksCache::CreateCropMark (   )  [private]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: [INPUTS]  Returns: - Definition at line 1282 of file prnmks.cpp. { if (CropMarkHandle>0) return TRUE; // Create a particular mark structure for this crop mark PrintMarkItem* pMarkItem = new PrintMarkItem; if (pMarkItem==NULL) return FALSE; MarkPosition* pPosition = new MarkPosition; if (pPosition==NULL) { delete pMarkItem; return FALSE; } MarkFormat format; pPosition->SetRegion(MarkRegion_Top1); pPosition->SetFormat(format); String_256 MenuText(_R(IDS_PRINTMARK_CROPMARKS)); PrintMark* pMark = pMarkItem->GetPrintMark(); pMark->SetCustomOrDefault(FALSE); pMark->SetIDByte(PRINTMARK_CROPMARKID); pMark->SetType(MarkType_Crop); pMark->SetMarkMenuText(&MenuText); pMark->SetOrientation(MO_Horizontal); pMark->SetDefaultState(TRUE); pMark->AddNewPosition(pPosition); // we don't want to save this mark pMarkItem->SetSaveable(FALSE); // we render this without formatting in a different way pMarkItem->SetRenderable(FALSE); // finally stick the thing in our cache! CropMarkHandle = AddNewMark(pMarkItem, NULL); return TRUE; }

BOOL PrintMarksCache::CreateTextInfoMark (   )  [private]

This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text.... Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pComp  = the document component containing the print marks [INPUTS] CurrRegion = the current region we're formatting marks in Returns: - Document title Date Time Page number? Plate name Definition at line 1347 of file prnmks.cpp. { // is it already created? if (TextInfoHandle>0) return TRUE; // Create a particular mark structure for this info PrintMarkItem* pMarkItem = new PrintMarkItem; if (pMarkItem==NULL) return FALSE; MarkPosition* pPosition = new MarkPosition; if (pPosition==NULL) { delete pMarkItem; return FALSE; } MarkFormat format; format.Middle = TRUE; format.Left = TRUE; pPosition->SetRegion(MarkRegion_Top2); pPosition->SetFormat(format); String_256 MenuText(_R(IDS_PRINTMARK_PLATEINFO)); PrintMark* pMark = pMarkItem->GetPrintMark(); pMark->SetCustomOrDefault(FALSE); pMark->SetIDByte(PRINTMARK_INFOMARKID); pMark->SetType(MarkType_Information); pMark->SetMarkMenuText(&MenuText); pMark->SetOrientation(MO_Horizontal); pMark->SetDefaultState(TRUE); pMark->AddNewPosition(pPosition); // we don't want to save this mark pMarkItem->SetSaveable(FALSE); // finally stick the thing in our cache! TextInfoHandle = AddNewMark(pMarkItem, NULL); return TRUE; }

BOOL PrintMarksCache::DecodeCachedLayer (  Layer *  pLayer  )  [private]

Given a layer, if the layer contains a print mark, strip the print mark out and try to add it to the PrintMarksMan cache. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: pLayer  = a pointer to a layer [INPUTS] Returns: TRUE if the layer has been processed Definition at line 926 of file prnmks.cpp. { ERROR2IF(pLayer==NULL,FALSE,"NULL Layer passed to DecodeCachedLayer"); // Read in the layer name String_256 Name; String_16 Token; Name = pLayer->GetLayerID(); Name.Left(&Token, 10); BOOL IsValid = FALSE; BOOL IsCustomMark = FALSE; if (Token == String_16(_T("%PRINTMARK"))) // This text must not be internationalised IsValid = TRUE; if (!IsValid && Token == String_16(_T("%CUSTOMMAR"))) // This text must not be internationalised { IsValid = TRUE; IsCustomMark = TRUE; } if (!IsValid) return FALSE; // find the first renderable group in this layer. NodeGroup* pGroup = (NodeGroup*)pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGroup)); if (pGroup==NULL) return FALSE; // Create a new mark structure to put the decoded data into PrintMarkItem* pNewMark = new PrintMarkItem; if (!pNewMark) return FALSE; PrintMark* pMark = pNewMark->GetPrintMark(); pMark->SetCustomOrDefault(IsCustomMark); // Remember if it's a custom or default mark if (!DecodeMarkFormat(&Name, pMark)) { delete pNewMark; return FALSE; } // Right we have a new print mark descriptor, // we simply merge the mark into the // cache. It would be faster, before copying the subtree, to check whether we // dont already have this mark cached in the print mark manager. if (DoesMarkExist(pMark)) { delete pNewMark; return TRUE; } // Add a handle to this mark pNewMark->SetHandle(GetUniqueHandle()); // ok the mark does not exist, so now look for that first group if (!pNewMark->SetMarkGlyph(pGroup, TRUE)) { delete pNewMark; return FALSE; } // Hey hey, we've finally done it! cool! PrintMarkCache.AddTail(pNewMark); return TRUE; }

BOOL PrintMarksCache::DecodeCachedLayers (  Document *  pDocument  )  [private]

Given a document, we scan each layer in the document. For each layer we check the loaded layer name. If the layer name contains a % at the begining (meaning its a format string) and the format is PRINTMARK, we take the first group in the layer (+ all its contents) and assign a new print mark item to this group. This group object will (if successfully) loaded, become a new print mark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: pDocument  = a pointer to a document [INPUTS] Returns: TRUE if the document has been processed Definition at line 893 of file prnmks.cpp. { ERROR2IF(pDocument==NULL,FALSE,"NULL Layer passed to DecodeCachedLayer"); Spread* pSpread = pDocument->FindFirstSpread(); Layer* pLayer; while (pSpread!=NULL) { pLayer = pSpread->FindFirstLayer(); while (pLayer!=NULL) { DecodeCachedLayer(pLayer); pLayer = pLayer->FindNextLayer(); // Find next layer } pSpread = pSpread->FindNextSpread(); } return TRUE; }

BOOL PrintMarksCache::DecodeMarkFormat (  const String_256 *  pFormatString, PrintMark *  pMark )  [private]

Decode the string pointed to by pFormatString, placing each format identifier into the output mark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: pFormatString  [INPUTS] pMark  [OUTPUTS] Returns: TRUE if the format string was valid. Special tag Mark name ID On/off Type Position(s) PRINTMARK = "Registration mark", 3, 1, _R(ID_STAR), 3MCS + 7MC + 11MCS + 15MC CUSTOMMARK = "User registration mark", 0, 1, _R(ID_STAR), 3MCS + 7MC + 11MCS + 15MC Definition at line 1068 of file prnmks.cpp. { ERROR2IF(pFormatString == NULL, FALSE, "NULL pointer passed to DecodeMarkFormat"); ERROR2IF(pMark == NULL, FALSE, "NULL mark pointer passed to DecodeMarkFormat"); String_256 Name(*pFormatString); String_256 MenuText; String_256 MenuID; MarkFormat NewFormat; MarkRegion NewRegion; MarkOrient NewOrient; const TCHAR COMMA = TEXT(','); // This text must not be internationalised // const TCHAR EQUALS = TEXT('='); const TCHAR QUOTES = TEXT('"'); const TCHAR PLUS = TEXT('+'); const TCHAR SPACE = TEXT(' '); INT32 pos, pos1; // Everything is hunky dory at the moment! ER NOT! BOOL AllIsWell = FALSE; // Turn on the exceptions function in the string reading class StringBase::EnableExceptionHandler(); //try { // toast everything up to the first quote pos = Name.FindNextChar(QUOTES); Name.Remove(0,pos+1); // now find the last quote of the first string pos = Name.FindNextChar(QUOTES); Name.Left(&MenuText,pos); Name.Remove(0,pos+1); // skip over the first comma onto the ID field pos = Name.SkipComma(); Name.Remove(0,pos); pos = 0; INT32 ID = Name.ConvertToInteger(pos); Name.Remove(0,pos); if (ID < 0 || ID > 255) ID = 0; pMark->SetIDByte((BYTE)ID); // skip over the next comma onto the enable/disable state pos = Name.SkipComma(); Name.Remove(0,pos); BOOL Enabled = (Name[0] == TEXT('1')); // skip comma to next field pos = Name.SkipComma(); pos1 = Name.FindNextChar(COMMA, pos+1); Name.Mid(&MenuID, pos, (pos1-pos)); Name.Remove(0,pos1+1); // turn the menu id into a type of mark if we recognise it MarkType actid = (MarkType)DecodeToMarkType(&MenuID); // skip the orientation field pos=Name.FindNextChar(); NewOrient=MO_None; if (Name[pos] == TEXT('H')) NewOrient=MO_Horizontal; else if (Name[pos] == TEXT('V')) NewOrient=MO_Vertical; // remove the orientation bit pos = Name.SkipComma(); // Add what we have so far pMark->SetMarkMenuText(&MenuText); pMark->SetOrientation(NewOrient); pMark->SetType(actid); pMark->SetDefaultState(Enabled); // The remainder of this string is a format list // BOOL format=FALSE; // BOOL eos=FALSE; // Turn our exception handler off but don't pop it. StringBase::DisableExceptionHandler(FALSE); INT32 region; while (pos>0) { // Try to create a new mark to add MarkPosition* pNewMark = new MarkPosition; if (pNewMark!=NULL) { region = Name.ConvertToInteger(pos); if (region<1 || region>MAXPAGEREGIONS) { // Ok, the region number is out of range so lets // skip to the next one (if there is one!) // we need to find the next + delete pNewMark; pos = Name.FindNextChar(PLUS, pos); } else { // store this type of region NewRegion = (MarkRegion)(region-1); pNewMark->SetRegion(NewRegion); // if we haven't run off the end of the string while ( Name.IsLegal(pos) && (Name[pos]!=PLUS) ) { TCHAR c = Name[pos]; switch (c) { case TEXT('T'): NewFormat.Top=TRUE; break; case TEXT('M'): NewFormat.Middle=TRUE; break; case TEXT('B'): NewFormat.Bottom=TRUE; break; case TEXT('L'): NewFormat.Left=TRUE; break; case TEXT('C'): NewFormat.Centre=TRUE; break; case TEXT('R'): NewFormat.Right=TRUE; break; default: // unknown token, just ignore it! if (c != SPACE) TRACEUSER( "Mike", _T("Unknown format character during PrintMarksMan::DecodeMarkFormat")); break; } pos = Name.FindNextChar(pos+1); } // make sure the format is ok if (!NewFormat.IsValid()) NewFormat.MakeValid(); // and set it in the structure. pNewMark->SetFormat(NewFormat); // Add the new mark position to the list. pMark->AddNewPosition(pNewMark); AllIsWell=TRUE; if (Name.IsLegal(pos)) pos = Name.FindNextChar(pos+1); } } else { pos = -1; } } } PORTNOTE("other", "Disabled random use of MFC CUserException in Kernel code") #ifndef EXCLUDE_FROM_XARALX catch (CUserException) { // An exception has been thrown which means // we failed to parse this string, so simply report failure AllIsWell = FALSE; } #endif // Switch off the exception state finally, (and of course pop it)! StringBase::DisableExceptionHandler(); return AllIsWell; }

UINT32 PrintMarksCache::DecodeToMarkType (  const String_256 *  Name  )  const [private]

Have a look at the string passed in and check to see it matches any of the known mark type names. If so return the proper mark type enum, otherwise 'Unkown' is returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: Name  = a pointer to a string describing the mark type [INPUTS] Returns: A unsigned integer describing the mark type (see MarkType for instances) Definition at line 1255 of file prnmks.cpp. { ERROR2IF(Name == NULL, MarkType_Unknown, "NULL pointer passed to DecodeToMarkType"); if ((*Name)==String_16(_T("ID_NONE"))) return MarkType_Unknown; /*NORESOURCEFIX*/ if ((*Name)==String_16(_T("ID_STAR"))) return MarkType_Star; /*NORESOURCEFIX*/ if ((*Name)==String_16(_T("ID_REGM"))) return MarkType_Registration; /*NORESOURCEFIX*/ if ((*Name)==String_16(_T("ID_CBAR"))) return MarkType_ColourBar; /*NORESOURCEFIX*/ if ((*Name)==String_16(_T("ID_GBAR"))) return MarkType_GreyBar; /*NORESOURCEFIX*/ if ((*Name)==String_16(_T("ID_INFO"))) return MarkType_Information; /*NORESOURCEFIX*/ return MarkType_Unknown; }

BOOL PrintMarksCache::DeleteChildAttribute (  NodeRenderableInk *  pParent, CCRuntimeClass *  pReqdAttrib )  [private]

Delete a child attribute of a specified type from this parent. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: -  [INPUTS] Definition at line 1619 of file prnmks.cpp. { ERROR2IF(pParent==NULL || pReqdAttrib==NULL, FALSE, "NULL parameter"); NodeAttribute* pAppliedAttr = pParent->GetChildAttrOfType(pReqdAttrib); if (!pAppliedAttr) return FALSE; pAppliedAttr->CascadeDelete(); delete pAppliedAttr; return TRUE; }

void PrintMarksCache::DestroyTextInfoMark (   )  [private]

Throw away any cached print information mark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: -  [INPUTS] Definition at line 1645 of file prnmks.cpp. { if (TextInfoHandle>0) { PrintMarkItem *pItem = FindMark(TextInfoHandle); if (pItem!=NULL) { pItem = (PrintMarkItem*)PrintMarkCache.RemoveItem(pItem); if (pItem) delete pItem; } } TextInfoHandle=0; }

BOOL PrintMarksCache::DoesMarkExist (  PrintMark *  pCheckMark  )  const [private]

Try to find a print mark in the cache. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: A  pointer to a print mark [INPUTS] Returns: TRUE if this mark already exists in the cache FALSE if not Definition at line 834 of file prnmks.cpp. { PrintMarkItem* pItem = GetFirstMark(); while (pItem) { PrintMark* pCurrMark = pItem->GetPrintMark(); if (pCheckMark->IsSimilarTo(pCurrMark)) return TRUE; pItem = GetNextMark(pItem); } return FALSE; }

PrintMarkItem * PrintMarksCache::FindMark (  UINT32  SearchHandle  )

Try to find a print mark in the cache, using its handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: SearchHandle  = the handle of the mark to search for [INPUTS] Returns: A pointer to the print mark described by this handle (NULL if none) Definition at line 860 of file prnmks.cpp. { PrintMarkItem* pItem = GetFirstMark(); while (pItem) { if (pItem->GetHandle() == SearchHandle) return pItem; pItem = GetNextMark(pItem); } return NULL; }

PrintMarkItem * PrintMarksCache::GetFirstMark (   )  const

Return a pointer to the first cached mark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: -  [INPUTS] Returns: A pointer to the first cached mark Definition at line 797 of file prnmks.cpp. { return ((PrintMarkItem*)PrintMarkCache.GetHead()); }

PrintMarkItem * PrintMarksCache::GetNextMark (  PrintMarkItem *  pCurrMark  )  const

Returns the next print mark item beyond pCurrMark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: A  pointer to a print mark item [INPUTS] Returns: A pointer to the next print mark item after this Definition at line 815 of file prnmks.cpp. { return ((PrintMarkItem*)PrintMarkCache.GetNext(pCurrMark)); }

UINT32 PrintMarksCache::GetUniqueHandle (   )  [private]

Generate a unique print mark handle. All handles will be >=1 and hence an illegal handle is given the value 0. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: -  [INPUTS] Returns: A handle used to reference a unique print mark Definition at line 777 of file prnmks.cpp. { NextHandle++; return (NextHandle); }

void PrintMarksCache::Invalidate (   )  [private]

Invalidate the cache list. If we do this, all the mark references in existing document will reference nothing. As we create new marks new handles will be built, so it might be necessary to delete references made in all doc components. Use with care. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Definition at line 752 of file prnmks.cpp. { // destroy all marks in the cache. PrintMarkItem* pItem; while ((pItem=(PrintMarkItem*)PrintMarkCache.RemoveTail())) // assignment delete pItem; // Make sure the crop and text info handles don't reference anything CropMarkHandle=0; TextInfoHandle=0; }

BOOL PrintMarksCache::SetInfoMarkAttributes (  TextStory *  pStory, String_64 *  pFontName, MILLIPOINT  FontSize )  [private]

This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text.... Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pComp  = the document component containing the print marks [INPUTS] CurrRegion = the current region we're formatting marks in Returns: - Document title Date Time Page number? Plate name Definition at line 1574 of file prnmks.cpp. { BOOL ok; // Ensure the font is cached. The fontmangler will return a replace font if // it can't find the required one. WORD Handle = FONTMANAGER->CacheNamedFont(pFontName); if (Handle==ILLEGALFHANDLE) return FALSE; // find the first line in this story TextLine* pTextLine = pStory->FindFirstLine(); if (pTextLine==NULL) return FALSE; // Delete the current instances of the attribute first ok = DeleteChildAttribute(pTextLine, CC_RUNTIME_CLASS(AttrTxtFontTypeface)); if (!ok) ok = DeleteChildAttribute(pStory, CC_RUNTIME_CLASS(AttrTxtFontTypeface)); ok = DeleteChildAttribute(pTextLine, CC_RUNTIME_CLASS(AttrTxtFontSize)); if (!ok) ok = DeleteChildAttribute(pStory, CC_RUNTIME_CLASS(AttrTxtFontSize)); // now create new ones TxtFontTypefaceAttribute FontAttr(Handle); TxtFontSizeAttribute SizeAttr(FontSize); ok = ((AttributeValue*)&FontAttr)->MakeNode(pTextLine,PREV) != NULL; if (ok) ok = ((AttributeValue*)&SizeAttr)->MakeNode(pTextLine,PREV) != NULL; return ok; }

void PrintMarksCache::UpdateMarkGlyph (  PrintMarkItem *  pMarkItem, NodeGroup *  pGroup )  [private]

Change the mark glyph to this new mark. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Parameters: pMarkItem  = a pointer to an existing cached mark [INPUTS] pGroup = a pointer to a new glyph to use. Returns: - Definition at line 1037 of file prnmks.cpp. { if (pMarkItem!=NULL) { // Make sure there's nothing in there at the mo. pMarkItem->RemoveMark(); // now set the new mark glyph pMarkItem->pMarkGlyph = pGroup; } }

BOOL PrintMarksCache::UpdateTextInfoMark (  Document *  pDocument, RenderRegion *  pRRegion )  [private]

This function creates a text information mark which will describe the current print job. As this will be created and destroyed on each print it should be reasonably fast to execute. We include the following information in the text.... Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pComp  = the document component containing the print marks [INPUTS] CurrRegion = the current region we're formatting marks in Returns: - Document title Date Time Page number? Plate name Definition at line 1413 of file prnmks.cpp. { // We should at least have one of these. if (TextInfoHandle==0) return FALSE; // find it in the cache PrintMarkItem *pMarkItem = FindMark(TextInfoHandle); if (!pMarkItem) return FALSE; // first put all the information we need to display in a string. String_256 TextInfo; BuildTextInfoString(pDocument, pRRegion, &TextInfo); // create a proper mark structure to fit this mark in NodeGroup* pNewGroup = new NodeGroup; if (pNewGroup==NULL) return FALSE; NodeGroup* pNewGroup1 = new NodeGroup; if (pNewGroup1==NULL) { delete pNewGroup; return FALSE; } /* // Make a text style LOGFONT to describe the text information LOGFONT Style; Style.lfHeight =0x08; // 8pt text Style.lfWidth =0x05; Style.lfEscapement =0x00; Style.lfOrientation =0x00; Style.lfWeight =0x190; Style.lfItalic =0x00; Style.lfUnderline =0x00; Style.lfStrikeOut =0x00; Style.lfCharSet =0x00; Style.lfOutPrecision =0x03; Style.lfClipPrecision =0x02; Style.lfQuality =0x01; Style.lfPitchAndFamily =0x12; camStrncpy(Style.lfFaceName, TEXT("Times New Roman\0"), 16); */ String_64 FontName(_T("Courier New")); MILLIPOINT FontSize = 9*1000; // now create the text story to put in the mark. TextStory *pStory; DocColour TextCol(COLOUR_BLACK); #ifdef _UNICODE pStory = TextStory::CreateFromChars(DocCoord(0,0), NULL, (TCHAR *)TextInfo, pDocument, NULL, FALSE, &TextCol); #else pStory = TextStory::CreateFromChars(DocCoord(0,0), (char *)TextInfo, NULL, pDocument, NULL, FALSE, &TextCol); #endif if (pStory==NULL) { // deleting this will delete the mark position delete pNewGroup1; delete pNewGroup; return FALSE; } // ok make sure the attributes are set nicely if (!SetInfoMarkAttributes(pStory,&FontName,FontSize)) { delete pStory; delete pNewGroup1; delete pNewGroup; return FALSE; } // Turn the print as shapes on. This means we will render it rather // than GDI rendering it. It also means the text goes out after our header // which sets things like Negative transfer. If we don't render the // text we wont have put out our header yet..... Hence the text has a habit // of vanishing on 'Negative' prints, black on black n all that. We could // set the colour of the text of course, hmm maybe? This is quicker for now. pStory->SetPrintingAsShapes(TRUE); // attach this new group to the tree pNewGroup1->AttachNode(pNewGroup,FIRSTCHILD); // attach the story to the group pStory->AttachNode(pNewGroup1,FIRSTCHILD); // We need to attach this structure to the tree, at the insertion node and makeattributes complete on it. pDocument->InsertNewNode(pNewGroup,NULL); /* // make sure we have all the attributes we're gonna need if (!pNewGroup->MakeAttributeComplete(NULL,TRUE,NULL,TRUE)) { pNewGroup->CascadeDelete(); delete pNewGroup; return FALSE; } */ // time to format the story into shape. if (!pStory->FormatAndChildren()) { pNewGroup->CascadeDelete(); delete pNewGroup; return FALSE; } // ok this is silly, but here we go, make the text into shapes so // it bloomin well prints properly. NodeGroup* pNGroup = new NodeGroup; if (pNGroup!=NULL) { // stuff it in the tree pNGroup->AttachNode(pNewGroup1,NEXT); // copy all children as shapes if (pNewGroup1->CopyChildrenAsShapes(pNGroup)) { // rip the node out of the tree and stick it in our cache. pNGroup->UnlinkNodeFromTree(); // destroy the first group we created pNewGroup->CascadeDelete(); delete pNewGroup; // finally stick the thing in our cache! // rip the node out of the tree and stick it in our cache. // finally stick the thing in our cache! UpdateMarkGlyph(pMarkItem, pNGroup); return TRUE; } pNGroup->CascadeDelete(); delete pNGroup; } // rip the node out of the tree and stick it in our cache. pNewGroup->UnlinkNodeFromTree(); // finally stick the thing in our cache! UpdateMarkGlyph(pMarkItem, pNewGroup); return TRUE; }

---

Friends And Related Function Documentation

friend class LoadPrintMarks [friend]

Definition at line 652 of file prnmks.h.

friend class PrintMarksComponent [friend]

Definition at line 653 of file prnmks.h.

friend class PrintMarksMan [friend]

Definition at line 651 of file prnmks.h.

---

Member Data Documentation

String_256 PrintMarksCache::CachedTime [private]

Definition at line 688 of file prnmks.h.

UINT32 PrintMarksCache::CropMarkHandle [private]

Definition at line 685 of file prnmks.h.

UINT32 PrintMarksCache::NextHandle [private]

Definition at line 683 of file prnmks.h.

List PrintMarksCache::PrintMarkCache [private]

Definition at line 686 of file prnmks.h.

UINT32 PrintMarksCache::TextInfoHandle [private]

Definition at line 684 of file prnmks.h.

---

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

• Kernel/prnmks.h (r1785/r1346)
• Kernel/prnmks.cpp (r1785/r1320)

---