PrintMarksMan Class Reference

The 'Print Marks Manager'. This manager handles the installation, formatting and rendering of printer marks. It liaises with the print box to provide a UI to enable and disable print marks. More...

#include <prnmks.h>

List of all members.

Public Member Functions
	PrintMarksMan ()
	Constructor for the PrintMarks Manager.
	~PrintMarksMan ()
	Destruct the PrintMarks manager. We delete all remaining cached items here.
BOOL	IsTemplateCached () const
	Return whether the disc based template file of marks has been cached once already.
BOOL	ConstructCache ()
	Here we construct the cache afresh. Well almost afresh, we need to do the following.
void	InvalidateCache ()
	Throws away the cache entirely. We unset the 'Template has been cached' variable which will result in a proper refiltering of the mark template file the next time we initialise.
BOOL	AddMarkToDoc (UINT32 MarkHandle, Document *pDocument)
	Add a mark reference to the documents displayable printer marks.
BOOL	RemoveMarkFromDoc (UINT32 MarkHandle, Document *pDocument)
	Removes the mark reference held in the print marks doc component inside this document.
void	ConvertAllDocColours (Document *pDoc)
	Convert all the index colours in the document to local doc colours. This avoids problems with copying data out of the tree and deleting the index colours. What does this mean. Ok, if you make a copy of the print mark, put the copy in the PMM and delete the original document, you will delete the doc component colour list which contains all used index colour definitions. These index col defs contain usage counts which will be incremented during the copy. An attempt to delete all these index colours will cause an error (index colour still in use) even though its not in use in the document. Hence we need to remove all index colour references from the document before we make a copy. This is what the function does by making local doc colours.
BOOL	AddDefaultMarksToDoc (Document *pDocument)
	Add all 'defaults to on' mark references to the documents displayable printer marks.
BOOL	ShowPrintMarks (Document *ScopeDoc) const
	Determine if a docuemnt will output printers marks when printing.
void	RenderPrintMarks (Document *ScopeDoc, BOOL DisplayEm=TRUE, BOOL LoadTemplateMarks=TRUE)
	Enable/Disable output of printers marks for the given document.
void	RenderPrintMarks (PrintMarksComponent *pComp, RenderRegion *pRRegion, const Matrix &Transform, const DocRect &ClipRect, Spread *pSpread)
void	StartPrinting ()
	Called from the print control system to tell the print mark manager that printing has started. Here we make sure all our print time local variables are set to default values.
BOOL	AddPageRect (const DocRect &Rect)
	This function provides the ability to specify n page rectangles. Each of these rectangles will have crop marks positioned around the paper edge to line up with this rectangle. Hence the print system uses this function to specify the final positions of all the multi fit page rectangles during a print. We make sure we then create and render the right number of crop marks to fit this rectangle list.
void	ResetPageRects ()
	Destroys the list of page rectangles the print marks manager caches.
void	SetBleed (MILLIPOINT bleed)
	Tells the print marks manager what bleed to use during this print pass. This is usually a globally set value and is unlikely to change across plates or pages. We use the value to inflate the typesetting rect by.
void	SetEmulsionDown (BOOL state)
	Tells the print marks manager which way up the emulsion is. This determins whether the marks manager will flip its marks during rendering or not.
void	SetImagesettingRect ()
	Define the print marks rectangle. During a print this rectangle will determin where print marks will be placed. For instance if you are printing a 2x2 multiple fit page, the print marks rectangle will be the union of all these page tiles. Hence the print marks will be places around the entire print area. Crop marks will be placed in this area too but will be positioned to align with each page. Notes: The union of the PageRects, added while printing the current paper will give the imagesetting rectangle. Each one of these PageRects needs a set of crop marks.
void	EndPrinting ()
	Called from the print control system to tell the print mark manager that printing has ended. Here we delete all the page rectangle positions added to our cached list.
MILLIPOINT	GetCropMarkWidth (Document *ScopeDoc) const
void	ClipToBleed (RenderRegion *pRRegion, Spread *pSpread)
	Export the bleed rectangle as the current clipping region. All graphics will be clipped to this region.
