View Class Reference

The basic kernel view item. This class contains minimal functionality to maintain the 'current' view, and the connection from a kernel view object to an OIL view object. DocView and PrintView are derived from this class. More...

#include <view.h>

Inheritance diagram for View:

List of all members.

Public Member Functions
	View ()
	Initialise a View object.
virtual	~View ()
	Cleans up a view object.
BOOL	ConnectToOilView (CCamView *)
	To set up the bi-directional connection between the OIL view object and the View. The OIL view object causes the creation of the View and so already has a pointer to it when it calls this routine to set up the connection in the other direction.
Document *	GetDoc () const
	Returns the linake between this View and its Document.
CCamView *	GetConnectionToOilView () const
	To get a pointer to the OIL view object which mirrors this one. Note that this can return NULL if the View does not have a mirroring OIL object. In this case the view is closed but the View remains available so that in the future a new view will be able to use all of its viewing parameters.
PrintControl *	GetPrintControl ()
	Simple way of getting the PrintControl object associated with this view's document.
virtual void	SetViewState (ViewState *)
	Sets the structure which is shared by both View and the OIL view object to which it is connected. NB. PrintViews do NOT share the ViewState with the OIL view, because the OIL view is the screen based view, so the PrintView is the only one that needs to use the view state. The CCamView always uses the ViewState of its DocView, not its PrintView.
virtual BOOL	ViewStateChanged ()=0
BOOL	SetCurrent ()
	Make this object be the 'current' View.
virtual void	SetViewPixelSize ()=0
void	OnDraw (wxDC *, OilRect)
	Do the drawing, guv.
virtual void	ContinueRenderView (RenderRegion *, Spread *, BOOL fRenderPaper=TRUE, BOOL fDeleteRegionAfter=TRUE, BOOL bForceImmediate=FALSE)=0
virtual wxDC *	GetRenderDC ()=0
virtual void	AllocateDC ()
	Hints that we've done with our DC.
virtual void	DoneWithDC ()
	Hints that we've done with our DC.
virtual BOOL	RenderTreeCallback (Node *pNode, RenderRegion *pRender)
RenderViewResult	RenderOptimalView (RenderRegion *r, Matrix &, Spread *, BOOL)
	This function has been designed along similar lines to the RenderView() function found elsewhere in this file. This version of the function is slightly different though. This version of the function is able to render complex objects, such as transparent objects into normal render regions. It does this by first scanning through all the objects that need rendering to see if any of them require complex things. If they do, then part of the rendering is done into a bitmap and blitted over the rest of the shapes using a masked blit. All very complicated really! This is the optimal version of this function, that will render individual complex shapes to the device instead of building them all up and blitting them in one go. This will produce the best quality results as as many objects as possible will be rendered to the resolution of the device.
SlowJobResult	RenderOptimalBitmapPhase (DocRect &ClipRect, Matrix &, Spread *, RenderRegion *, Node *, Node *, BOOL RenderAllObjects, BOOL bPrintPaper, INT32 &, ProgressDisplay *pProgress, INT32 TotalProgress)
	Renders the masked bitmap part of the process. This function will get called many times during the typical rendering of the document (once for each run of complex nodes in the document).
virtual RenderViewResult	RenderSimpleView (RenderRegion *, Matrix &, Spread *, BOOL)
	This function has been designed along similar lines to the RenderView() function found elsewhere in this file. This version of the function is slightly different though. This version of the function is able to render complex objects, such as transparent objects into normal render regions. It does this by first scanning through all the objects that need rendering to see if any of them require complex things. If they do, then part of the rendering is done into a bitmap and blitted over the rest of the shapes using a masked blit. All very complicated really!
SlowJobResult	RenderBitmapPhase (DocRect &ClipRect, Matrix &, Spread *, RenderRegion *, Node *, Node *, BOOL bRenderAll, BOOL bPrintPaper, ProgressDisplay &Progress)
	This function is called from RenderSimpleView if it ends up having to do the 3 phase rendering system. This function performs the bitmap phase, where all the objects deemed to be complex by the Host render region are rendered into a bitmap using GDraw and a mono, mask bitmap. The bitmap is blitted into the host render region using the mask bitmap, minimising the amount of bitmaps ending up in the view (important for things like postscript that do not really like bitmaps very much).
virtual void	RenderPaper (Spread *, DocRect, wxDC *, Matrix &)
	Actually renders the paper onto the screen. Moved from 'MakeNewRenderRegion' so that it can be called from outside (eg. ResetRegion).
virtual BOOL	RenderPageMarks (RenderRegion *, Matrix &, DocRect &, Spread *)
	Performs the rendering of page marks, ie crop marks, registration marks etc to the screen and printer. This base class version does nothing. All mark rendering technology is held in DocView and PrintView.
virtual BOOL	GetForeBackMode ()=0
virtual void	SetForeBackMode (BOOL)=0
virtual Matrix	ConstructRenderingMatrix (Spread *pSpread)
	From the given spread, construct a matrix that will convert spread coordinates to OS coordinates.
virtual Matrix	ConstructScaledRenderingMatrix (Spread *pSpread, double ScaleFactor)
	Create a rendermatrix at ScaleFactor precision of the current Scale Allows you to create a bitmap with higher/lower resolution than the current view eg used to create a bitmap of a given invalid region at double the current zoom factor (ie synonymous concept to "double resolution" or "double DPI").
FIXED16	GetPixelWidth ()
	Get the width of a pixel in this view.
FIXED16	GetPixelHeight ()
	Get the height of a pixel in this view.
void	GetPixelSize (FIXED16 *PixelWidth, FIXED16 *PixelHeight)
	Get the size of a pixel in this view.
virtual void	SetPixelSize (FIXED16 PixelWidth, FIXED16 PixelHeight)
	Set the size of a pixel in this view.
FIXED16	GetScaledPixelWidth ()
	Get the width of a scaled pixel in this view.
FIXED16	GetScaledPixelHeight ()
	Get the height of a scaled pixel in this view.
void	GetScaledPixelSize (FIXED16 *PixelWidth, FIXED16 *PixelHeight)
	Get the size of a scaled pixel in this view.
virtual void	SetScaledPixelSize (FIXED16 PixelWidth, FIXED16 PixelHeight)
	Set the size of a scaled pixel in this view.
virtual double	GetConvertToEditableShapesDPI ()
	Allows derived view classes to override the reolution.
ColourContext *	GetColourContext (ColourModel Model, BOOL ReturnNULLIfNone=FALSE)
	To find an appropriate colour context in the given colour model for use when rendering into this view. This allows us to control colour separation and correction down to a per-view level.
ColourPlate *	GetColourPlate (void)
	To find out what colour separation options are currently in use by this view.