Public Attributes
PrintMarksCache	PMMCache
Private Member Functions
	CC_DECLARE_MEMDUMP (PrintMarksMan)
void	CompileMarkRegion (PrintMarksComponent *pComp, MarkRegion CurrRegion)
	Add all the marks which are supposedly in this region into the region and format em before rendering. What happens is this. Each mark reference in the doc component is found in the marks manager. The record in the marks manager describes the regions the mark should be formatted into. We add the mark if it happens to be the right region on entry. Adding the mark to the formatting region adds a position record which is used to render the mark when the region is rendered.
void	RenderPrintMarksAroundRect (PrintMarksComponent *pComp, RenderRegion *pRRegion, const Matrix *pTrans, const DocRect &Rect, MILLIPOINT bleed)
	Render all user print marks contained in this doc component.
void	RenderCropMarksAroundRect (RenderRegion *pRRegion, const Matrix *pTrans, const DocRect &Rect, MILLIPOINT bleed)
	Render all print marks contained in this doc component and the crop marks if they are enabled around the given rectangle.
MILLIPOINT	AdjustedBleed () const
	Internal function to get the adjusted bleed value.
Private Attributes
BOOL	TemplateCached
MarkFormatRegion	MFRegion
DocRect	ImagesettingRect
PageRectList	PageRects
MILLIPOINT	Bleed
BOOL	EmulsionDown

---

Detailed Description

The 'Print Marks Manager'. This manager handles the installation, formatting and rendering of printer marks. It liaises with the print box to provide a UI to enable and disable print marks.

Author:

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

Date:

23/07/96

See also:

Specification of print marks inside 'ImageSetting Phase 3' documentation

Definition at line 705 of file prnmks.h.

---

Constructor & Destructor Documentation

PrintMarksMan::PrintMarksMan (   )

Constructor for the PrintMarks Manager. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Definition at line 1782 of file prnmks.cpp. { Bleed = 0; TemplateCached=FALSE; EmulsionDown=FALSE; }

PrintMarksMan::~PrintMarksMan (   )

Destruct the PrintMarks manager. We delete all remaining cached items here. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Definition at line 1800 of file prnmks.cpp. { }

---

Member Function Documentation

BOOL PrintMarksMan::AddDefaultMarksToDoc (  Document *  pDocument  )

Add all 'defaults to on' mark references to the documents displayable printer marks. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: pDocument  = a pointer to a document to add the default set to [INPUTS] Returns: TRUE if all 'defaults to on' marks have been added, FALSE if none have. Definition at line 2103 of file prnmks.cpp. { ERROR3IF(pDocument==NULL,"NULL document pointer passed to AddDefaultMarks()"); BOOL Added=FALSE; if (pDocument!=NULL) { // Get that print marks doc component PrintMarksComponent* pMarksComp = (PrintMarksComponent*)pDocument->GetDocComponent(CC_RUNTIME_CLASS(PrintMarksComponent)); if (pMarksComp && pMarksComp->IsVirgin()) { // now go through each print mark and add it if necessary PrintMarkItem* pMarkItem = PMMCache.GetFirstMark(); while (pMarkItem) { // check to see if this mark is on by default if (pMarkItem->DefaultsToOn()) { // Add this item to the document UINT32 handle = pMarkItem->GetHandle(); pMarksComp->AddMark(handle); } // find the next print mark item pMarkItem = PMMCache.GetNextMark(pMarkItem); } // ok we've tried to add em. Added=TRUE; } } return Added; }

BOOL PrintMarksMan::AddMarkToDoc (  UINT32  MarkHandle, Document *  pDocument )

Add a mark reference to the documents displayable printer marks. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: MarkHandle  = the handle of the mark to add [INPUTS] pDocument = a pointer to a document to add the mark to Returns: TRUE if the mark has been added, FALSE if not. Definition at line 2024 of file prnmks.cpp. { ERROR2IF(pDocument==NULL,FALSE,"NULL document pointer passed to AddMarkToDoc!"); // Sanity check, make sure this mark handle actually exists if (!PMMCache.FindMark(MarkHandle)) { ERROR3("Illegal handle given to PrintMarksMan::AddMarkToDoc"); return FALSE; } // ok, try to find the print marks component in this document. PrintMarksComponent* pComponent = (PrintMarksComponent*)pDocument->GetDocComponent(CC_RUNTIME_CLASS(PrintMarksComponent)); if (!pComponent) { ERROR3("We're stimmied, there's no PrintMarksComponent in this document!"); return FALSE; } // super duper, we've got the doc component, so lets add our mark reference to // its list. return pComponent->AddMark(MarkHandle); }

BOOL PrintMarksMan::AddPageRect (  const DocRect &  rect  )

This function provides the ability to specify n page rectangles. Each of these rectangles will have crop marks positioned around the paper edge to line up with this rectangle. Hence the print system uses this function to specify the final positions of all the multi fit page rectangles during a print. We make sure we then create and render the right number of crop marks to fit this rectangle list. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: rect  = a document rectangle specifying the a pages position in the [INPUTS] print paper coordinate system Returns: - See also: ScreenView::EnumeratePagePatches(). Definition at line 2265 of file prnmks.cpp. { // add this rectangle return PageRects.AddPageRect(rect); }

MILLIPOINT PrintMarksMan::AdjustedBleed (   )  const [private]

Internal function to get the adjusted bleed value. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: the size of the bleed as we know it Definition at line 2324 of file prnmks.cpp. { return (Bleed+OUTSIDEBLEEDWIDTH); }

PrintMarksMan::CC_DECLARE_MEMDUMP (  PrintMarksMan   )  [private]

void PrintMarksMan::ClipToBleed (  RenderRegion *  pRRegion, Spread *  pSpread )

Export the bleed rectangle as the current clipping region. All graphics will be clipped to this region. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 28/8/96 Parameters: pRRegion  = a pointer to a render region [INPUTS] Pass in NULL to use the selected doc. Returns: - Definition at line 2515 of file prnmks.cpp. { // if any of these are null we can't do the job if (pRRegion==NULL) return; // if there's no imagesetting rect to render around we can't position our marks if (ImagesettingRect.IsEmpty()) return; // do we need to display our marks? if ( !ShowPrintMarks( (Document *) (pSpread->FindOwnerDoc()) ) ) return; PORTNOTE("printing", "disabled print mark generation use of PrintPSRenderRegion") #ifndef EXCLUDE_FROM_XARALX // dont render to a none postscript region if ( !IS_A(pRRegion, PrintPSRenderRegion) ) return; // BODGE ALERT... // Clip everything else to this imagesetting rectangle // Go get the adjusted bleed MILLIPOINT adjbleed = AdjustedBleed(); DocRect Rect = ImagesettingRect; Rect.Inflate(adjbleed); PSPrintDC *pPrintDC = (PSPrintDC*)pRRegion->GetRenderDC(); ((PrintPSRenderRegion*)pRRegion)->WriteClipRegion(pPrintDC, Rect); // BODGE ALERT // Mike 02/09/96 - We should be performing stacked clipping. This is not the place // to alter the postscript clip region but if will suffice for now. #endif }

void PrintMarksMan::CompileMarkRegion (  PrintMarksComponent *  pComp, MarkRegion  CurrRegion )  [private]

Add all the marks which are supposedly in this region into the region and format em before rendering. What happens is this. Each mark reference in the doc component is found in the marks manager. The record in the marks manager describes the regions the mark should be formatted into. We add the mark if it happens to be the right region on entry. Adding the mark to the formatting region adds a position record which is used to render the mark when the region is rendered. 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: - Definition at line 2893 of file prnmks.cpp. { UINT32 handle; // Dig the mark reference out of this doc component. DocPrintMark* pDocMark = pComp->GetFirstMark(); while (pDocMark) { // retrieve the reference handle of this mark handle=pDocMark->GetHandle(); // find the mark item in the print marks cache PrintMarkItem* pMarkItem = PMMCache.FindMark(handle); if (pMarkItem && pMarkItem->NeedsToRender()) { // ok we have a pointer to the mark item. Scan through all its format // positions and add the mark if necessary PrintMark* pPrintMark = pMarkItem->GetPrintMark(); if (pPrintMark) { MarkPosition* pMarkPosition = pPrintMark->GetFirstPosition(); while (pMarkPosition!=NULL) { if (pMarkPosition->GetRegion()==CurrRegion) { MarkFormat LocalFormat = pMarkPosition->GetFormat(); MFRegion.AddMark(pMarkItem, &LocalFormat); } pMarkPosition = pPrintMark->GetNextPosition(pMarkPosition); } } } // go onto format and render the next object pDocMark = pComp->GetNextMark(pDocMark); } }

BOOL PrintMarksMan::ConstructCache (   )

Here we construct the cache afresh. Well almost afresh, we need to do the following. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 (1) find the disc file containing our marks (2) load the file as a document (3) convert all index colours used in objects to lookalike doc colours (4) enumerate each layer and decode the layer name (5) find the group inside the layer which contains the mark (6) make a copy of this information as a PrintMarkItem (7) merge the PrintMarkItem with the current contents of the cache. This is v.important as there will be valuable information already in the cache we don't want to lose. (8) destroy the document on completion (or partial completion==failure) easy really. We use various lower level functions to perform all of course. Definition at line 1850 of file prnmks.cpp. { // If its already cached then ignore this call. if (TemplateCached) return TRUE; BOOL ok=FALSE; // otherwise do some serious stuff. TCHAR SearchFile[] = _T("mrktmpl.xar"); // TCHAR *OutputBuff = new TCHAR[_MAX_PATH]; if (1 /*OutputBuff*/) { LoadPrintMarks LdPrintMark; // try to find the search file... StringVar s(CamResource::GetResourceFilePath(SearchFile)); PORTNOTE("other", "Disabled printmark resource file finding") #ifndef EXCLUDE_FROM_XARALX ok = FileUtil::FindResourceFile(SearchFile, OutputBuff); #endif // Add a crop mark bits. ok = ok && PMMCache.CreateCropMark(); // Add a text info mark too. ok = ok && PMMCache.CreateTextInfoMark(); // Get the winoil level direct loader to do its stuff ok = ok && LdPrintMark.Execute(s); // delete the allocated buffer // delete OutputBuff; } // return all is well/not well return (TemplateCached=ok); }

void PrintMarksMan::ConvertAllDocColours (  Document *  pDoc  )

Convert all the index colours in the document to local doc colours. This avoids problems with copying data out of the tree and deleting the index colours. What does this mean. Ok, if you make a copy of the print mark, put the copy in the PMM and delete the original document, you will delete the doc component colour list which contains all used index colour definitions. These index col defs contain usage counts which will be incremented during the copy. An attempt to delete all these index colours will cause an error (index colour still in use) even though its not in use in the document. Hence we need to remove all index colour references from the document before we make a copy. This is what the function does by making local doc colours. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> / Mike Date: 31/07/96 Definition at line 1938 of file prnmks.cpp. { ERROR3IF(pDoc==NULL,"No doc pointer during PrintMarksMan::ConvertAllDocColours!"); Node *CurNode = Node::DocFindFirstDepthFirst(pDoc); Node *NextNode; while (CurNode !=NULL) { // We may be about to chop this node out of the tree, so get the next node now NextNode = CurNode->DocFindNextDepthFirst(); // Use to scan the colour fields of the attribute. UINT32 Context = 0; DocColour *pColour; if (CurNode->IsAnAttribute()) { NodeAttribute *pNodeAttr = (NodeAttribute *) CurNode; // Get the next colour field from the attribute pColour = pNodeAttr->EnumerateColourFields(Context++); while (pColour != NULL) { // For each colour field, make sure the colour is a local DocColour so that // the sub-tree is entirely stand-alone if (pColour->FindParentIndexedColour() != NULL) { ColourGeneric ColDef; ColourContext *cc = ColourManager::GetColourContext(pColour->GetColourModel()); ERROR3IF(cc == NULL, "Can't find colour context?!"); // Get the IndexedColour definition as a standalone colour definition cc->ConvertColour(pColour->FindParentIndexedColour(), &ColDef); // Make the DocColour into a simple standalone "lookalike" of the parent colour *pColour = DocColour(pColour->GetColourModel(), &ColDef); } pColour = pNodeAttr->EnumerateColourFields(Context++); } } CurNode = NextNode; } }

void PrintMarksMan::EndPrinting (   )

Called from the print control system to tell the print mark manager that printing has ended. Here we delete all the page rectangle positions added to our cached list. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: - Definition at line 2218 of file prnmks.cpp. { PageRects.DeleteAll(); ImagesettingRect.MakeEmpty(); }

MILLIPOINT PrintMarksMan::GetCropMarkWidth (  Document *  ScopeDoc  )  const

Definition at line 2392 of file prnmks.cpp. { if (ShowPrintMarks(ScopeDoc)) return (CROPMARK_LENGTH + OUTSIDEBLEEDWIDTH); else return 0; }

void PrintMarksMan::InvalidateCache (  void   )

Throws away the cache entirely. We unset the 'Template has been cached' variable which will result in a proper refiltering of the mark template file the next time we initialise. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: - Definition at line 2000 of file prnmks.cpp. { // Force a proper recache next time the marks are accessed TemplateCached=FALSE; // Destroy everything in the current marks list PMMCache.Invalidate(); }

BOOL PrintMarksMan::IsTemplateCached (   )  const

Return whether the disc based template file of marks has been cached once already. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 23/07/96 Returns: TRUE if we've cached the print marks template once during the life of the program FALSE if not. Definition at line 1819 of file prnmks.cpp. { return TemplateCached; }

BOOL PrintMarksMan::RemoveMarkFromDoc (  UINT32  MarkHandle, Document *  pDocument )

Removes the mark reference held in the print marks doc component inside this document. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: MarkHandle  = the handle of the mark to remove [INPUTS] pDocument = a pointer to a document to remove the mark from Returns: TRUE if the mark has been removed FALSE if not. This result will occur only when the document does not contain a print marks component or I cannot find the specified mark. If the mark exists it will never fail to be removed. Definition at line 2068 of file prnmks.cpp. { ERROR2IF(pDocument==NULL,FALSE,"NULL document pointer passed to AddMarkToDoc!"); // ok, try to find the print marks component in this document. PrintMarksComponent* pComponent = (PrintMarksComponent*)pDocument->GetDocComponent(CC_RUNTIME_CLASS(PrintMarksComponent)); if (!pComponent) { ERROR3("We're stimmied, there's no PrintMarksComponent in this document!"); return FALSE; } // super duper, we've got the doc component, so lets add our mark reference to // its list. pComponent->RemoveMark(MarkHandle); return TRUE; }

void PrintMarksMan::RenderCropMarksAroundRect (  RenderRegion *  pRRegion, const Matrix *  pTrans, const DocRect &  Rect, MILLIPOINT  bleed )  [private]

Render all print marks contained in this doc component and the crop marks if they are enabled around the given rectangle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pRRegion=  the render region to draw in [INPUTS] pSpread = the spread to draw Returns: Definition at line 2570 of file prnmks.cpp. { // create a cropline path and set it up Path CropLine; if (!CropLine.Initialise()) return; // an extra bit we pust the marks out by if the bleed is zero INT32 ExtraBit = 0; if (bleed==0) ExtraBit = 2384; // transform the rectangle if necessary DocRect TransformedRect(Rect); TransformedRect.Inflate(bleed+ExtraBit); if (pTrans) { pTrans->transform(&TransformedRect.lo); pTrans->transform(&TransformedRect.hi); } MILLIPOINT Tmp; if (TransformedRect.lo.x > TransformedRect.hi.x) { Tmp = TransformedRect.lo.x; TransformedRect.lo.x = TransformedRect.hi.x; TransformedRect.hi.x = Tmp; } if (TransformedRect.lo.y > TransformedRect.hi.y) { Tmp = TransformedRect.lo.y; TransformedRect.lo.y = TransformedRect.hi.y; TransformedRect.hi.y = Tmp; } // Calculate the inverse of the render matrix, this allows us to render // through a scaling render region and prevent our marks being scaled. Matrix ViewTrans = pRRegion->GetMatrix(); ViewTrans = ViewTrans.Inverse(); // get the cropmark length INT32 Length = CROPMARK_LENGTH; double Thickness = CROPMARK_THICKNESS; // now adjust it a little as we may be pushing the cropmarks out // by 1mm and taking 1mm off the length. This is only done when there // is no bleed set and means the cropmarks don't touch each other. Length -= ExtraBit; if (Length<1) Length=1; // ok we need to scale the thickness dependent on the current scale // facter within this render region otherwise, the region will scale it // for us which would be real bad stuff indeed. FIXED16 CurrScale; ViewTrans.Decompose(&CurrScale); double scale = CurrScale.MakeDouble(); // Emulsion down does its stuff by getting the render matrix to flip about // the Y axis. This shows up in the scale as a negative value returned. We // need the absoulte scale. if (scale<0) scale = -scale; Thickness = Thickness*scale; INT32 Thick = (INT32)(Thickness+0.5); if (Thick<1) Thick=1; // start setting attributes in this render context pRRegion->SaveContext(); pRRegion->SetLineColour(COLOUR_BLACK); pRRegion->SetLineWidth(Thick); // Set up some dummy data CropLine.AddMoveTo(DocCoord(0,0)); CropLine.AddLineTo(DocCoord(72000,0)); // Get the coords array in our cropline path DocCoord *Coords = CropLine.GetCoordArray(); // go through all our registered page rectangles and generate DocCoord iLo = TransformedRect.lo; DocCoord iHi = TransformedRect.hi; // process all our page rectangles PageRect *pRect = PageRects.GetFirstPageRect(); DocCoord p0,p1,rLo,rHi; // ok finally render them all #define LINEDRAW(p,q) \ ViewTrans.transform(&p); \ ViewTrans.transform(&q); \ Coords[0]=p; \ Coords[1]=q; \ pRRegion->DrawPath(&CropLine); while (pRect) { rLo = pRect->Rect.lo; rHi = pRect->Rect.hi; p0.x = iLo.x; p1.x = iLo.x - Length; p0.y = p1.y = rLo.y; LINEDRAW(p0,p1); p0.x = iLo.x; p1.x = iLo.x - Length; p0.y = p1.y = rHi.y; LINEDRAW(p0,p1); p0.y = iHi.y; p1.y = iHi.y + Length; p0.x = p1.x = rLo.x; LINEDRAW(p0,p1); p0.y = iHi.y; p1.y = iHi.y + Length; p0.x = p1.x = rHi.x; LINEDRAW(p0,p1); p0.x = iHi.x; p1.x = iHi.x + Length; p0.y = p1.y = rHi.y; LINEDRAW(p0,p1); p0.x = iHi.x; p1.x = iHi.x + Length; p0.y = p1.y = rLo.y; LINEDRAW(p0,p1); p0.y = iLo.y; p1.y = iLo.y - Length; p0.x = p1.x = rHi.x; LINEDRAW(p0,p1); p0.y = iLo.y; p1.y = iLo.y - Length; p0.x = p1.x = rLo.x; LINEDRAW(p0,p1); pRect = PageRects.GetNextPageRect(pRect); } #undef LINEDRAW // pop the attribute context again pRRegion->RestoreContext(); }

void PrintMarksMan::RenderPrintMarks (  PrintMarksComponent *  pComp, RenderRegion *  pRRegion, const Matrix &  Transform, const DocRect &  ClipRect, Spread *  pSpread )

Definition at line 2420 of file prnmks.cpp. { // if any of these are null we can't do the job if (pComp==NULL || pRRegion==NULL || pSpread==NULL) return; // do we need to display our marks? if ( !ShowPrintMarks( (Document *) (pSpread->FindOwnerDoc()) ) ) return; // if there's no imagesetting rect to render around we can't position our marks if (ImagesettingRect.IsEmpty()) return; // Go get the adjusted bleed MILLIPOINT adjbleed = AdjustedBleed(); // is this region a postscript render region? PORTNOTE("printing", "disabled print mark generation use of PrintPSRenderRegion") #ifndef EXCLUDE_FROM_XARALX BOOL OldClipState = FALSE; BOOL IsPostScript = pRRegion->IS_KIND_OF(PrintPSRenderRegion); PSPrintDC *pPrintDC = NULL; // configure the postscript clipping region if (IsPostScript) { // Get the render DC pPrintDC = (PSPrintDC*)pRRegion->GetRenderDC(); if (pPrintDC==NULL) return; // Disable the print clipping for the moment OldClipState = pPrintDC->SetClipping(FALSE); } #endif // check for any user doc marks DocPrintMark* pDocMark = pComp->GetFirstMark(); if (pDocMark!=NULL) { // Update the text info mark now. This builds the time/date etc. Document* pDoc = Document::GetSelected(); PMMCache.UpdateTextInfoMark(pDoc, pRRegion); // get the bleed size used in this spread RenderPrintMarksAroundRect(pComp, pRRegion, NULL, ImagesettingRect, adjbleed); // ok are crop marks created? if (PMMCache.CropMarkHandle>0) { // and are they in this document component? if (pComp->FindMark(PMMCache.CropMarkHandle)!=NULL) RenderCropMarksAroundRect(pRRegion, NULL, ImagesettingRect, adjbleed); } } PORTNOTE("printing", "disabled print mark generation use of PrintPSRenderRegion") #ifndef EXCLUDE_FROM_XARALX // finalise any bleed area clipping in PostScript if (IsPostScript) { if (pPrintDC) { // Reset the clipping state of affairs. pPrintDC->SetClipping(TRUE); //OldClipState); // Export the cliptobleed stuff pPrintDC->OutputPSClipping(); // ClipToBleed(pRRegion,pSpread); } } #endif }

void PrintMarksMan::RenderPrintMarks (  Document *  ScopeDoc, BOOL  DisplayEm = TRUE, BOOL  UpdateCache = TRUE )

Enable/Disable output of printers marks for the given document. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>/Jason Date: ... / 28/8/96 Parameters: ScopeDoc  - points to the document for which you want to find out. [INPUTS] Pass in NULL to use the selected doc. DisplayEm - TRUE to enable, FALSE to disable, printing of printers marks LoadTemplateMarks - TRUE to ensure that the printers marks are cached in the PMM, or FALSE to merely enable/disable printing thereof. Note that if the PMM cache is not initialised, then no print marks are available, and hence this variable defaults to TRUE. If they're already cached, nothing is done. See also: PrinterMarksMan::ShowPrintMarks; TypesetInfo::SetOutputPrintersMarks Definition at line 2352 of file prnmks.cpp. { TypesetInfo *pInfo = TypesetInfo::FindTypesetInfoForDoc(ScopeDoc); if (pInfo != NULL) pInfo->SetOutputPrintersMarks(DisplayEm); if (DisplayEm && UpdateCache) ConstructCache(); }

void PrintMarksMan::RenderPrintMarksAroundRect (  PrintMarksComponent *  pComp, RenderRegion *  pRRegion, const Matrix *  pTrans, const DocRect &  Rect, MILLIPOINT  bleed )  [private]

Render all user print marks contained in this doc component. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 10/08/96 Parameters: pComp  = the document component containing the print marks [INPUTS] pRRegion= the render region to draw in pSpread = the spread to draw Returns: Definition at line 2738 of file prnmks.cpp. { pRRegion->SaveContext(); // transform the rectangle if necessary DocRect TransformedRect(Rect); if (pTrans) { pTrans->transform(&TransformedRect.lo); pTrans->transform(&TransformedRect.hi); } // construct all 16 regions around this page rect PageMarkRegions MyPageRegions; MyPageRegions.Initialise(TransformedRect,bleed); Matrix OuterTransform; if (EmulsionDown) { DocRect Rect = TransformedRect; Rect.Inflate(bleed); INT32 w = Rect.Width(); OuterTransform *= Matrix(-Rect.lo); OuterTransform *= Matrix(FIXED16(-1), FIXED16(0), FIXED16(0), FIXED16(1), w, 0); OuterTransform *= Matrix(Rect.lo); } for (INT32 i=0; i<MAXPAGEREGIONS; i++) { if (MyPageRegions.Region[i].Valid) { // Make sure the formatting region is empty first MFRegion.Empty(); MFRegion.SetPosition(MyPageRegions.Region[i].Pos); MFRegion.SetOrientation(MyPageRegions.Region[i].OrientX); // MFRegion.SetFlipRender(EmulsionDown); CompileMarkRegion(pComp, (MarkRegion)i ); MFRegion.Render(pRRegion,OuterTransform); } } // pop the attribute context again pRRegion->RestoreContext(); }

void PrintMarksMan::ResetPageRects (   )

Destroys the list of page rectangles the print marks manager caches. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: - Definition at line 2305 of file prnmks.cpp. { PageRects.DeleteAll(); }

void PrintMarksMan::SetBleed (  MILLIPOINT  bleed  )

Tells the print marks manager what bleed to use during this print pass. This is usually a globally set value and is unlikely to change across plates or pages. We use the value to inflate the typesetting rect by. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: bleed  = the bleed used during this print [INPUTS] Returns: - Definition at line 2240 of file prnmks.cpp. { Bleed=bleed; }

void PrintMarksMan::SetEmulsionDown (  BOOL  state  )

Tells the print marks manager which way up the emulsion is. This determins whether the marks manager will flip its marks during rendering or not. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: state  = the new state of the emulsion down flag the print marks manager [INPUTS] will use during this print Returns: - Definition at line 2287 of file prnmks.cpp. { EmulsionDown=state; }

void PrintMarksMan::SetImagesettingRect (   )

Define the print marks rectangle. During a print this rectangle will determin where print marks will be placed. For instance if you are printing a 2x2 multiple fit page, the print marks rectangle will be the union of all these page tiles. Hence the print marks will be places around the entire print area. Crop marks will be placed in this area too but will be positioned to align with each page. Notes: The union of the PageRects, added while printing the current paper will give the imagesetting rectangle. Each one of these PageRects needs a set of crop marks. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: - Definition at line 2161 of file prnmks.cpp. { ImagesettingRect.MakeEmpty(); PageRect* pRect = PageRects.GetFirstPageRect(); while (pRect) { ImagesettingRect = ImagesettingRect.Union(pRect->Rect); pRect = PageRects.GetNextPageRect(pRect); } }

BOOL PrintMarksMan::ShowPrintMarks (  Document *  ScopeDoc  )  const

Determine if a docuemnt will output printers marks when printing. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 28/8/96 Parameters: ScopeDoc  - points to the document for which you want to find out. [INPUTS] Pass in NULL to use the selected doc. Returns: TRUE if printers marks will be output when printing this document See also: PrinterMarksMan::RenderPrintMarks; TypesetInfo::SetOutputPrintersMarks Definition at line 2382 of file prnmks.cpp. { TypesetInfo *pInfo = TypesetInfo::FindTypesetInfoForDoc(ScopeDoc); if (pInfo != NULL) return(pInfo->OutputPrintersMarks()); return(FALSE); }

void PrintMarksMan::StartPrinting (   )

Called from the print control system to tell the print mark manager that printing has started. Here we make sure all our print time local variables are set to default values. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: - Definition at line 2189 of file prnmks.cpp. { // destroy the current set of rectangles PageRects.DeleteAll(); ImagesettingRect.MakeEmpty(); EmulsionDown=FALSE; Bleed=0; // now cache the print time CCTime MyTime; PMMCache.CachedTime.Empty(); String_64 TimeFormat(_T("%dy/%mt/%yr %th.%mn %pm")); MyTime.ConvertStandardDateAndTime(&TimeFormat, &PMMCache.CachedTime); }

---

Member Data Documentation

MILLIPOINT PrintMarksMan::Bleed [private]

Definition at line 763 of file prnmks.h.

BOOL PrintMarksMan::EmulsionDown [private]

Definition at line 764 of file prnmks.h.

DocRect PrintMarksMan::ImagesettingRect [private]

Definition at line 761 of file prnmks.h.

MarkFormatRegion PrintMarksMan::MFRegion [private]

Definition at line 760 of file prnmks.h.

PageRectList PrintMarksMan::PageRects [private]

Definition at line 762 of file prnmks.h.

PrintMarksCache PrintMarksMan::PMMCache

Definition at line 710 of file prnmks.h.

BOOL PrintMarksMan::TemplateCached [private]

Definition at line 757 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)

---