void	SetColourPlate (ColourPlate *NewPlate, BOOL bSendContextChanged=TRUE)
	Sets a new colour plate (colour separation description for this view. Any future requests for colour contexts for this view (e.g. the next time it is redrawn, etc) will return a ColourContext using this new ColourPlate.
void	SetColourContext (ColourModel Model, ColourContext *NewContext=NULL)
	Sets a new colour context for this view.
BOOL	GetForceDefaultColourContexts (void)
BOOL	SetForceDefaultColourContexts (BOOL bForceDefault=TRUE)
WorkCoord	GetScrollOffsets () const
	To find the position of the top left corner of the display.
virtual BOOL	SetScrollOffsets (WorkCoord, BOOL RedrawNeeded=TRUE)
	To scroll this view to a new position over the document. The coordinate supplied is the coordinate of the top left corner of the viewport onto the document. The RedrawNeeded flag is TRUE when any invalid areas created should be redrawn immediately and FALSE if they should be ignored.
FIXED16	GetViewScale () const
	Inquire the viewing scale factor from this View.
virtual BOOL	SetViewScale (FIXED16)
	Set the viewing scale factor for this view. (Also, sets up the scaled pixel size in DocCoord if this View is current.
virtual DocRect	GetDocViewRect (Spread *)=0
virtual void	SetExtent (DocCoord, DocCoord)=0
virtual WorkRect	GetViewRect ()=0
Static Public Member Functions
static void	Deinit ()
	De-initialises the view system. At the moment this involves destroying our PaperRenderRegion.
static View *	GetCurrent ()
	Find the current View object which SHOULD have been set as one of the very first actions during event processing.
static void	SetNoCurrent ()
	Set the current View pointer to be NULL, i.e., there is no current View object.
static void	DeInitOnTopRegion ()
	Deinitialises the static OnTop RenderRegion, used for blob rendering.
static BOOL	IsPrintableNodeSelected (Node *)
	Determine whether a given node should be rendered when we are printing with "selected objects only" enabled. It checks to see if the node is bounded - if it isn't, then it's an attribute or similar and so is always rendered. If it is bounded then return TRUE if it is selected or if it is the child of a selected object. Otherwise we return FALSE to indicate that it should not be printed.
Public Attributes
Quality	RenderQuality
Protected Member Functions
virtual void	RenderPaper (RenderRegion *, Spread *)
	To render the parts of a Document which are not rendered when printing. Ie. all the parts of the document that represent the paper on which the ink will be rendered. This function does not take any notice of the RenderControl object - it renders until it has finished so that at least the pages, pasteboard, etc. will be drawn when any region is invalidated.
SlowJobResult	RenderSimpleNodes (Node *pNode, RenderRegion *pRender, ProgressDisplay &Progress, Node *pLastComplexNode=NULL)
	Function to render nodes 'normally' during 3-pass rendering. This copes with stopping at the specified last complex node, and with only printing selected objects if the user has requested it.
SlowJobResult	RenderSimpleNodesUnclipped (Node *pNode, RenderRegion *pRender, ProgressDisplay &Progress, Node *pLastComplexNode=NULL)
	Function to render nodes 'normally' during 3-pass rendering. This copes with stopping at the specified last complex node, and with only printing selected objects if the user has requested it.
RenderRegion *	NewRenderRegion (DocRect InvalidRect, Matrix &ViewMatrix, wxDC *pDevContext, Spread *pSpread, RenderType rType, bool fOwned=false)
virtual void	MakeNewRenderRegion (Spread *, DocRect, wxDC *, RenderType, BOOL PaintPaper=FALSE, Node *pInvalidNode=NULL)
	Makes a new render region and adds it to the list associated with the DocView. Depending on the type of render region requested, it may be rendered to completion immediately (e.g. print regions are). Note that if PaintPaper is FALSE, pDevContext isn't used, so can be NULL.
Protected Attributes
CCamView *	pViewWindow
Document *	pDoc
ViewState *	pVState
FIXED16	PixelWidth
FIXED16	PixelHeight
FIXED16	ScaledPixelWidth
FIXED16	ScaledPixelHeight
ColourPlate *	ColPlate
ColourContextArray	ColourContexts
BOOL	ShouldDeleteContext [16]
BOOL	ForceDefaultColourContexts
FIXED16	Scale
DocRect	PhysExtent
BOOL	m_bSolidDrag
Static Protected Attributes
static View *	Current = NULL
Private Member Functions
	CC_DECLARE_DYNAMIC (View)
Static Private Attributes
static PaperRenderRegion *	pPaperRegion = NULL
static PaperRenderRegion *	pOnTopRegion = NULL

---

Detailed Description

The basic kernel view item. This class contains minimal functionality to maintain the 'current' view, and the connection from a kernel view object to an OIL view object. DocView and PrintView are derived from this class.

Author:

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

Date:

02/07/95

See also:

DocView; PrintView

Definition at line 228 of file view.h.

---

Constructor & Destructor Documentation

View::View (   )

Initialise a View object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/23/95 See also: View Definition at line 180 of file view.cpp. { // No connections yet... pViewWindow = NULL; pDoc = NULL; pVState= NULL; // Actual size of OIL pixels that this view uses - default to 96dpi. PixelWidth = PixelHeight = FIXED16(72000.0 / 96); // Scaled size of OIL pixels that this view uses - default to scale of 100% ScaledPixelWidth = ScaledPixelHeight = PixelWidth; // View scale factor - default to 100% Scale = 1.0; // Initialise our ColourPlate and colour contexts to NULL pointers ForceDefaultColourContexts = FALSE; ColPlate = NULL; for (INT32 i = 0; i < (INT32) MAX_COLOURMODELS; i++) { ColourContexts.Context[i] = NULL; ShouldDeleteContext[i] = TRUE; } m_bSolidDrag = FALSE; }

View::~View (   )  [virtual]

Cleans up a view object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/23/95 See also: View Definition at line 222 of file view.cpp. { if (this == Current) SetNoCurrent(); // Decommission all colour contexts that we own ColourContextList *cclist = ColourContextList::GetList(); ERROR3IF( cclist == NULL, "No ColourContextList? What's up?" ); // Delete any old context we had in use (ignoring the ShouldDeleteContext flags) for (INT32 i = 0; i < (INT32) MAX_COLOURMODELS; i++) { if (ColourContexts.Context[i] != NULL) cclist->RemoveContext(&(ColourContexts.Context[i])); } if (ColPlate != NULL) delete ColPlate; if (pVState != NULL) { delete pVState; pVState=NULL; } }

---

Member Function Documentation

void View::AllocateDC (   )  [virtual]

Hints that we've done with our DC. Author: Alex Bligh <alex@alex.org.uk> Date: 12/06/2006 See also: View; PaperRenderRegion. Note this is merely a hint. This routine is not guaranteed to eb called Definition at line 261 of file view.cpp. { if (pViewWindow) pViewWindow->AllocateDC(); }

View::CC_DECLARE_DYNAMIC (  View   )  [private]

BOOL View::ConnectToOilView (  CCamView *  pOilView  )

To set up the bi-directional connection between the OIL view object and the View. The OIL view object causes the creation of the View and so already has a pointer to it when it calls this routine to set up the connection in the other direction. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/93 Parameters: Pointer  to view object in the OIL layer which we will mirror. [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 323 of file view.cpp. { ERROR2IF(this==NULL,FALSE,"View member func called on NULL pointer"); ERROR2IF(pViewWindow != NULL, FALSE, "View::ConnectToOilView called when connection already established"); pViewWindow = pOilView; return TRUE; }

Matrix View::ConstructRenderingMatrix (  Spread *  pSpread  )  [virtual]

From the given spread, construct a matrix that will convert spread coordinates to OS coordinates. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> & Rik Date: 10/12/93 Parameters: pSpread  - the spread that is to be rendered. [INPUTS] Returns: The required transformation matrix. See also: DocView::OnDraw Reimplemented in ExpressView, and PrintView. Definition at line 1113 of file view.cpp. { // Get the PIXELISED origin of spread coordinates, in document coords DocCoord SpreadCoordOrigin = pSpread->GetSpreadCoordOrigin(TRUE, this); // Convert it into logical Work Coords // NOTE: We convert this via the spread, because the Spread Coord Origin can now // lie *outside* the current chapter/spread pasteboard bounds, and so the version // of this call that takes a document pointer can't find the enclosing chapter! // Of course, we know the enclosing chapter, because this point is in a known spread! WorkCoord WorkCoordOffset = SpreadCoordOrigin.ToWork(pSpread, this); // Offset it by the window scroll position WorkCoordOffset.x -= pVState->GetScrollPos().x; WorkCoordOffset.y -= pVState->GetScrollPos().y; // Just in case the above hasn't work (the DocCoord conversion seems to produce some rounding // errors), Pixelize the offset WorkCoordOffset.Pixelise(72000.0/PixelWidth.MakeDouble(),72000.0/PixelHeight.MakeDouble()); // Construct the transformation matrix for the spread. Matrix RenderMatrix; // We can chop the 64bit values down to 32bit now, as we have them in the correct range Matrix TranslateToOrigin( (INT32)WorkCoordOffset.x, (INT32)WorkCoordOffset.y); Matrix ScaleMat(Scale, Scale); // The following matrix compositions MUST be performed in this order. // If you are tempted to optimise this code MAKE SURE THAT THEY ARE STILL // IN THIS ORDER WHEN YOU'VE FINISHED! // Apply scale factors to convert from millipoint distances to pixel distances... RenderMatrix *= ScaleMat; // Apply scroll-offset translation to move origin to viewing position... RenderMatrix *= TranslateToOrigin; return RenderMatrix; }

Matrix View::ConstructScaledRenderingMatrix (  Spread *  pSpread, double  ScaleFactor )  [virtual]

Create a rendermatrix at ScaleFactor precision of the current Scale Allows you to create a bitmap with higher/lower resolution than the current view eg used to create a bitmap of a given invalid region at double the current zoom factor (ie synonymous concept to "double resolution" or "double DPI"). Author: Ilan_Copelyn (Xara Group Ltd) <camelotdev@xara.com> Date: 06/06/00 Parameters: pSpread  = the spread that is to be rendered. [INPUTS] ScaleFactor = multiplier for current Scale (ie zoom factor) Returns: The required transformation matrix. See also: View::ConstructRenderingMatrix(Spread *pSpread) Definition at line 1171 of file view.cpp. { // Get the PIXELISED origin of spread coordinates, in document coords DocCoord SpreadCoordOrigin = pSpread->GetSpreadCoordOrigin(TRUE, this); // Convert it into logical Work Coords // NOTE: We convert this via the spread, because the Spread Coord Origin can now // lie *outside* the current chapter/spread pasteboard bounds, and so the version // of this call that takes a document pointer can't find the enclosing chapter! // Of course, we know the enclosing chapter, because this point is in a known spread! WorkCoord WorkCoordOffset = SpreadCoordOrigin.ToWork(pSpread, this); // Offset it by the window scroll position WorkCoordOffset.x -= pVState->GetScrollPos().x; WorkCoordOffset.y -= pVState->GetScrollPos().y; // Construct the transformation matrix for the spread. Matrix RenderMatrix; // We can chop the 64bit values down to 32bit now, as we have them in the correct range Matrix TranslateToOrigin( (INT32)WorkCoordOffset.x, (INT32)WorkCoordOffset.y); FIXED16 ScaledScale = Scale.MakeDouble() * ScaleFactor; Matrix ScaleMat(ScaledScale, ScaledScale); // The following matrix compositions MUST be performed in this order. // If you are tempted to optimise this code MAKE SURE THAT THEY ARE STILL // IN THIS ORDER WHEN YOU'VE FINISHED! // Apply scale factors to convert from millipoint distances to pixel distances... RenderMatrix *= ScaleMat; // Apply scroll-offset translation to move origin to viewing position... RenderMatrix *= TranslateToOrigin; return RenderMatrix; }

virtual void View::ContinueRenderView (  RenderRegion *  , Spread *  , BOOL  fRenderPaper = TRUE, BOOL  fDeleteRegionAfter = TRUE, BOOL  bForceImmediate = FALSE )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

void View::Deinit (  void   )  [static]

De-initialises the view system. At the moment this involves destroying our PaperRenderRegion. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/23/95 See also: View; PaperRenderRegion. Definition at line 298 of file view.cpp. { // Lose our PaperRenderRegion... delete pPaperRegion; delete pOnTopRegion; }

void View::DeInitOnTopRegion (   )  [static]

Deinitialises the static OnTop RenderRegion, used for blob rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 2/5/95 Definition at line 568 of file view.cpp. { if (pOnTopRegion) pOnTopRegion->DetachDevice(); }

void View::DoneWithDC (   )  [virtual]

Hints that we've done with our DC. Author: Alex Bligh <alex@alex.org.uk> Date: 12/06/2006 See also: View; PaperRenderRegion. Note this is merely a hint. This routine is not guaranteed to eb called Definition at line 280 of file view.cpp. { if (pViewWindow) pViewWindow->DoneWithDC(); }

ColourContext * View::GetColourContext (  ColourModel  Model, BOOL  ReturnNULLIfNone = FALSE )

To find an appropriate colour context in the given colour model for use when rendering into this view. This allows us to control colour separation and correction down to a per-view level. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/96 Parameters: Model  - The colour model of the context you want to find [INPUTS] ReturnNULLIfNone - if FALSE, an appropriate view will be found, by searching my parent document and global contexts if necessary. if TRUE, then if this view hasn't got it's own special context it will immediately return NULL. Returns: NULL, or a pointer to an appropriate context. Notes: This only functions for RGB and CMYK contexts at present. If you wish to render to a view using an output context of a different type, you will need to upgrade tios method. ONLY Use the returned pointer temporarily - If the view is deleted or if the ColourPlate options on the view are changed, the context will be deleted. You should thus always call this function to get the current Context - it's cached, and quick after the first call. See also: View::GetColourPlate; View::SetColourPlate; ColourContext; ColourManager Definition at line 1407 of file view.cpp. { // If our internal flag is set, we will return a default global colour context // This allows View::RenderOptimalBitmapPhase to create RenderRegions which will // not colour spearate or correct (as we want to do the correction as a post process // on the produced bitmap) if (ForceDefaultColourContexts) return(ColourManager::GetColourContext(Model, pDoc)); // Under normal circumstances, if we have a special ColourPlate, we look in our // cache for an appropriate context. First, we'll make sure an appropriate context // is cached (We don't do this if the caller specified ReturnNULLIfNone) if (!ReturnNULLIfNone && ColourContexts.Context[Model] == NULL && ColPlate != NULL) { // It's not cached yet - create a new context of this type ColourContext *NewCC = NULL; switch(Model) { case COLOURMODEL_RGBT: NewCC = new ColourContextRGBT(this); break; case COLOURMODEL_CMYK: NewCC = new ColourContextCMYK(this); break; default: ERROR3("View::GetColourContext only supports RGB/CMYK contexts at present"); break; } if (NewCC != NULL) { // Copy our ColourPlate ColourPlate *NewPlate = new ColourPlate(*ColPlate); if (NewPlate == NULL) { // Failure - delete the ColourContext and abandon the attempt delete NewCC; NewCC = NULL; } else { // Attach the ColourPlate to the context, add it into our cache of ColourContexts, // and add the new context to the context list NewCC->SetColourPlate(NewPlate); ColourContextList *cclist = ColourContextList::GetList(); ERROR3IF(cclist == NULL, "No ColourContextList? What's up?"); ColourContexts.Context[Model] = NewCC; cclist->AddContext(&(ColourContexts.Context[Model])); } } } // See if we've got a cached context we can return ColourContext *cc = ColourContexts.Context[Model]; // If we own our own colour context, then use it. Otherwise, find a suitable // context from our parent document; if that has none, then use a global default. // (We don't do this if the caller specified ReturnNULLIfNone) if (cc == NULL && !ReturnNULLIfNone) cc = ColourManager::GetColourContext(Model, pDoc); return(cc); }

ColourPlate * View::GetColourPlate (  void   )

To find out what colour separation options are currently in use by this view. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/96 Returns: NULL, or a pointer to the current ouptut ColourPlate See also: View::SetColourPlate; View::GetColourContext Definition at line 1495 of file view.cpp. { return(ColPlate); }

CCamView * View::GetConnectionToOilView (   )  const

To get a pointer to the OIL view object which mirrors this one. Note that this can return NULL if the View does not have a mirroring OIL object. In this case the view is closed but the View remains available so that in the future a new view will be able to use all of its viewing parameters. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/93 Returns: Pointer to the OIL view object which mirrors this one. Definition at line 350 of file view.cpp. { return pViewWindow; }

double View::GetConvertToEditableShapesDPI (   )  [virtual]

Allows derived view classes to override the reolution. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 18/08/2005 Returns: The resolution to use for convert top editable shapes operations while this view is current Reimplemented in XPFView. Definition at line 1343 of file view.cpp. { INT32 iPixPerInch = 0; if (!GetApplication()->GetConvertToEditableShapesDPI(&iPixPerInch)) { ERROR3("View::GetConvertToEditableShapesDPI; Couldn't get app's dpi"); iPixPerInch = 96; } return(iPixPerInch); }

View * View::GetCurrent (   )  [static]

Find the current View object which SHOULD have been set as one of the very first actions during event processing. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/93 Returns: Pointer to the current View object. Reimplemented in DocView. Definition at line 386 of file view.cpp. { #ifdef RALPH if(::GetCurrentThreadId() == RalphDocument::GetImportingThreadID()) { return RalphDocument::GetImportingDoc()->GetFirstDocView(); } #endif return Current; }

Document * View::GetDoc (   )  const

Returns the linake between this View and its Document. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/94 Returns: A pointer to the kernel Document associated with this View. Definition at line 368 of file view.cpp. { return pDoc; }

virtual DocRect View::GetDocViewRect (  Spread *   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

BOOL View::GetForceDefaultColourContexts (  void   )  [inline]

Definition at line 374 of file view.h. { return(ForceDefaultColourContexts); }

virtual BOOL View::GetForeBackMode (   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

FIXED16 View::GetPixelHeight (   )

Get the height of a pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/19/95 Returns: The pixel height for this view Definition at line 1238 of file view.cpp. { return PixelHeight; }

void View::GetPixelSize (  FIXED16 *  pPixelWidth, FIXED16 *  pPixelHeight )

Get the size of a pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/10/95 Parameters: pPixelWidth,pPixelHeight  - pixel size. [OUTPUTS] Definition at line 1254 of file view.cpp. { *pPixelWidth = PixelWidth; *pPixelHeight = PixelHeight; }

FIXED16 View::GetPixelWidth (   )

Get the width of a pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/19/95 Returns: The pixel width for this view Definition at line 1221 of file view.cpp. { return PixelWidth; }

PrintControl * View::GetPrintControl (   )

Simple way of getting the PrintControl object associated with this view's document. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/09/95 Returns: Pointer to the PrintControl object, or NULL if none found, or the view is not attached to a document. Errors: If no print control found => ERROR2 Definition at line 4172 of file view.cpp. { #ifndef STANDALONE if (pDoc == NULL) // This view is not attached to a document (e.g. it's a DialogView) return NULL; // Find print control object for this document, to see if we are // printing via bitmap, and so if we need to band the output. PrintComponent *pPrintComponent = (PrintComponent *) pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); ERROR2IF(pPrintComponent == NULL, NULL, "Unable to find PrintComponent object in document."); PrintControl *pPrintControl = pPrintComponent->GetPrintControl(); ERROR2IF(pPrintControl == NULL, NULL, "Unable to find PrintControl object in document component."); return pPrintControl; #else return NULL; #endif }

virtual wxDC* View::GetRenderDC (   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

FIXED16 View::GetScaledPixelHeight (   )

Get the height of a scaled pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/19/95 Returns: The scaled pixel height for this view Definition at line 1307 of file view.cpp. { return ScaledPixelHeight; }

void View::GetScaledPixelSize (  FIXED16 *  pScaledPixelWidth, FIXED16 *  pScaledPixelHeight )

Get the size of a scaled pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/10/95 Parameters: pScaledPixelWidth,pScaledPixelHeight  - scaled pixel size. [OUTPUTS] Definition at line 1323 of file view.cpp. { *pScaledPixelWidth = ScaledPixelWidth; *pScaledPixelHeight = ScaledPixelHeight; }

FIXED16 View::GetScaledPixelWidth (   )

Get the width of a scaled pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/19/95 Returns: The scaled pixel width for this view Definition at line 1290 of file view.cpp. { return ScaledPixelWidth; }

WorkCoord View::GetScrollOffsets (   )  const

To find the position of the top left corner of the display. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/93 Returns: Top left corner of the viewport in WorkCoords. Definition at line 1038 of file view.cpp. { ERROR2IF(this==NULL,WorkCoord(0,0),"View member func called on NULL pointer"); return pVState->GetScrollPos(); }

virtual WorkRect View::GetViewRect (   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

FIXED16 View::GetViewScale (   )  const

Inquire the viewing scale factor from this View. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Returns: Viewing scale factor for this view. Definition at line 1091 of file view.cpp. { return Scale; }

BOOL View::IsPrintableNodeSelected (  Node *  pNode  )  [static]

Determine whether a given node should be rendered when we are printing with "selected objects only" enabled. It checks to see if the node is bounded - if it isn't, then it's an attribute or similar and so is always rendered. If it is bounded then return TRUE if it is selected or if it is the child of a selected object. Otherwise we return FALSE to indicate that it should not be printed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/28/95 Parameters: pNode  - the node to check. [INPUTS] Returns: TRUE if the node should be printed; FALSE if not. See also: View::RenderSimpleNodes Definition at line 2228 of file view.cpp. { if (pNode->IsBounded()) { // We must check the selected status of this node. // Even if this node is not selected, its parent might be, so we // scan upwards until we find a layer, or a selected node. Node *pTestNode = pNode; while ((pTestNode != NULL) && (!pTestNode->IsSelected()) && (!pTestNode->IsLayer())) { pTestNode = pTestNode->FindParent(); } // If we failed to find a parent at some point then it can't possibly be selected if (pTestNode == NULL) return(FALSE); // If it is selected then we'd better print this node if (pTestNode->IsSelected()) return(TRUE); // If the original node is a shadow then we should test the right sibling // and print this node if that is selected if (pNode->IsAShadow()) { Node* pRightSibling = pNode->FindNext(); if (pRightSibling && pRightSibling->IsSelected()) return(TRUE); } // Fall back to not printing this node return(FALSE); // Ok, what did we find? // return ((pTestNode != NULL) && pTestNode->IsSelected()); } else { // It is a non-bounded node such as an attribute so we render it always. return TRUE; } }

void View::MakeNewRenderRegion (  Spread *  pSpread, DocRect  ClipRect, wxDC *  pDevContext, RenderType  rType, BOOL  PaintPaper = FALSE, Node *  pInvalidNode = NULL )  [protected, virtual]

Makes a new render region and adds it to the list associated with the DocView. Depending on the type of render region requested, it may be rendered to completion immediately (e.g. print regions are). Note that if PaintPaper is FALSE, pDevContext isn't used, so can be NULL. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: pSpread  - pointer to the spread concerned [INPUTS] ClipRect - Rectangle to create region from pDevContect - pointer to the device context for this region (may be NULL if PaintPaper == FALSE) rType - type of rendering PaintPaper - TRUE if paper should be redrawn immediately, FALSE otherwise (ignored for non-screen render regions). -  [OUTPUTS] Returns: - Reimplemented in PrintView. Definition at line 598 of file view.cpp. { // Construct the transformation matrix for the spread. Matrix RenderMatrix = ConstructRenderingMatrix(pSpread); // Go and create the new render region RenderRegion *NewRegion = NULL; if (pViewWindow != NULL) { // NewRegion = NewRenderRegion(ClipRect, RenderMatrix, GetRenderDC(), pSpread, rType); // GAT - Is it safe to change the above line to the one below? NewRegion = NewRenderRegion(ClipRect, RenderMatrix, pDevContext, pSpread, rType); } if (NewRegion == NULL) { TRACEALL( _T("Not enough memory to create render region\n") ); return; } if (rType == RENDERTYPE_SCREEN) { if (PaintPaper) { // Call helper function defined below RenderPaper(pSpread, ClipRect, pDevContext, RenderMatrix); } else { // Caller does not want paper to be rendered, so set the flag to indicate that // OS paper rendering is not needed. NewRegion->NeedsOSPaper = FALSE; } } NewRegion->SetBackmostChangedNode(pInvalidNode); // Add the region to the list of regions to render and start the // rendering process off if it has some ink to render Camelot.AddRenderRegion(NewRegion); }

RenderRegion * View::NewRenderRegion (  DocRect  InvalidRect, Matrix &  ViewMatrix, wxDC *  pDevContext, Spread *  pSpread, RenderType  rType, bool  fOwned = false )  [protected]

Definition at line 511 of file view.cpp. { RenderRegion *pNewRRegion; if (rType == RENDERTYPE_SCREENXOR) { if (pOnTopRegion == NULL) { // No OnTop rendering region - get a new render region of // the special type RENDERTYPE_SCREENPAPER. pOnTopRegion = (PaperRenderRegion *) NewRenderRegion(InvalidRect, ViewMatrix, pDevContext, pSpread, RENDERTYPE_SCREENPAPER, fOwned ); pOnTopRegion->SaveContext(); } else { // Change the device of the OnTop rendering region pOnTopRegion->AttachDevice(this, pSpread, pDevContext, ViewMatrix, Scale, InvalidRect, fOwned ); } pNewRRegion = pOnTopRegion; } else { // JCF: added 'this' argument to the end of the list. pNewRRegion = OSRenderRegion::Create(InvalidRect, ViewMatrix, Scale, rType, this); // If the construction was succesful then // Attach the new RenderRegion to a Window and its DC for rendering... if (pNewRRegion) { if (!pNewRRegion->AttachDevice(this, pDevContext, pSpread, fOwned)) { // the AttachDevice failed, so tidy up delete pNewRRegion; pNewRRegion = NULL; } } } return pNewRRegion; }

void View::OnDraw (  wxDC *  pDevContext, OilRect  OilClipRect )

Do the drawing, guv. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> & Rik & JustinF Date: 10/12/93 Parameters: pDevContext  - the device context of the view to render. [INPUTS] OilClipRect - the clipping rectangle of the invalid region (in OilCoords). Reimplemented in PrintView. Definition at line 899 of file view.cpp. { if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore // TRACE( _T("View::OnDraw\n") ); // TRACE( _T("Rect = (%d, %d, %d, %d)"), OilClipRect.lo.x, OilClipRect.lo.y, OilClipRect.hi.x, OilClipRect.hi.y ); // find type of rendering device const RenderType rType = CCDC::GetType(pDevContext, TRUE); // Convert OilClipRect to 64 bit WorkCoords WorkRect ClipRect = OilClipRect.ToWork(pVState->GetScrollPos()); //TRACE( _T("View::GetScrollPos : %d %d"),(INT32)(pVState->GetScrollPos().x/750),(INT32)(pVState->GetScrollPos().y/750)); //TRACE( _T("ClipRect : %d %d %d %d\n"),(INT32)(ClipRect.lo.x/750),(INT32)(ClipRect.lo.y/750),(INT32)(ClipRect.hi.x/750),(INT32)(ClipRect.hi.y/750)); ERROR3IF(ClipRect.lo.x > ClipRect.hi.x, "DocView::OnDraw clipping rect is invalid"); ERROR3IF(ClipRect.lo.y > ClipRect.hi.y, "DocView::OnDraw clipping rect is invalid"); // Use the last chapter as a sentinel. Chapter* pLastChapter = (Chapter*) pDoc->GetFirstNode()-> FindNext()->FindLastChild(CC_RUNTIME_CLASS(Chapter)); // Find all the spreads in the document that intersect the clipping rect, and create // a render region for each of them. // Iterate over the chapters in the document. for (Chapter* pChapter = Node::FindFirstChapter(pDoc); pChapter != 0; pChapter = pChapter->FindNextChapter()) { // Convert chapter bounding box to logical coords WorkRect LogChapterRect; DocRect PhysChapterRect = pChapter->GetPasteboardRect(TRUE, this); LogChapterRect.lo = PhysChapterRect.lo.ToWork(pDoc, this); LogChapterRect.hi = PhysChapterRect.hi.ToWork(pDoc, this); BOOL IsLastChapter = (pChapter == pLastChapter); // Check to see if this chapter intersects the clipping rectangle. // If the chapter is the last one in the document, then the chapter's pasteboard // does not include the area of the bottom of the last spread, so we only check // the chapter's top boundary. if (ClipRect.lo.y <= LogChapterRect.hi.y && (IsLastChapter || ClipRect.hi.y >= LogChapterRect.lo.y)) { // Find the last spread in the chapter. Spread* pLastSpread = (Spread*) pChapter->FindLastChild(CC_RUNTIME_CLASS(Spread)); // Iterate over the spreads in the chapter. for (Spread* pSpread = pChapter->FindFirstSpread(); pSpread != 0; pSpread = pSpread->FindNextSpread()) { // Convert spread bounding box to logical coords DocRect PhysSpreadRect = pSpread->GetPasteboardRect(TRUE, this); // Pixelised WorkRect LogSpreadRect; LogSpreadRect.lo = PhysSpreadRect.lo.ToWork(pSpread, this); LogSpreadRect.hi = PhysSpreadRect.hi.ToWork(pSpread, this); BOOL IsLastSpread = (pSpread == pLastSpread); // Check if spread intersects the clipping rect if (ClipRect.lo.y <= LogSpreadRect.hi.y && ((IsLastChapter && IsLastSpread) || ClipRect.hi.y >= LogSpreadRect.lo.y)) { // Make render region for intersection between spread and cliprect. DocRect SpreadClipRect = pSpread->GetWidePasteboard(this); // Convert clip rectangle to document coords DocRect DocClipRect = OilClipRect.ToDoc(pSpread, this); // Clip to spread rectangle SpreadClipRect = SpreadClipRect.Intersection(DocClipRect); // Make sure that the clip region is valid after the intersection if (SpreadClipRect.IsValid() && !SpreadClipRect.IsEmpty()) { // Convert document coords to spread coords and make a render region. pSpread->DocCoordToSpreadCoord(&SpreadClipRect); MakeNewRenderRegion(pSpread, SpreadClipRect, pDevContext, rType, TRUE); } } } } } // TRACE( _T("Leaving View::OnDraw\n") ); }

SlowJobResult View::RenderBitmapPhase (  DocRect &  ComplexClipRect, Matrix &  ViewTrans, Spread *  pSpread, RenderRegion *  pHostRegion, Node *  pFirstComplex, Node *  pLastComplex, BOOL  bRenderAll, BOOL  bPrintPaper, ProgressDisplay &  Progress )

This function is called from RenderSimpleView if it ends up having to do the 3 phase rendering system. This function performs the bitmap phase, where all the objects deemed to be complex by the Host render region are rendered into a bitmap using GDraw and a mono, mask bitmap. The bitmap is blitted into the host render region using the mask bitmap, minimising the amount of bitmaps ending up in the view (important for things like postscript that do not really like bitmaps very much). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/4/95 Parameters: ClipRect  - the clipping rectangle of the region [INPUTS] ViewTrans - the matrix to render through pSpread - The Spread we are drawing pHostRegion - The Render Region we are rendering on behalf of pFirstComplex - The first complex node that needs rendering pLastComplex - The last complex node that needs rendering Progress - the usual progress display object. Returns: TRUE if everything was fabby, FALSE if there was a problem See also: DocView::RenderSimpleView; ProgressDisplay Definition at line 3736 of file view.cpp. { #ifndef STANDALONE // TRACEUSER( "Gerry", _T("View::RenderBitmapPhase\n")); BOOL bIsOnScreen = pHostRegion->IS_KIND_OF(GRenderRegion); ERROR3IF(!bIsOnScreen && PrintMonitor::PrintMaskType==PrintMonitor::MASK_OPTIMAL, "PrintMaskType must be SIMPLE or MASKED here\n"); // This needs to be done in 2 phases - one to create the bitmap we will blit into the // host render region and one to create the mask to show us which parts of the bitmap // need to be blitted. First we will create the bitmap to blit into the host. // create the bitmap render region // CNativeDC* pDC = pHostRegion->GetRenderDC(); double Dpi; if (bIsOnScreen) { Dpi = (double) (72000.0 / PixelWidth.MakeDouble()); // Dpi = Dpi / 4.0; } else if (pHostRegion->IsPrinting()) { PrintControl *pPrintControl = GetPrintControl(); ERROR2IF(pPrintControl == NULL, SLOWJOB_FAILURE, "No print control in RenderBitmapPhase()"); Dpi = (double) pPrintControl->GetDotsPerInch(); } else if (IS_A(pHostRegion, CamelotEPSRenderRegion)) { // Use DPI as set in EPS export options dialog. Dpi = (double) EPSFilter::XSEPSExportDPI; } else { // Default to something reasonable (only really used for screens). Dpi = (double) (72000.0 / PixelWidth.MakeDouble()); } BOOL bDoScan = TRUE; if (bIsOnScreen) { // Now check the print method to determine if we need to do a three-pass render // Get document pointer Document* pDoc = GetDoc(); // Get print information for this document. PrintComponent *pPrint = (PrintComponent *) pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); if (pPrint) { PrintControl *pPrintControl = pPrint->GetPrintControl(); if (pPrintControl) { if (pPrintControl->GetPrintMethod() != PRINTMETHOD_NORMAL) { bDoScan = FALSE; } } } } // Check to see if we should do a masked blit. // We always do it under NT, or to a PostScript printer; under other conditions // we are controlled by the printing preference. BOOL DoMaskedBlit = FALSE; if (//IsWin32NT() || bIsOnScreen || (PrintMonitor::PrintMaskType==PrintMonitor::MASK_MASKED) || (CCDC::GetType(pHostRegion->GetRenderDC(), TRUE) == RENDERTYPE_PRINTER_PS) || IS_A(pHostRegion, CamelotEPSRenderRegion)) { DoMaskedBlit = TRUE; } // Work out the clip rect to use DocRect ClipRect = ComplexClipRect; ClipRect.Inflate((INT32)(2*72000.0/Dpi + 0.5)); // We will need the clip rect of the whole region too DocRect RClipRect = pHostRegion->GetRegionRect(); // pHostRegion->StopRender(); // During this function, we force the View::GetColourContext function to return default // global contexts to anyone who asks, in order to disable any attempts to // colour separate or correct the output (we want a normal composite bitmap which // will be colour corrected by the main render region when we call PlotBitmap, below) BOOL OldForceState = ForceDefaultColourContexts; ForceDefaultColourContexts = TRUE; // Create a new GDraw context so we don't have to keep stopping and starting our regions GDrawAsm TempContext; if (!TempContext.Init()) { ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } // Replace the static GDraw context with our temp one // GDrawContext* pOldGD = NULL; GDrawContext* pOldGD = GRenderRegion::SetTempDrawContext(&TempContext); if (pOldGD == NULL) { TRACEUSER( "Gerry", _T("NULL GDraw context returned from SetTempDrawContext\n")); } // Feathers require that the ScaleFactor of the render region be set correctly // or they will only render correctly at 100% FIXED16 TempScale; ViewTrans.Decompose(&TempScale, NULL, NULL, NULL, NULL); // Set it up GRenderBitmap BitmapRR(ClipRect, ViewTrans, TempScale, 32, Dpi); BitmapRR.AttachDevice(this, NULL, pSpread); // Update progress display if necessary. Progress.StartBitmapPhase(BitmapRR.GetNumBands()); // Also create a masked mono bitmap and Set them up MaskedRenderRegion MaskedBitmap(ClipRect, ViewTrans, TempScale, Dpi); MaskedBitmap.AttachDevice(this, NULL, pSpread); // ask for the bands to overlap BitmapRR.SetOverlapBands(TRUE); MaskedBitmap.SetOverlapBands(TRUE); // Start the first band if (!BitmapRR.SetFirstBand()) { ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } // in the masked region as well if (!MaskedBitmap.SetFirstBand()) { ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } INT32 CurrentBand = 0; // loop through all the available bands BOOL MoreBands = FALSE; do { CurrentBand++; // TRACEUSER( "Gerry", _T("Printing Band %d\n"),CurrentBand); // Start rendering into the bitmap if (!BitmapRR.StartRender()) { GRenderRegion::SetTempDrawContext(pOldGD); ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } // Should draw a big white rectangle here, into the bitmap render region or // transparent objects will not fade to white where you can see the paper under them DocRect DrawRect = ClipRect; // Inflate the rect by 2 pixels DrawRect.Inflate( (INT32)(2*72000.0/Dpi + 0.5) ); if (bPrintPaper) { BitmapRR.SaveContext(); RenderPaper(&BitmapRR, pSpread); BitmapRR.RestoreContext(); } else { // Draw it into the real bitmap BitmapRR.SaveContext(); DocColour white(255,255,255); BitmapRR.SetFillColour(white); BitmapRR.DrawRect(&DrawRect); BitmapRR.RestoreContext(); } // We anti-alias the transparency mask QualityAttribute *pAttr = new QualityAttribute(); pAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pAttr, TRUE); // BitmapRR.RRQuality.SetQuality(QUALITY_MAX); // BitmapRR.SetQualityLevel(); RRCaps HostCaps; pHostRegion->GetRenderRegionCaps(&HostCaps); SimpleBitmapRenderCallback ImageCallback(this, bRenderAll, pFirstComplex, pLastComplex, FALSE); BitmapRR.RenderTree(pSpread, FALSE, FALSE, &ImageCallback); // Stop rendering BitmapRR.StopRender(); // Start it up if (!MaskedBitmap.StartRender()) { GRenderRegion::SetTempDrawContext(pOldGD); ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } // Now, either we are rendering a masked bitmap, in which case we only want the complex // objects to render in the mask, or we are rendering the objects with a rectangular // bitmap, in which case we want *all* objects to render into the mask. if (DoMaskedBlit) { // Find out what the host can do pHostRegion->GetRenderRegionCaps(&HostCaps); } else { // Mark this region as not able to do anything, so the bitmap render region // will do everything for it (i.e. all objects will render into the mask). HostCaps.CanDoNothing(); } MaskedBitmap.SetHostCaps(&HostCaps); // Fill the mask in "simple" MaskedBitmap.SaveContext(); DocColour white(255,255,255); MaskedBitmap.SetFillColour(white); MaskedBitmap.DrawRect(&DrawRect); MaskedBitmap.RestoreContext(); if (!bDoScan) { HostCaps.CanDoNothing(); MaskedBitmap.SetHostCaps(&HostCaps); } SimpleBitmapRenderCallback MaskCallback(this, bRenderAll, pFirstComplex, pLastComplex, TRUE); MaskedBitmap.RenderTree(pSpread, FALSE, FALSE, &MaskCallback); // Tell the render region we are done rendering MaskedBitmap.StopRender(); // Make the mask a little bigger, to cover any errors from different dpis MaskedBitmap.SpreadMask(); // Get the mask bitmap from the render region // OILBitmap* pMaskBitmap = MaskedBitmap.ExtractBitmapCopy(); // KernelBitmap* pRealMaskBmp = new KernelBitmap(pMaskBitmap, TRUE); // pRealMaskBmp->AttachDebugCopyToCurrentDocument("TestMask"); // delete pRealMaskBmp; // Get the bitmaps from the render region OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); KernelBitmap* pRealBmp = new KernelBitmap(pFullBitmap, TRUE); // pRealBmp->AttachDebugCopyToCurrentDocument("TestBmp"); // Restore the ForceDefaultContext flag around the output rendering section ForceDefaultColourContexts = OldForceState; // Restore the original GDrawContext if (GRenderRegion::SetTempDrawContext(pOldGD) != &TempContext) { TRACEUSER( "Gerry", _T("Not &TempContext when restoring\n")); } pOldGD = NULL; // Now render the bitmap we have into the host render region. // if (pHostRegion->StartRender()) // { // Save the context pHostRegion->SaveContext(); // Render the bitmap using the mask DocRect BandClipRect = BitmapRR.GetClipRect(); // TRACE( _T("BandClipRect = (%d, %d) - (%d, %d)\n"), BandClipRect.lo.x, BandClipRect.lo.y, BandClipRect.hi.x, BandClipRect.hi.y); // TRACE( _T("BandMatrix = \n")); // Matrix HostMatrix = pHostRegion->GetMatrix(); // HostMatrix.Dump(); SlowJobResult Result = pHostRegion->DrawMaskedBitmap(BandClipRect, pRealBmp, &MaskedBitmap, &Progress); if (Result != SLOWJOB_SUCCESS) { // Either something has gone wrong, or an error has occured, so clean up. // Get rid of the bitmaps. We have to detach it once, as it was attached // when extracted from the render region. // pFullBitmap->Detach(); delete pRealBmp; pRealBmp = NULL; return Result; } // restore the context and stop rendering pHostRegion->RestoreContext(); // pHostRegion->StopRender(); // } ForceDefaultColourContexts = TRUE; // Make sure we are using the temporary GDrawContext pOldGD = GRenderRegion::SetTempDrawContext(&TempContext); if (pOldGD == NULL) { TRACEUSER( "Gerry", _T("NULL GDraw context returned from SetTempDrawContext\n")); } // get rid of the bitmaps. We have to detach it once, as it was attached when extracted from the rr // pFullBitmap->Detach(); delete pRealBmp; pRealBmp = NULL; // Ensure all captures are cleared before setting up next band. MaskedBitmap.FreeOffscreenState(); BitmapRR.FreeOffscreenState(); // Get the next bands ready BOOL MoreMaskedBands = MaskedBitmap.GetNextBand(); MoreBands = BitmapRR.GetNextBand(); CAM_USE(MoreMaskedBands); // suppress unused variable wanring on retail builds ERROR3IF(MoreMaskedBands!=MoreBands, "Bands don't match"); // Update progress display if (!Progress.EndBitmapPhaseBand()) { ForceDefaultColourContexts = OldForceState; // User has aborted operation return SLOWJOB_USERABORT; } } while (MoreBands); #endif // Restore the ForceDefaultContext flag ForceDefaultColourContexts = OldForceState; // Restore the original GDrawContext if (GRenderRegion::SetTempDrawContext(pOldGD) != &TempContext) { TRACEUSER( "Gerry", _T("Not &TempContext when restoring\n")); } pOldGD = NULL; // pHostRegion->StartRender(); // TRACEUSER( "Gerry", _T("End of View::RenderBitmapPhase\n")); // all worked return SLOWJOB_SUCCESS; }

SlowJobResult View::RenderOptimalBitmapPhase (  DocRect &  ClipRect, Matrix &  ViewTrans, Spread *  pSpread, RenderRegion *  pRender, Node *  pLastNormalInRun, Node *  pLastComplexInRun, BOOL  RenderAllObjects, BOOL  bPrintPaper, INT32 &  NodesSoFar, ProgressDisplay *  pProgress, INT32  TotalProgress )

Renders the masked bitmap part of the process. This function will get called many times during the typical rendering of the document (once for each run of complex nodes in the document). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 28/7/95 Parameters: ClipRect  - the Clipping rectangle [INPUTS] ViewTrans - the view matrix to use pSpread - the Spread to render to pRender - the host render region pLastNormalInRun - The last normal node in this run pLastComplexInRun - the last complex node in the run RenderAllObjects - TRUE if we render all objects, FALSE if its just the selection NodesSoFar - the number of nodes rendered so far Progress - the Progress display object NodesSoFar  - The Number of nodes rendered after the Complex ones have been done [OUTPUTS] Returns: SLOWJOB_SUCCESS - if all went well SLOWJOB_FAILURE - if all went bad SLOWJOB_USERABORT - if the user press 'esc' Notes: All rendering to the bitmap is done in composite colour (by ignoring the ColourPlate attached to this view). The bitmap is then plotted into the output RenderRegion, at which point it will be separated/corrected according to the ColourPlate settings. This is for 2 reasons: 1) If we didn't stop it here, the output would be colour corrected twice, and thus come out wrong 2) Bleach transparency does not work correctly on pre-separated colours, so we must render using composite colour in order to nmake such transparent objects come out correctly. Definition at line 2891 of file view.cpp. { TRACEUSER( "Gerry", _T("View::RenderOptimalBitmapPhase TotalProgress = %d\n"), TotalProgress); INT32 EndProgress = NodesSoFar + TotalProgress; // work out the DPI - this is a bit complicated really double Dpi = 96.0; if (!pRender->IS_KIND_OF(GRenderRegion) && pRender->IsPrinting()) { // we are printing, so ask the print options PrintControl *pPrintControl = GetPrintControl(); ERROR2IF(pPrintControl == NULL, SLOWJOB_FAILURE, "No print control in RenderOptimalView"); Dpi = (double) pPrintControl->GetDotsPerInch(); } else if (IS_A(pRender, CamelotEPSRenderRegion)) { // Use DPI as set in EPS export options dialog. Dpi = (double) EPSFilter::XSEPSExportDPI; } else { // Default to something reasonable (only really used for screens). Dpi = (double) (72000.0 / PixelWidth.MakeDouble()); } // Markn 27/10/95 // Scan the layers finding the union of the bounds of all the layers that should be rendered // This will be used to calc the Bitmap clip rect DocRect BitmapClipRect; Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { if (pLayer->NeedsToRender(pRender)) BitmapClipRect = BitmapClipRect.Union(pLayer->GetBoundingRect()); pLayer = pLayer->FindNextLayer(); } // Make sure that the BitmapClipRect does not incude an area that's not included in the entry ClipRect BitmapClipRect = BitmapClipRect.Intersection(ClipRect); // Now we make sure the clip rect is pixel aligned INT32 TempPixels; double dPixelWidth = 72000.0 / Dpi; if (BitmapClipRect.Width() < dPixelWidth || BitmapClipRect.Height() < dPixelWidth) { TRACE( _T("Very small rectangle\n")); } TempPixels = (INT32)(((double)BitmapClipRect.lo.x) / dPixelWidth); BitmapClipRect.lo.x = (INT32)(((double)TempPixels) * dPixelWidth); if (BitmapClipRect.Width() < dPixelWidth) BitmapClipRect.hi.x = (INT32)(BitmapClipRect.lo.x + dPixelWidth); TempPixels = (INT32)(((double)BitmapClipRect.lo.y) / dPixelWidth); BitmapClipRect.lo.y = (INT32)(((double)TempPixels) * dPixelWidth); if (BitmapClipRect.Height() < dPixelWidth) BitmapClipRect.hi.y = INT32(BitmapClipRect.lo.y + dPixelWidth); // Markn 26/10/95 // Find out if this render region is printing or not. // This is used as a param to the constructors of the bitmap-related render regions so that they // have the same printing state as the main render region. // If they don't, some nodes that shouldn't render when printing (e.g. background layers) will get // rendered into the bitmaps. BOOL Printing = pRender->IsPrinting(); // During this function, we force the View::GetColourContext function to return default // global contexts to anyone who asks, in order to disable any attempts to // colour separate or correct the output (we want a normal composite bitmap which // will be colour corrected by the main render region when we call PlotBitmap, below) BOOL OldForceState = ForceDefaultColourContexts; ForceDefaultColourContexts = TRUE; // Create a new GDraw context so we don't have to keep stopping and starting our regions GDrawAsm TempContext; if (!TempContext.Init()) { return SLOWJOB_FAILURE; } // Use the temporary GDrawContext GDrawContext* pOldGD = GRenderRegion::SetTempDrawContext(&TempContext); if (pOldGD == NULL) { TRACEUSER( "Gerry", _T("NULL GDraw context returned from SetTempDrawContext\n")); } // Feathers require that the ScaleFactor of the render region be set correctly // or they will only render correctly at 100% FIXED16 TempScale; ViewTrans.Decompose(&TempScale, NULL, NULL, NULL, NULL); // Also create a masked mono bitmap and Set them up PrintingMaskedRenderRegion MaskedBitmap(BitmapClipRect, ViewTrans, TempScale, Dpi, Printing); MaskedBitmap.AttachDevice(this, NULL, pSpread); // Create the colour Render Region as well GRenderBitmap BitmapRR(BitmapClipRect, ViewTrans, TempScale, 32, Dpi, Printing); BitmapRR.AttachDevice(this, NULL, pSpread); // ask for the bands to overlap BitmapRR.SetOverlapBands(TRUE); MaskedBitmap.SetOverlapBands(TRUE); // Start the first band in both of our renderregions if (!BitmapRR.SetFirstBand() || !MaskedBitmap.SetFirstBand()) { ForceDefaultColourContexts = OldForceState; return SLOWJOB_FAILURE; } // Count the nodes in this complex run // BOOL StartCounting = FALSE; INT32 TotalBands = MaskedBitmap.GetNumBands(); // Count the nodes to be rendered so we can calculate the increment to use if (!MaskedBitmap.StartRender()) { // Restore the ForceDefaultContext flag ForceDefaultColourContexts = OldForceState; GRenderRegion::SetTempDrawContext(pOldGD); return SLOWJOB_FAILURE; } // Find out what the host can do RRCaps HostCaps; pRender->GetRenderRegionCaps(&HostCaps); MaskedBitmap.SetHostCaps(&HostCaps); INT32 TotalNodes = 0; OptimalBitmapRenderCallback CountCallback(this, RenderAllObjects, pLastNormalInRun, pLastComplexInRun, TRUE, 0, &TotalNodes, pProgress, TRUE); MaskedBitmap.RenderTree(pSpread, FALSE, FALSE, &CountCallback); // Tell the render region we are done rendering MaskedBitmap.StopRender(); double NodesPerBand = 0.0; if (TotalBands != 0) NodesPerBand = ((double)TotalProgress) / ((double)TotalBands * 3.0); double NodeIncrement = 0.0; if (TotalNodes != 0) NodeIncrement = NodesPerBand / ((double) TotalNodes); // TRACEUSER( "Gerry", _T("TotalNodes - %ld\n"), TotalNodes); // TRACEUSER( "Gerry", _T("TotalBands - %ld\n"), TotalBands); // TRACEUSER( "Gerry", _T("NodesPerBand - %f\n"), NodesPerBand); // TRACEUSER( "Gerry", _T("NodeIncrement - %f\n"), NodeIncrement); INT32 CurrentBand = 0; // loop through all the available bands BOOL MoreBands = FALSE; do { // Update the current band variable CurrentBand++; // TRACEUSER( "Gerry", _T("Printing Band %d of %d\n"),CurrentBand,TotalBands); // Start it up if (!MaskedBitmap.StartRender()) { // Restore the ForceDefaultContext flag ForceDefaultColourContexts = OldForceState; GRenderRegion::SetTempDrawContext(pOldGD); return SLOWJOB_FAILURE; } // Find out what the host can do RRCaps HostCaps; pRender->GetRenderRegionCaps(&HostCaps); MaskedBitmap.SetHostCaps(&HostCaps); // Fill the mask in white DocRect DrawRect = ClipRect; // Inflate the rect by 2 pixels DrawRect.Inflate((INT32)(2*72000.0/Dpi + 0.5)); // Tell the masked render region that the following nodes are Simple MaskedBitmap.SetMaskDrawingMode(FALSE); MaskedBitmap.SaveContext(); DocColour white(255,255,255); MaskedBitmap.SetFillColour(white); MaskedBitmap.DrawRect(&DrawRect); MaskedBitmap.RestoreContext(); // Find out the size of the Region DocRect SizeOfRegion = MaskedBitmap.GetClipRect(); // start actually rendering nodes in to the mask. Just the ones in this // complex run are actually rendering solid into the mask. All other nodes, // before and after the run are punched out. double RegionArea = (double)SizeOfRegion.Width() * (double)SizeOfRegion.Height(); OptimalBitmapRenderCallback MaskCallback(this, RenderAllObjects, pLastNormalInRun, pLastComplexInRun, TRUE, RegionArea, &NodesSoFar, pProgress, FALSE, NodeIncrement); MaskedBitmap.RenderTree(pSpread, FALSE, FALSE, &MaskCallback); ENSURE(MaskedBitmap.GetCaptureDepth()==1, "Mask capture nesting not unwound correctly in RenderOptimalBitmapPhase\n"); // Tell the render region we are done rendering MaskedBitmap.StopRender(); // Make the mask a little bigger, to cover any errors from different dpis MaskedBitmap.SpreadMask(); #ifdef _DEBUG_ATTACH_OPTIMAL_MASK OILBitmap* pMaskBitmap = MaskedBitmap.ExtractBitmapCopy(); KernelBitmap* pRealMaskBmp = new KernelBitmap(pMaskBitmap, TRUE); pRealMaskBmp->AttachDebugCopyToCurrentDocument("TestMask"); delete pRealMaskBmp; #endif // Draw the colour bitmap if (MaskedBitmap.FindCoverage()>0) { // Start rendering into the bitmap { // Start the render region up. BOOL ok = BitmapRR.StartRender(); if (!ok) { // Restore the ForceDefaultContext flag ForceDefaultColourContexts = OldForceState; GRenderRegion::SetTempDrawContext(pOldGD); return SLOWJOB_FAILURE; } } // Should draw a big white rectangle here, into the bitmap render region or // transparent objects will not fade to white where you can see the paper under them // Draw it into the real bitmap if (bPrintPaper) { BitmapRR.SaveContext(); RenderPaper(&BitmapRR, pSpread); BitmapRR.RestoreContext(); } else { BitmapRR.SaveContext(); DocColour white(255,255,255); BitmapRR.SetFillColour(white); BitmapRR.DrawRect(&DrawRect); BitmapRR.RestoreContext(); } // We always anti-alias the bitmap output QualityAttribute *pAttr = new QualityAttribute(); pAttr->QualityValue.SetQuality(QUALITY_MAX); BitmapRR.SetQuality(pAttr, TRUE); OptimalBitmapRenderCallback ImageCallback(this, RenderAllObjects, pLastNormalInRun, pLastComplexInRun, FALSE, RegionArea, &NodesSoFar, pProgress, FALSE, NodeIncrement); BitmapRR.RenderTree(pSpread, FALSE, FALSE, &ImageCallback); ENSURE(BitmapRR.GetCaptureDepth()==1, "Bitmap capture nesting not unwound correctly in RenderOptimalBitmapPhase\n"); // Stop rendering BitmapRR.StopRender(); // Get the bitmaps from the render region OILBitmap* pFullBitmap = BitmapRR.ExtractBitmap(); KernelBitmap* pRealBmp = new KernelBitmap(pFullBitmap, TRUE); #ifdef _DEBUG_ATTACH_OPTIMAL_BITMAP pRealBmp->AttachDebugCopyToCurrentDocument("TestBmp"); #endif // Restore the ForceDefaultContext flag around the output rendering section ForceDefaultColourContexts = OldForceState; if (GRenderRegion::SetTempDrawContext(pOldGD) != &TempContext) { TRACEUSER( "Gerry", _T("Not &TempContext when restoring\n")); } pOldGD = NULL; // TRACE( _T("Rendering bitmap with mask\n")); // Save the context pRender->SaveContext(); // Render the bitmap using the mask DocRect BandClipRect = BitmapRR.GetClipRect(); SlowJobResult Result = pRender->DrawMaskedBitmap(BandClipRect, pRealBmp, &MaskedBitmap, NULL); if (Result != SLOWJOB_SUCCESS) { // Either something has gone wrong, or an error has occured, so clean up. // Get rid of the bitmaps. We have to detach it once, as it was attached // when extracted from the render region. // pFullBitmap->Detach(); delete pRealBmp; pRealBmp = NULL; return SLOWJOB_FAILURE; } // restore the context and stop rendering pRender->RestoreContext(); NodesSoFar += (INT32)NodesPerBand; if (pProgress) { if (!pProgress->SetNodesRendered(NodesSoFar)) { TRACE( _T("*****************************\n")); TRACE( _T("************ User aborted job\n")); TRACE( _T("*****************************\n")); } } ForceDefaultColourContexts = TRUE; // Use the temporary GDrawContext pOldGD = GRenderRegion::SetTempDrawContext(&TempContext); if (pOldGD == NULL) { TRACEUSER( "Gerry", _T("NULL GDraw context returned from SetTempDrawContext\n")); } // get rid of the bitmaps. We have to detach it once, as it was attached when extracted from the rr // pFullBitmap->Detach(); delete pRealBmp; pRealBmp = NULL; } else { // TRACEUSER( "Gerry", _T("No mask coverage\n")); NodesSoFar += (INT32)(NodesPerBand * 2.0); if (pProgress) { if (!pProgress->SetNodesRendered(NodesSoFar)) { TRACE( _T("*****************************\n")); TRACE( _T("************ User aborted job\n")); TRACE( _T("*****************************\n")); } } } // Ensure all captures are cleared before setting up next band BitmapRR.FreeOffscreenState(); // Get the next bands ready BOOL MoreMaskedBands = MaskedBitmap.GetNextBand(); TRACEUSER( "Phil", _T("GetNextBand (Before) %d, %d\n"), BitmapRR.GetClipRect().lo.y, BitmapRR.GetClipRect().hi.y); MoreBands = BitmapRR.GetNextBand(); TRACEUSER( "Phil", _T("GetNextBand (After) %d, %d\n"), BitmapRR.GetClipRect().lo.y, BitmapRR.GetClipRect().hi.y); ERROR3IF(MoreMaskedBands!=MoreBands, "Bands don't match"); if (MoreMaskedBands!=MoreBands) MoreBands = FALSE; } while (MoreBands); // Restore the ForceDefaultContext flag ForceDefaultColourContexts = OldForceState; if (GRenderRegion::SetTempDrawContext(pOldGD) != &TempContext) { TRACEUSER( "Gerry", _T("Not &TempContext when restoring\n")); } pOldGD = NULL; // All went well so makesure the progress is at the right point NodesSoFar = EndProgress; if (pProgress) pProgress->SetNodesRendered(NodesSoFar); TRACEUSER( "Gerry", _T("End of View::RenderOptimalBitmapPhase\n")); return SLOWJOB_SUCCESS; }

RenderViewResult View::RenderOptimalView (  RenderRegion *  pRender, Matrix &  ViewTrans, Spread *  pSpread, BOOL  PrintPaper )

This function has been designed along similar lines to the RenderView() function found elsewhere in this file. This version of the function is slightly different though. This version of the function is able to render complex objects, such as transparent objects into normal render regions. It does this by first scanning through all the objects that need rendering to see if any of them require complex things. If they do, then part of the rendering is done into a bitmap and blitted over the rest of the shapes using a masked blit. All very complicated really! This is the optimal version of this function, that will render individual complex shapes to the device instead of building them all up and blitting them in one go. This will produce the best quality results as as many objects as possible will be rendered to the resolution of the device. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/7/95 Parameters: pRender  - The render region to render into [INPUTS] ViewTrans - the transform matrix to use for the rendering pSpread - the spread to render PrintPaper - TRUE if the paper should be rendered as well Returns: RENDERVIEW_SUCCESS - view was rendered successfully RENDERVIEW_FAILURE - an error occured while rendering the view. RENDERVIEW_NOTNEEDED - the view was not rendered as the usual RenderView call can be used instead. RENDERVIEW_USERABORT - the user aborted the rendering operation. (e.g. pressing Escape, or aborting the print job) See also: DocView::RenderView Definition at line 2699 of file view.cpp. { // TRACEUSER( "Gerry", _T("View::RenderOptimalView\n")); ERROR3IF(PrintMonitor::PrintMaskType!=PrintMonitor::MASK_OPTIMAL, "PrintMaskType must be OPTIMAL here\n"); // Find out what the host render region is capable of RRCaps Caps; pRender->GetRenderRegionCaps(&Caps); // Whether or not the rendering was successful. RenderViewResult Result = RENDERVIEW_FAILURE; // Find out the Clipping rectangle of the render region to draw into DocRect ClipRect = pRender->GetClipRect(); BOOL Printing = pRender->IsPrinting(); // Create and set up a new Scanning render region ScanningRenderRegion Scanner(Printing); // Attach a device to the scanning render region // Since this rr does no real rendering, it does not need a Device context Scanner.AttachDevice(this, (CNativeDC*) NULL, pSpread); // Get it ready to render Scanner.SetMatrix(ViewTrans); Scanner.SetClipRect(ClipRect); // Start the render region and return if it fails if (Scanner.StartRender()) { // and tell the scanning render region about the caps of the host region Scanner.SetHostRRCaps(Caps); // Work out whether we need to render all objects, or just the selected ones. BOOL RenderAllObjects = TRUE; CCPrintInfo *pPrintInfo = NULL; if (Printing) { pPrintInfo = CCPrintInfo::GetCurrent(); if (pPrintInfo != NULL) { PrintControl *pPrCtrl = pPrintInfo->GetPrintControl(); RenderAllObjects = (pPrCtrl->GetObjPrintRange() == PRINTRANGEOBJ_ALL); } } // BOOL ReallyPrinting = Printing && (pPrintInfo != NULL); // We going to analyse the document if (pPrintInfo != NULL) pPrintInfo->SetAnalysing(); ScannerRenderCallback ScanCallback(this, RenderAllObjects, &Scanner); // Call RenderTree to do the rendering Scanner.RenderTree(pSpread, FALSE, TRUE, &ScanCallback); // Thats all the nodes rendered, so stop rendering Scanner.StopRender(); // Ok, we now have a Scanning render region that has all the info we need to know in it. #ifdef _DEBUG // Dump out the node span info // Scanner.DumpNodeRuns(); #endif // We going to print the document now if (pPrintInfo != NULL) pPrintInfo->SetPrinting(); // Set up the matrix and clipping rect pRender->SetMatrix(ViewTrans); pRender->SetClipRect(ClipRect); // Ask the render region not to render complex shapes pRender->SetRenderComplexShapes(FALSE); // Start the render region and get out if it fails if (!pRender->StartRender()) goto OptimalRenderError; // I think it likely we need to put something in here. if (Printing) { // Render the spreads paper marks where necessary RenderPageMarks(pRender, ViewTrans, ClipRect, pSpread); } // Draw the paper if we have been asked to do so. if (PrintPaper) { // Render all paper nodes from there into the real render region pRender->SaveContext(); RenderPaper(pRender, pSpread); pRender->RestoreContext(); if (pRender->NeedsOSPaper) { // This render region uses the OS to render paper, so if we don't // render anything except paper then there is no need for e.g. // GRenderRegions to blit anything. Hence we call this function // to clear the changed bbox. pRender->SetClean(TRUE, FALSE); } // The Paper is now done pRender->IsPaperRendered = TRUE; } ProgressDisplay Progress; Progress.SetUpOptimal(pRender, &Scanner); INT32 NodesRendered = 0; // TRACE( _T("Starting main render\n")); // We need to call RenderTree for the spread // We pass the ScanningRenderRegion to the RenderCallback object // so that it can tell which objects are normal and which are complex // We also pass the progress object so that can be updated OptimalPrintRenderCallback MyCallback(this, pSpread, RenderAllObjects, &Scanner, PrintPaper, &NodesRendered, &Progress, FALSE); pRender->RenderTree(pSpread, FALSE, FALSE, &MyCallback); MyCallback.FinishRendering(pRender); // Examine the callback object to see if anything went wrong // And stop rendering pRender->StopRender(); // All worked, so return success Result = RENDERVIEW_SUCCESS; } OptimalRenderError: #ifdef _DEBUG if (Result != RENDERVIEW_SUCCESS) TRACEUSER( "Gerry", _T("RenderOptimalView failed\n")); #endif // Unlink the RenderRegion from list and error if it was not there BOOL InList = Camelot.DeleteRenderRegion(pRender); CAM_USE(InList); // Suppress unused variable warning on retail build ERROR3IF(!InList, "DocView::RenderOptimalView tried to delete a RenderRegion not in the list"); // Instruct the render region to commit suicide. This call doesn't work on a CamelotEPS // render region. pRender->ConditionalSuicide (); // TRACEUSER( "Gerry", _T("End of View::RenderOptimalView\n")); return Result; }

BOOL View::RenderPageMarks (  RenderRegion *  pCurrRegion, Matrix &  ViewTrans, DocRect &  ClipRect, Spread *  pSpread )  [virtual]

Performs the rendering of page marks, ie crop marks, registration marks etc to the screen and printer. This base class version does nothing. All mark rendering technology is held in DocView and PrintView. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 08/08/96 Parameters: pSpread  - pointer to the spread concerned [INPUTS] ClipRect - Rectangle to create region from pDevContect - pointer to the device context for this region (may be NULL if PaintPaper == FALSE) RenderMatrix- the render matrix to use. rType - the type of render to give the region -  [OUTPUTS] Returns: - See also: DocView, PrintView Reimplemented in DocView. Definition at line 797 of file view.cpp. { #if !defined(EXCLUDE_FROM_RALPH) #ifndef STANDALONE /* // Ask the render region not to render complex shapes BOOL OldState = pCurrRegion->SetRenderComplexShapes(FALSE); // Create and set an identity matrix. We will cope with // the view transform later Matrix OldMatrix = pCurrRegion->GetMatrix(); Matrix Identity; // Work out the transformed clip rectangle onto the paper DocRect TransformedClipRect(ClipRect); ViewTrans.transform(&TransformedClipRect.lo); ViewTrans.transform(&TransformedClipRect.hi); MILLIPOINT Tmp; if (TransformedClipRect.lo.x > TransformedClipRect.hi.x) { Tmp = TransformedClipRect.lo.x; TransformedClipRect.lo.x = TransformedClipRect.hi.x; TransformedClipRect.hi.x = Tmp; } if (TransformedClipRect.lo.y > TransformedClipRect.hi.y) { Tmp = TransformedClipRect.lo.y; TransformedClipRect.lo.y = TransformedClipRect.hi.y; TransformedClipRect.hi.y = Tmp; } // pCurrRegion->SetMatrix(ViewTrans); pCurrRegion->SetClipRect(TransformedClipRect); pCurrRegion->SetMatrix(Identity); // Start the render region and return if it fails if (!pCurrRegion->StartRender()) { pCurrRegion->SetMatrix(OldMatrix); pCurrRegion->SetRenderComplexShapes(OldState); return FALSE; } */ // start a save context for attributes pCurrRegion->SaveContext(); if (pCurrRegion!=NULL && pSpread!=NULL) { if (!IS_A(pCurrRegion,PaperRenderRegion)) { // find this documents print mark component. Document* pDoc = (Document*)pSpread->FindOwnerDoc(); if (pDoc) { // ok, render all the print marks where necessary. PrintMarksMan* pMarksMan = GetApplication()->GetMarksManager(); if (pMarksMan!=NULL) { // find this documents print mark component. PrintMarksComponent* pMarksComp = (PrintMarksComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintMarksComponent)); if (pMarksComp != NULL) pMarksMan->RenderPrintMarks(pMarksComp, pCurrRegion, ViewTrans, ClipRect, pSpread); } } } } pCurrRegion->RestoreContext(); /* pCurrRegion->StopRender(); // Done rendering the print marks pCurrRegion->SetMatrix(OldMatrix); pCurrRegion->SetClipRect(ClipRect); pCurrRegion->SetRenderComplexShapes(OldState); */ #endif #endif return TRUE; }

void View::RenderPaper (  RenderRegion *  pRRegion, Spread *  pSpread )  [protected, virtual]

To render the parts of a Document which are not rendered when printing. Ie. all the parts of the document that represent the paper on which the ink will be rendered. This function does not take any notice of the RenderControl object - it renders until it has finished so that at least the pages, pasteboard, etc. will be drawn when any region is invalidated. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/93 Parameters: pRRegion  - The render region to draw in [INPUTS] pSpread - the spread to draw Scope: Private Definition at line 730 of file view.cpp. { // We always want paper to render to the same display quality level. pRRegion->SetDefaultQuality(); Node* pn = (Node*) pSpread; // First render all the paper nodes in the tree through the given RenderRegion... while (pn != NULL) { //TRACEUSER("Phil", _T("RenderPaper for %x - %x\n"), pSpread, pn); pn->Render(pRRegion); pn = pn->FindNextForClippedPaperRender(); } #ifndef STANDALONE // Render the printable area using the document's PrintControl object, but only if this // is a DocView & the ShowPrintBorder's flag is set if (GetRuntimeClass() == CC_RUNTIME_CLASS(DocView)) { DocView* pDocView = (DocView*)this; if (pDoc!=NULL) { if (pDocView->GetShowPrintBorders()) { PrintComponent* pPrComp = (PrintComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); if (pPrComp != NULL) { PrintControl* pPrCtrl = pPrComp->GetPrintControl(); if (pPrCtrl != NULL) pPrCtrl->RenderPrintBorder(pRRegion); } } } } #endif }

void View::RenderPaper (  Spread *  pSpread, DocRect  ClipRect, wxDC *  pDevContext, Matrix &  RenderMatrix )  [virtual]

Actually renders the paper onto the screen. Moved from 'MakeNewRenderRegion' so that it can be called from outside (eg. ResetRegion). Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 30/6/95 Parameters: pSpread  - pointer to the spread concerned [INPUTS] ClipRect - Rectangle to create region from pDevContect - pointer to the device context for this region (may be NULL if PaintPaper == FALSE) -  [OUTPUTS] Returns: - Definition at line 661 of file view.cpp. { // TRACE( _T("View::RenderPaper\n") ); if (pPaperRegion == NULL) { // No paper rendering region - get a new render region of // the special type RENDERTYPE_SCREENPAPER. pPaperRegion = (PaperRenderRegion *) NewRenderRegion(ClipRect, RenderMatrix, pDevContext, pSpread, RENDERTYPE_SCREENPAPER); // We save the context here, so that PaperRenderRegion::DetachDevice() can // throw away all the attributes. We only need to do it here because // PaperRenderRegion::AttachDevice() (see 2 inches below) calls SaveContext() // automagically. pPaperRegion->SaveContext(); } else { // Change the device of the paper rendering region pPaperRegion->AttachDevice(this, pSpread, pDevContext, RenderMatrix, Scale, ClipRect); } // Set up the rendering system. if (!pPaperRegion->StartRender()) { TRACEALL( _T("StartRender failed for paper in OnDraw\n") ); return; } // Render the paper objects using the permanent PaperRenderRegion. pPaperRegion->SaveContext(); RenderPaper(pPaperRegion, pSpread); pPaperRegion->RestoreContext(); pPaperRegion->StopRender(); pPaperRegion->DetachDevice(); // Draw the DragBlobs. Operation* pOp = Operation::GetCurrentDragOp(); if (pOp != NULL) pOp->RenderDragBlobs(ClipRect, pSpread, m_bSolidDrag); }

SlowJobResult View::RenderSimpleNodes (  Node *  pNode, RenderRegion *  pRender, ProgressDisplay &  Progress, Node *  pLastComplexNode = NULL )  [protected]

Function to render nodes 'normally' during 3-pass rendering. This copes with stopping at the specified last complex node, and with only printing selected objects if the user has requested it. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/25/95 Parameters: pNode  - the node to start rendering at. [INPUTS] pRender - the render region to render the nodes into. Progress - usual progress info object. pLastComplexNode - optional: if not NULL, then stop rendering when this node is reached, otherwise render to completion. Returns: SLOWJOB_SUCCESS if rendered ok; SLOWJOB_FAILURE if an error occured; SLOWJOB_USERABORT if the user intervened - e.g. pressed Escape. See also: ProgressInfo; View::RenderSimpleView Definition at line 2163 of file view.cpp. { #ifndef STANDALONE DocRect ClipRect = pRender->GetClipRect(); // Work out whether we need to render all objects, or just the selected ones. BOOL RenderAllObjects = TRUE; // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER if (pRender->IsPrinting()) { CCPrintInfo *pPrintInfo = CCPrintInfo::GetCurrent(); // ERROR2IF(pPrintInfo == NULL, SLOWJOB_FAILURE, "No print info while printing!"); if (pPrintInfo != NULL) { PrintControl *pPrCtrl = pPrintInfo->GetPrintControl(); RenderAllObjects = (pPrCtrl->GetObjPrintRange() == PRINTRANGEOBJ_ALL); } } #endif //webster // Render nodes into specified render region while ((pNode!=NULL) && (pNode != pLastComplexNode)) { if (pNode->IsRenderable() && (RenderAllObjects || IsPrintableNodeSelected(pNode))) { // Render the node that we have pNode->Render(pRender); // If progress display is needed, update it if it's time. if (!Progress.IncProgress()) return SLOWJOB_USERABORT; } // Find another one to render pNode = pNode->FindNextForClippedInkRender(&ClipRect, pRender); } // All ok return SLOWJOB_SUCCESS; #else return SLOWJOB_FAILURE; #endif }

SlowJobResult View::RenderSimpleNodesUnclipped (  Node *  pNode, RenderRegion *  pRender, ProgressDisplay &  Progress, Node *  pLastComplexNode = NULL )  [protected]

Function to render nodes 'normally' during 3-pass rendering. This copes with stopping at the specified last complex node, and with only printing selected objects if the user has requested it. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 08/03/2004 Parameters: pNode  - the node to start rendering at. [INPUTS] pRender - the render region to render the nodes into. Progress - usual progress info object. pLastComplexNode - optional: if not NULL, then stop rendering when this node is reached, otherwise render to completion. Returns: SLOWJOB_SUCCESS if rendered ok; SLOWJOB_FAILURE if an error occured; SLOWJOB_USERABORT if the user intervened - e.g. pressed Escape. See also: ProgressInfo; View::RenderSimpleView Definition at line 4114 of file view.cpp. { #ifndef STANDALONE // Work out whether we need to render all objects, or just the selected ones. BOOL RenderAllObjects = TRUE; // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER if (pRender->IsPrinting()) { CCPrintInfo *pPrintInfo = CCPrintInfo::GetCurrent(); // ERROR2IF(pPrintInfo == NULL, SLOWJOB_FAILURE, "No print info while printing!"); if (pPrintInfo != NULL) { PrintControl *pPrCtrl = pPrintInfo->GetPrintControl(); RenderAllObjects = (pPrCtrl->GetObjPrintRange() == PRINTRANGEOBJ_ALL); } } #endif //webster // Render nodes into specified render region while ((pNode!=NULL) && (pNode != pLastComplexNode)) { if (pNode->IsRenderable() && (RenderAllObjects || IsPrintableNodeSelected(pNode)) && pNode->NeedsToRender(pRender)) { // Render the node that we have pNode->Render(pRender); // If progress display is needed, update it if it's time. if (!Progress.IncProgress()) return SLOWJOB_USERABORT; } // Find another one to render pNode = pNode->FindNextForUnclippedInkRender(pRender); } // All ok return SLOWJOB_SUCCESS; #else return SLOWJOB_FAILURE; #endif }

RenderViewResult View::RenderSimpleView (  RenderRegion *  pRender, Matrix &  ViewTrans, Spread *  pSpread, BOOL  PrintPaper )  [virtual]

This function has been designed along similar lines to the RenderView() function found elsewhere in this file. This version of the function is slightly different though. This version of the function is able to render complex objects, such as transparent objects into normal render regions. It does this by first scanning through all the objects that need rendering to see if any of them require complex things. If they do, then part of the rendering is done into a bitmap and blitted over the rest of the shapes using a masked blit. All very complicated really! Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 10/4/95 Parameters: pRender  - The render region to render into [INPUTS] ViewTrans - the transform matrix to use for the rendering pSpread - the spread to render PrintPaper - TRUE if the paper should be rendered as well Returns: RENDERVIEW_SUCCESS - view was rendered successfully RENDERVIEW_FAILURE - an error occured while rendering the view. RENDERVIEW_NOTNEEDED - the view was not rendered as the usual RenderView call can be used instead. RENDERVIEW_USERABORT - the user aborted the rendering operation. (e.g. pressing Escape, or aborting the print job) See also: DocView::RenderView Definition at line 3473 of file view.cpp. { #ifndef STANDALONE // TRACEUSER( "Gerry", _T("View::RenderSimpleView\n")); BOOL bIsOnScreen = pRender->IS_KIND_OF(GRenderRegion); // if the preference says we should not be in this function then call the other function if (!bIsOnScreen && PrintMonitor::PrintMaskType==PrintMonitor::MASK_OPTIMAL) return RenderOptimalView(pRender, ViewTrans, pSpread, PrintPaper); // Find out what the host render region is capable of RRCaps Caps; pRender->GetRenderRegionCaps(&Caps); // Whether or not the rendering was successful. RenderViewResult Result = RENDERVIEW_FAILURE; // Find out the Clipping rectangle of the render region to draw into DocRect ClipRect = pRender->GetClipRect(); // Work out whether we need to render all objects, or just the selected ones. BOOL RenderAllObjects = TRUE; #ifndef WEBSTER CCPrintInfo *pPrintInfo = NULL; if (!bIsOnScreen && pRender->IsPrinting()) { pPrintInfo = CCPrintInfo::GetCurrent(); // ERROR2IF(pPrintInfo == NULL, RENDERVIEW_FAILURE, "No print info while printing!"); if (pPrintInfo != NULL) { PrintControl *pPrCtrl = pPrintInfo->GetPrintControl(); RenderAllObjects = (pPrCtrl->GetObjPrintRange() == PRINTRANGEOBJ_ALL); } } #endif //webster // Create and set up a new Scanning render region ScanningRenderRegion Scanner(pRender->IsPrinting()); BOOL bDoScan = TRUE; if (bIsOnScreen) { // Now check the print method to determine if we need to do a three-pass render // Get document pointer Document* pDoc = GetDoc(); // Get print information for this document. PrintComponent *pPrint = (PrintComponent *) pDoc->GetDocComponent(CC_RUNTIME_CLASS(PrintComponent)); if (pPrint) { PrintControl *pPrintControl = pPrint->GetPrintControl(); if (pPrintControl) { if (pPrintControl->GetPrintMethod() != PRINTMETHOD_NORMAL) { bDoScan = FALSE; } } } } // Declare some useful vars before the scanning chunk // Node* pFirstInkNode = NULL; // Node* pNode = NULL; if (bDoScan) { // Attach a device to the scanning render region // Since this rr does no real rendering, it does not need a Device context Scanner.AttachDevice(this, (CNativeDC *)NULL, pSpread); // Get it ready to render Scanner.SetMatrix(ViewTrans); Scanner.SetClipRect(ClipRect); // Start the render region and return if it fails if (!Scanner.StartRender()) return RENDERVIEW_FAILURE; // and tell the scanning render region about the caps of the host region Scanner.SetHostRRCaps(Caps); // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER // We going to analyse the document if (pPrintInfo != NULL) pPrintInfo->SetAnalysing(); #endif //webster // Find the first node to render // pFirstInkNode = pSpread->FindFirstForUnclippedInkRender(&Scanner); // Scanner.SetRenderState(pFirstInkNode); ScannerRenderCallback ScanCallback(this, RenderAllObjects, &Scanner); // Call RenderTree to do the rendering Scanner.RenderTree(pSpread, FALSE, FALSE, &ScanCallback); // Thats all the nodes rendered, so stop rendering Scanner.StopRender(); } // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER // We going to print the document now if (pPrintInfo != NULL) pPrintInfo->SetPrinting(); #endif //webster // Ok, we now have a Scanning render region that has all the info we need to know in it. // See if there were any complex shapes in the region // If we didn't do a scan then pretend there is one complex node /*INT32 NumComplex =*/ bDoScan ? Scanner.GetNumComplex() : 1; // Oh well, there are complex shapes to draw, so we had better do the comlpex thing pRender->SetMatrix(ViewTrans); pRender->SetClipRect(ClipRect); // Ask the render region not to render complex shapes pRender->SetRenderComplexShapes(FALSE); // Start the render region and return if it fails if (!pRender->StartRender()) return RENDERVIEW_FAILURE; // I think it likely we need to put something in here. if (pRender->IsPrinting()) { // Render the spreads paper marks where necessary RenderPageMarks(pRender, ViewTrans, ClipRect, pSpread); } // Draw the paper if we have been asked to do so. if (PrintPaper) { // Render all paper nodes from there into the real render region pRender->SaveContext(); RenderPaper(pRender, pSpread); pRender->RestoreContext(); if (pRender->NeedsOSPaper) { // This render region uses the OS to render paper, so if we don't // render anything except paper then there is no need for e.g. // GRenderRegions to blit anything. Hence we call this function // to clear the changed bbox. pRender->SetClean(TRUE, FALSE); } // The Paper is now done pRender->IsPaperRendered = TRUE; } // Find the first and last complex node in the document Node* pFirstComplexNode = Scanner.GetFirstComplexObject(); Node* pLastComplexNode = Scanner.GetLastComplexObject(); // Create and initialise the progress display. // (NB. we don't always do progress display, e.g. for screens we don't bother) ProgressDisplay Progress; // Progress.SetUp(pRender, &Scanner); INT32 NodesRendered = 0; // Find the first node to render // pFirstInkNode = pSpread->FindFirstForUnclippedInkRender(pRender); if (!bDoScan) { pFirstComplexNode = pSpread; pLastComplexNode = NULL; } TRACE( _T("pFirstComplexNode = 0x%08x\n"), pFirstComplexNode); TRACE( _T("pLastComplexNode = 0x%08x\n"), pLastComplexNode); // pRender->SetRenderState(pFirstInkNode); // Find out about the first node and the first complex node // pNode = pRender->GetRenderState(); // Check to see if we should do a masked blit. // We always do it under NT, or to a PostScript printer or EPS file; under other conditions // we are controlled by the printing preference. BOOL DoMaskedBlit = FALSE; if (//IsWin32NT() || bIsOnScreen || (PrintMonitor::PrintMaskType==PrintMonitor::MASK_MASKED) || (CCDC::GetType(pRender->GetRenderDC(), TRUE) == RENDERTYPE_PRINTER_PS) || IS_A(pRender, CamelotEPSRenderRegion)) { DoMaskedBlit = bDoScan; // Don't render simple phase if not scanning } SimplePrintRenderCallback MyCallback(this, pSpread, RenderAllObjects, &Scanner, DoMaskedBlit, PrintPaper, &NodesRendered, &Progress); pRender->RenderTree(pSpread, FALSE, FALSE, &MyCallback); pRender->StopRender(); // If we get here, it all worked Result = RENDERVIEW_SUCCESS; //ExitRenderSimpleView: // Unlink the RenderRegion from list and error if it was not there BOOL InList = Camelot.DeleteRenderRegion(pRender); ERROR2IF(!InList,RENDERVIEW_FAILURE,"DocView::RenderView tried to delete a RenderRegion not in the list"); // Instruct the render region to commit suicide. This call doesn't work on a CamelotEPS // render region. pRender->ConditionalSuicide (); // Finish progress bar for EPS export if (Result == RENDERVIEW_SUCCESS) Progress.AllStagesDone(); // TRACEUSER( "Gerry", _T("End of View::RenderSimpleView\n")); return Result; #else return RENDERVIEW_USERABORT; #endif }

virtual BOOL View::RenderTreeCallback (  Node *  pNode, RenderRegion *  pRender )  [inline, virtual]

Definition at line 281 of file view.h. {return TRUE;}

void View::SetColourContext (  ColourModel  Model, ColourContext *  NewContext = NULL )

Sets a new colour context for this view. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: Model  - The colour model of this context [INPUTS] NewContext - NULL to delete any existing context attached to this view, or a pointer to the new context to use. Any old attached context will be deleted. The new context is now "owned" by the view, which will delete it when it is finished with it. When we render to a view, an appropriate CMYK or RGB context is used for output, fetched by calling View::GetColourContext. Normally, the view will get a global default context, attach a copy of the View's ColourPlate (see View::SetColourPlate) to it, and return that. However, if you set a special context, this will be used instead of a global default. This is only currently used by the printing system to use a CMYK context which knows how to colour-correct separated output for the output printer device. Notes: Once given to a view, the ColourContext is "Owned" by the view, and will be deleted when the view is deleted, or when this function is called to set a different context active. Call this function with a NULL pointer to clear any existing ColourContext attached to the view. The View will attach the context to the global ColourContext list for you The View will always attach its own ColourPlate to the ColourContext that you pass in, overriding any ColourPlate you may have given it. (Implementation) The View keeps a special array of BOOLs next to its Array of contexts, which tell it whether the context in the cache is one created on demand by the view (which it can delete when the ColourPlate is changed) or one passed in by the caller (which should only be deleted on destruction or Context change) See also: View::SetColourPlate; View::GetColourPlate; View::GetColourContext Definition at line 1613 of file view.cpp. { ColourContextList *cclist = ColourContextList::GetList(); ERROR3IF(cclist == NULL, "No ColourContextList? What's up?"); if (ColourContexts.Context[Model] != NULL) cclist->RemoveContext(&(ColourContexts.Context[Model])); ColourContexts.Context[Model] = NewContext; ShouldDeleteContext[Model] = TRUE; // Reset the auto-delete flag by default if (NewContext != NULL) { ERROR3IF(Model != NewContext->GetColourModel(), "View::SetColourContext - Model must match colour context's model!"); ColourPlate *NewPlate = NULL; if (ColPlate != NULL) NewPlate = new ColourPlate(*ColPlate); // Attach our ColourPlate to the context, add it into our cache of ColourContexts, // and add the new context to the context list NewContext->SetColourPlate(NewPlate); cclist->AddContext(&(ColourContexts.Context[Model])); if (ColourContexts.Context[Model] != NULL) { // Instruct ourselves not to auto-delete this context from the cache ShouldDeleteContext[Model] = FALSE; } } }

void View::SetColourPlate (  ColourPlate *  NewPlate, BOOL  bSendContextChanged = TRUE )

Sets a new colour plate (colour separation description for this view. Any future requests for colour contexts for this view (e.g. the next time it is redrawn, etc) will return a ColourContext using this new ColourPlate. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/96 Parameters: NewPlate  - NULL (to remove any attached plate), or a pointer to a new [INPUTS] ColourPlate to use - (the existing COlourPLate attached to this view will be deleted, and replaced with a copy of this new ColourPlate) Notes: A copy is made of the ColourPlate object - you still own the one you lent us. See also: View::GetColourPlate; View::GetColourContext Definition at line 1525 of file view.cpp. { if (ColPlate != NULL) { delete ColPlate; ColPlate = NULL; } if (NewPlate != NULL) ColPlate = new ColourPlate(*NewPlate); // Wipe any cached colour contexts for the old ColourPlate ColourContextList *cclist = ColourContextList::GetList(); ERROR3IF(cclist == NULL, "No ColourContextList? What's up?"); for (INT32 i = 0; i < (INT32) MAX_COLOURMODELS; i++) { if (ColourContexts.Context[i] != NULL) { if (ShouldDeleteContext[i]) cclist->RemoveContext(&(ColourContexts.Context[i])); else { // We didn't cache this context, so we shouldn't delete it // Instead, we should just change it over to use the new ColourPlate ColourPlate *NewPlate = NULL; if (ColPlate != NULL) NewPlate = new ColourPlate(*ColPlate); // Attach the ColourPlate to the context - even if it is NULL this is safe ColourContexts.Context[i]->SetColourPlate(NewPlate); } } } // And if necessary, inform everybody that the colour separation options for // the selected view have been changed if (bSendContextChanged && this == DocView::GetSelected()) ColourManager::SelViewContextHasChanged(); }

BOOL View::SetCurrent (   )

Make this object be the 'current' View. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/93 Returns: TRUE if function set current correctly FALSE otherwise (then an Error has been set) Reimplemented in DocView. Definition at line 411 of file view.cpp. { #ifdef RALPH // if we are being called from the load thread just ignore if(::GetCurrentThreadId() == RalphDocument::GetImportingThreadID()) return TRUE; #endif if (Current!=this) { Current = this; if (this != NULL) { SetViewPixelSize(); if (pDoc != NULL) pDoc->SetCurrent(); } } return TRUE; }

virtual void View::SetExtent (  DocCoord  , DocCoord  )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

BOOL View::SetForceDefaultColourContexts (  BOOL  bForceDefault = TRUE  )  [inline]

Definition at line 376 of file view.h. { BOOL bOldForce = ForceDefaultColourContexts; ForceDefaultColourContexts = bForceDefault; return(bOldForce); }

virtual void View::SetForeBackMode (  BOOL   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

void View::SetNoCurrent (   )  [static]

Set the current View pointer to be NULL, i.e., there is no current View object. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/93 Reimplemented in DocView. Definition at line 446 of file view.cpp. { #ifdef RALPH // if we are being called from the load thread just ignore if(::GetCurrentThreadId() == RalphDocument::GetImportingThreadID()) return ; #endif // Set no current View or Document. Current = NULL; Document::SetNoCurrent(); }

void View::SetPixelSize (  FIXED16  NewPixelWidth, FIXED16  NewPixelHeight )  [virtual]

Set the size of a pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/10/95 Parameters: PixelWidth,PixelHeight  - new pixel size to use. [INPUTS] Definition at line 1272 of file view.cpp. { PixelWidth = NewPixelWidth; PixelHeight = NewPixelHeight; }

void View::SetScaledPixelSize (  FIXED16  NewScaledPixelWidth, FIXED16  NewScaledPixelHeight )  [virtual]

Set the size of a scaled pixel in this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/10/95 Parameters: NewScaledPixelWidth,NewScaledPixelHeight  - new scaled pixel size to use. [INPUTS] Definition at line 1367 of file view.cpp. { ScaledPixelWidth = NewScaledPixelWidth; ScaledPixelHeight = NewScaledPixelHeight; }

BOOL View::SetScrollOffsets (  WorkCoord  NewTopLeft, BOOL  RedrawNeeded = TRUE )  [virtual]

To scroll this view to a new position over the document. The coordinate supplied is the coordinate of the top left corner of the viewport onto the document. The RedrawNeeded flag is TRUE when any invalid areas created should be redrawn immediately and FALSE if they should be ignored. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/93 Parameters: New  scroll offsets [INPUTS] Flag to control whether redraw is needed or not Reimplemented in DocView. Definition at line 1008 of file view.cpp. { // TRACE(_T("View::SetScrollOffsets(%d, %d)\n"), (INT32)(NewTopLeft.x), (INT32)(NewTopLeft.y)); ERROR2IF(this==NULL,FALSE,"View member func called on NULL pointer"); //Graham 7/12/97: Downgraded to an error 3, otherwise this can go off in retail builds if (NewTopLeft.x < (XLONG)0 || NewTopLeft.y > (XLONG)0) { ERROR3("View::SetScrollOffsets - invalid parameters"); return FALSE; } pVState->SetScrollPos(NewTopLeft); // Set the new scroll offsets return TRUE; }

virtual void View::SetViewPixelSize (   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

BOOL View::SetViewScale (  FIXED16  NewScale  )  [virtual]

Set the viewing scale factor for this view. (Also, sets up the scaled pixel size in DocCoord if this View is current. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Parameters: New  view scale factor [INPUTS] Reimplemented in DocView. Definition at line 1059 of file view.cpp. { ERROR2IF(this==NULL,FALSE,"View member func called on NULL pointer"); ERROR2IF(pVState==NULL,FALSE,"View not connected to ViewState"); // Set the new scale pVState->ViewScale = Scale = NewScale; // Set up the scaled pixel size for this view according to new scale. SetViewPixelSize(); // Inform the Viewstate that it has been changed and that the doc extent may // need to be recomputed... ViewStateChanged(); return TRUE; }

void View::SetViewState (  ViewState *  pvs  )  [virtual]

Sets the structure which is shared by both View and the OIL view object to which it is connected. NB. PrintViews do NOT share the ViewState with the OIL view, because the OIL view is the screen based view, so the PrintView is the only one that needs to use the view state. The CCamView always uses the ViewState of its DocView, not its PrintView. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/93 Returns: A pointer to the ViewState object associated with this View. Definition at line 476 of file view.cpp. { ERROR3IF(pvs == NULL, "View::SetViewState called with a null parameter!"); // Justin here: removed this ERROR3 because it stops the workspace restoration code // working. This is a temp fix, just for the 1.1 release. What we need is a function // that allows you to *change* the ViewState this View refers to, and unfortunately // the effect of these two ERROR3's is to make that impossible, as you can't pass a new // ViewState, or set th existing one to null. // ERROR3IF(pVState != NULL, "View::SetViewState called when view already has a view state."); pVState = pvs; // Inform the ViewState object which view it is describing. pVState->pView = this; }

virtual BOOL View::ViewStateChanged (   )  [pure virtual]

Implemented in DocView, ExpressView, PrintView, XPFView, ClipboardView, DialogView, and MetafileView.

---

Member Data Documentation

ColourContextArray View::ColourContexts [protected]

Definition at line 385 of file view.h.

ColourPlate* View::ColPlate [protected]

Definition at line 384 of file view.h.

View * View::Current = NULL [static, protected]

Definition at line 260 of file view.h.

BOOL View::ForceDefaultColourContexts [protected]

Definition at line 388 of file view.h.

BOOL View::m_bSolidDrag [protected]

Definition at line 418 of file view.h.

Document* View::pDoc [protected]

Definition at line 242 of file view.h.

DocRect View::PhysExtent [protected]

Definition at line 400 of file view.h.

FIXED16 View::PixelHeight [protected]

Definition at line 350 of file view.h.

FIXED16 View::PixelWidth [protected]

Definition at line 350 of file view.h.

PaperRenderRegion * View::pOnTopRegion = NULL [static, private]

Definition at line 313 of file view.h.

PaperRenderRegion * View::pPaperRegion = NULL [static, private]

Definition at line 310 of file view.h.

CCamView* View::pViewWindow [protected]

Definition at line 241 of file view.h.

ViewState* View::pVState [protected]

Definition at line 243 of file view.h.

Quality View::RenderQuality

Definition at line 283 of file view.h.

FIXED16 View::Scale [protected]

Definition at line 399 of file view.h.

FIXED16 View::ScaledPixelHeight [protected]

Definition at line 354 of file view.h.

FIXED16 View::ScaledPixelWidth [protected]

Definition at line 354 of file view.h.

BOOL View::ShouldDeleteContext[16] [protected]

Definition at line 386 of file view.h.

---

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

• Kernel/view.h (r1785/r1323)
• Kernel/view.cpp (r1785/r1357)

---