DocView Class Reference

The DocView class is used to hold non-oil data about views onto a document. When a CCamView object exists there is always a DocView object on the other side of the OIL- interface and they are linked. However, the DocView object is not destroyed when the CCamView object is destroyed so that it records the state of views while they are closed. More...

#include <docview.h>

Inheritance diagram for DocView:

List of all members.

Public Member Functions
	DocView (Document *)
	DocView class constructor A DocView object is usually created by the Document and is linked into a list of DocViews owned by the Document. So the DocView constructor takes and stores a pointer to the Document object so that it can get to it quickly.
virtual	~DocView ()
	DocView class destructor.
BOOL	Init ()
	Init a doc view.
void	OnNewView ()
	Called by CCamView as part of its "initial update" function provided that this view onto a document has not been previously saved and reloaded. Sets the defaults, eg. scroll offset, for newly created views.
void	OnLoadedView ()
	Called by CCamView as part of its "initial update" function provided that this view onto a document has been previously saved and reloaded. Currently does nothing, but one day - who knows.
BOOL	SetCurrent ()
	Make this object be the 'current' DocView.
virtual void	SetViewPixelSize ()
	Sets up the normal and scaled pixel sizes according to this view.
virtual CNativeWnd *	GetRenderWindow ()
	Get a pointer to a CNativeWnd window object associated with a DocView.
BOOL	StartDrag (Operation *, DragType, DocRect *pMoveBBox, DocCoord *StartPos, BOOL KeepAccuracy, BOOL bSolidDragSupported=FALSE)
	Tells the world that a drag is starting.
BOOL	EndDrag (Operation *)
	Tell the oil layer that the drag has finished.
BOOL	ChangeDragType (DragType Type)
	Change the type of drag during the middle of a drag. This can only be called if there is a drag already happening (ie between calls to StartDrag and EndDrag).
void	DragPointerMove (Operation *, OilCoord, ClickModifiers)
	Tell the current dragging operation that the pointer has moved. This function is ony called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called.
void	DragPointerIdle (Operation *, OilCoord, ClickModifiers)
	Tell the current dragging operation that the pointer has NOT moved and that there is idle CPU time to be used. This function is only called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called.
void	DragFinished (Operation *, OilCoord, ClickModifiers, BOOL)
	Tell the current dragging operation that the drag has ended either because the pointer buttons have all been released or the drag has been aborted in some way (Escape was pressed?). This function is ony called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called.
BOOL	IsSingleClickReallyTriple () const
	For determining wether the current single click event is really a triple click It only makes sense to call this when you are processing a click event!
BOOL	IsSingleClickReallyQuad () const
	For determining wether the current single click event is really a quad click It only makes sense to call this when you are processing a click event!
void	OnMouseMove (OilCoord, ClickModifiers)
	Converts the mouse position into document coordinates, then calls the OnMouseMove() function of the currently selected tool with this information.
void	OnClick (OilCoord, ClickType, ClickModifiers)
	Convert click coordinates into DocCoords and pass them on to the current tool.
void	RenderSelectBlobs (DocRect Rect, Spread *pSpread)
	Renders the Selection blobs of all the currently selected objects.
BOOL	IsMouseMoved ()
	This function finds out if the mouse has moved yet. This is only really useful if you are doing some processing as a result of a mouse move event. If, in the middle of your processing, you discover that the mouse has moved again, you may be able to stop processing immediatly and wait for the next mouse event to arrive in the not too distant future.
WorkCoord	GetClickWorkCoord ()
	To let people know where the last click was in Work Coordinates.
ObjectDragTarget	IsPointerOverNode (NodeRenderableInk **ThisNode, INT32 Range, BOOL Interrupt=TRUE, BOOL bColourDrag=FALSE)
	to determine whether pointer is over 1 - an objects outline 2 - any visible fill blobs 3 - a simple (non grouped) object
BOOL	DM_DragFinished (DragInformation *DragInfo, ViewDragTarget *pDragTarget)
	act at the end of a general drag according to the drag type.
void	SetSolidDragState (BOOL bNewState)
BOOL	GetCurrentSolidDragAbility ()
BOOL	GetCurrentSolidDragState ()
void	ClearClickState ()
	Allows click handlers to reset the click logic if they are doing things that would break it.
virtual BOOL	HandleKeyPress (KeyPress *pKeyPress)
	Passes keystroke events to the current drag op, if dragging, or the current tool, if not.
void	ResetRenderingStartTime ()
BOOL	GetShowPrintBorders ()
void	SetShowPrintBorders (BOOL State)
Spread *	FindEnclosingSpread (OilCoord)
	Given a chapter and an OilCoord, finds the spread that contains the coordinate.
Spread *	OilToSpreadCoord (OilCoord, DocCoord *)
	Combines the functions of FindEnclosingSpread and OilCoord::ToDoc. Finds which spread an OilCoord is in and then computes the DocCoord of that position within the spread.
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. 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.
void	ContinueRenderView (RenderRegion *pRegion, Spread *pSpread, BOOL fRenderPaper=TRUE, BOOL fDeleteRegionAfter=TRUE, BOOL bForceImmediate=FALSE)
	To re-start rendering a Document through a given RenderRegion. This call is different from RenderView because it may need to re-compute the Doc to OS matrix.
void	RenderEntireView (RenderRegion *pRender, Spread *pSpread)
	To render a Document through a given RenderRegion. This differs from your regular RenderView service in that it pays no mind as to how long things take. Once you start this function off it will run until it renders the lot. The reason for this is that it is designed for use with the brush tool. Here we will need to render the entire view into an offscreen bitmap which is then used to with the brush. It serves as an alternative when we cannot simply blit the contents of the screen. I don't really recommend using this function in other circumstances as if you have a complex document it will probably lock up for a while.
virtual BOOL	GetForeBackMode ()
	To find out if background rendering is on.
virtual void	SetForeBackMode (BOOL)
	Set the background render flag for this view. Also sets the new value to be used as the default preference.
void	ForceRedraw (BOOL ForcePaper=FALSE)
	Force the entire view to be redrawn. NB. If you are redrawing because you have changed the zoom or scroll offsets, then you must pass in TRUE for ForcePaper!!! (Because (a) Otherwise our scroll offsets are invalid and the next time we scroll it gets mucked up, and (b) Scrolling or zooming should give instant feedback to the user.).
void	ForceRedraw (WorkRect &)
	Force a specific rectangle of the view to be redrawn.
void	ForceRedraw (Spread *, DocRect, BOOL Accumulate=FALSE, Node *pInvalidNode=NULL)
	Force redraw of an area of a spread.
void	FlushRedraw ()
	Intelligently invalidate all the regions gathered so far for this DocView. This performs smart invalidation depending on the number and nature of the regions.
void	HandleNodeDeletion (Node *pNode)
	Intelligently invalidate all the regions gathered so far for this DocView. This performs smart invalidation depending on the number and nature of the regions.
RenderRegion *	GetFirstRenderRegion (DocRect &, Spread *, OnTopCode Reason)
	RenderRegion's cannt span Spreads, because different Matrices are needed for the Coordinate transforms. This Function (Along with GetNext...) is used to Split a DocRect area into a number of RenderRegions depending on the number of spreads the DocRect spans. First call this function to return the first RenderRegion (there will always be at least one for a valid DocRect), and then call GetNextRenderRegion until it returns NULL (which may be immediately). Repeat the Rendering process for each RenderRegion returned. You do NOT need to call Init/Exit Render as they will be set up for Immediate rendering.
RenderRegion *	GetNextRenderRegion (DocRect &, Spread *, OnTopCode Reason)
	Used to split a DocRect to be redrawn into one or more RenderRegions. See DocView::GetFirstRenderRegion(DocRect& ClipRect) for more details.
void	ShowViewScrollers (BOOL fIsVisible)
	Pass on Show Hide Scrollers Message to CamView.
void	ShowViewRulers (BOOL fIsVisible)
	Pass on Show Hide Rulers Message to CamView.
BOOL	AreRulersVisible ()
BOOL	AreScrollersVisible ()
BOOL	SetViewScale (FIXED16 NewScale)
	Set the viewing scale factor for this view. (Also, sets up the scaled pixel size in DocCoord if this View is current.
BOOL	SetScrollOffsets (WorkCoord NewTopLeft, BOOL RedrawNeeded)
	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.
void	ScrollToShow (DocCoord *pCoord)
	Scrolls the currently selected document view to bring this coord into view. If this coord is already visible then we do nothing.
void	ScrollToShow (DocRect *RectToShow)
	Scrolls the currently selected view to ensure that as much as possible of RectToShow is visible. If the entire rect cannot be seen, then it will scroll the minimum distance in order to make a part of it visible.
void	ScrollToShow (DocRect *pBoundingBox, DocCoord Direction)
	Scrolls the currently selected view to ensure that edge(s) of pBoundingBox are visible. The Direction argument tells us which edges. If the movement was towards the top of the screen then we need to make the top edge of the DocRect visible.
void	ScrollToShowWithMargin (DocCoord *pCoord)
	Scrolls the currently selected view to show the coord; if the coord in already in view then we do nothing.
void	ScrollToShowWithMargin (DocRect *RectToShow)
	Scrolls the currently selected view to ensure that as much as possible of RectToShow is visible. If the entire rect cannot be seen, then it will scroll the minimum distance in order to make a part of it visible.
void	ScrollToShowWithMargin (DocRect *pBoundingBox, DocCoord Direction)
	Scrolls the current view to show parts of pBoundingBox. The edge(s) of pBoundingBox are determined by Direction, if we have moved objects towards the top of the screen then we need to ensure that the top edge of the DocRect is visible.
BOOL	ViewStateChanged ()
	Inform the DocView that the ViewState has been changed in some way. When this function detects a new ViewState object (IsNewView = TRUE) it sets the scroll offsets to the top left hand corner of the first page in the document.
DocRect	GetDocViewRect (Spread *)
	To find the rectangle describing the viewport onto the document.
void	SetExtent (DocCoord, DocCoord)
	Informs the DocView that the extent of the document has changed in some way and that the view must be altered to take this into account (namely the scrollbars).
WorkRect	GetViewRect ()
	To find the rectangle describing the viewport onto the document.
INT32	GetZoomTableIndex () const
void	SetZoomTableIndex (INT32 nIndex)
INT32	GetPrevZoomIndex () const
	Returns the index into the zoom tool's tabel of a previous zoom on this DocView.
void	SetPrevZoomIndex (INT32 nIndex)
	Sets the zoom table index of a previous zoom onto this DocView.
FIXED16	GetPrevZoomScale () const
void	SetPrevZoomScale (FIXED16 fxScale)
	Sets the scale factor this DocView will "remember" as a previous zoom.
WorkCoord	GetPrevZoomOffset () const
void	SetPrevZoomOffset (const WorkCoord &wcOffset)
	Sets the scroll offset this DocView will "remember" as a previous zoom.
BOOL	Snap (Spread *pSpread, DocCoord *pDocCoord, BOOL TryMagSnap=TRUE, BOOL TryGridSnap=TRUE)
	Allows you to easily snap a coord to something relevant in the given spread (e.g. to a grid, magnetic object, etc).
BOOL	Snap (Spread *pSpread, DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a rectangle to something relevant in the given spread (e.g. to a grid, magnetic object, etc).
BOOL	GetSnapToGridState ()
	To find the "Snap to grid" state of a DocView.
void	SetSnapToGridState (BOOL SnapToGrid)
	Allow you to change the "snap to grid" state of a DocView.
BOOL	GetShowGridState ()
	To find the "Show grid" state of a DocView.
void	SetShowGridState (BOOL ShowGrid)
	Allow you to change the "show grid" state of a DocView.
BOOL	GetSnapToObjectsState ()
	To find the "Snap to all objects" state of a DocView.
void	SetSnapToObjectsState (BOOL SnapToObjects)
	Allow you to change the "snap to all objects" state of a DocView.
BOOL	GetSnapToMagObjectsState ()
	To find the "Snap to magnetic objects" state of a DocView.
void	SetSnapToMagObjectsState (BOOL SnapToMagObjects)
	Allow you to change the "snap to magnetic objects" state of a DocView.
BOOL	GetSnapToGuidesState ()
void	SetSnapToGuidesState (BOOL State)
BOOL	GetShowGuidesState ()
void	SetShowGuidesState (BOOL State)
Spread *	GetVisibleSpread ()
	Compares the bounding rectangles of Spreads in this view's document with the section of the document currently visible in the view, looking for the largest spread object that is within the view. If none are visible then the function returns NULL.
Spread *	GetFirstSelectedSpread ()
	Searches for a selected object in the document, and returns a pointer to the spread containing said object. If there are no selected objects then it returns NULL.
RulerPair *	GetpRulerPair ()
DocCoord	GetCentreCoord ()
	Gets a DocCoord for the centre of the view.
ImportPosition	GetCentreImportPosition ()
	Gets an import position for the centre of the view.
DocCoord	GetTopLeftCoord ()
	Gets a DocCoord for the top left of the view.
ImportPosition	GetTopLeftImportPosition ()
	Gets an import position for the top left of the view.
double	GetZoomFactor ()
	Obtain the current zoom factor for this document view.
void	SetPreventRenderView (BOOL Value)
	To set our member variable that will prevent rendering of the view. As you might imagine this is something to be careful about.
BOOL	GetPreventRenderView ()
	As above.
void	NotifyBoundsChanged (BOOL bNewValue=TRUE)
Static Public Member Functions
static BOOL	DeclarePreferences ()
	Declares any preferences that the DocView class needs to decalre.
static DocView *	GetCurrent ()
	This function returns the parameters which control the transformation of coordinates between Document space and OS space. These parameters can be used to build transformation matrices to perform the transformation in either direction. Clips the DocRect so that it does not go outside the Chapter Bounds. This is used to try and stop the problems with DocCoords that are not within any chapters (ie. in OffPaste area). Find the current DocView object which SHOULD have been set as one of the very first actions during event processing.
static void	SetNoCurrent ()
	Set the current DocView pointer to be NULL, i.e., there is no current DocView object.
static DocView *	GetSelected ()
	Find the selected DocView object which SHOULD have been set as one of the very first actions during event processing.
static CNativeWnd *	GetCurrentRenderWindow ()
	Useful function allowing fairly direct access to CCamView's render window, which comes in handy on the odd occasion.
static BOOL	GetCurrentMousePos (Spread **ppSpread, DocCoord *pdcMousePos)
	Reports the position of the mouse if it is within the "selected" DocView. It position is "returned" in Spread coordinates.
static RenderRegion *	RenderOnTop (DocRect *Rect, Spread *pSpread, OnTopCode Reason)
	Marks the start of an 'On Top' rendering loop. On Top simply means that the rendering will be done directly over the top of anything else that happens to be there, without causeing a redraw from the bottom of the tree. This functions main use is drawing on the EOR blobs that show selection, are part of a tool or are there to show a drag is in progress. This function could also be used to draw objects that we know will be placed on top of all other objects (ie a new object, being drawn for the first time). You should always use a loop like the one below :- MonoOn RenderRegion* pRegion = DocView::RenderOnTop( MyRect, EOR ); while ( pRegion ) { Do your EOR rendering in here pRegion = DocView::GetNextOnTop( MyRect ); } MonoOff This bit of code will loop through all the invalid regions that the OS needs redrawing as well as all the rectangles that Camelot splits a region into itself. IMPORTANT : Because this is a loop, you should not change the state of any data within it, because it will then be different the second time the code in the loop is executed.
static RenderRegion *	GetNextOnTop (DocRect *)
	This function continues the RenderOnTop loop, returning the next RenderRegion to be considered. If we are not in the outer most rendering loop then this function will return NULL, as it will be up to the top level to re-call everyone with the next render region. It should always be used as part of a rendering loop as described in DocView::RenderOnTop.
static BOOL	SnapSelected (Spread *pSpread, DocCoord *pDocCoord, BOOL TryMagSnap=TRUE, BOOL TryGridSnap=TRUE)
	Calls the Snap(pSpread,pDocCoord) function of the selected DocView.
static BOOL	SnapSelected (Spread *pSpread, DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Calls the Snap(pSpread,pDocRect,PrevCoord,CurCoord) function of the selected DocView.
static BOOL	SnapCurrent (Spread *pSpread, DocCoord *pDocCoord, BOOL TryMagSnap=TRUE, BOOL TryGridSnap=TRUE)
	Calls the Snap(pSpread,pDocCoord) function of the Current DocView.
static BOOL	SnapCurrent (Spread *pSpread, DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Calls the Snap(pSpread,pDocRect,PrevCoord,CurCoord) function of the Current DocView.
static BOOL	SnapToMagneticNode (Spread *pSpread, Node *pNode, DocCoord *pDocCoord)
	Calls magnetic snapping functions taking into acount the control flags held in this DocView.
static BOOL	ForceSnapToGrid (Spread *pSpread, DocCoord *pDocCoord)
	Calls grid snapper ignoring enabling flags.
static BOOL	ForceSnapToGuides (Spread *pSpread, DocCoord *pDocCoord, GuidelineType Type)
	Calls guideline snapper ignoring enabling flags.
static void	ConstrainToAngle (DocCoord &, DocCoord *, double Constrain=0.0)
	Constrains the mouse movement to rays coming out from a central point. This is ideal for rotation etc. You should use this version of the function as the other verison of the function is being phased out right now.
static void	ConstrainToAngle (DocCoord &, double, DocCoord *)
	Constrains the mouse movement to rays coming out from a central point. This is ideal for rotation etc. DO NOT USE THIS VERSION OF THE FUNCTION. There is a newer version that makes use of the constrain angle in the preferences and should be used instead of this version.
static void	ConstrainToAspect (DocCoord &FixedPoint, FIXED16 &AspectLock, DocCoord *CurCoord)
	Forces the supplied coordinate to be constrained to positions that force the aspect ratio from the fixed corner to be the one supplied. It should be called by the tools to 'snap' the coordinates from a drag to positions where the shape is not deformed. NOT FINISHED.
Static Public Attributes
static BOOL	BackgroundRendering = TRUE
	Defines whether or not to use background rendering on new views. 0 => No background rendering 1 => Use background rendering.
static BOOL	SolidDragging = TRUE
	Defines whether or not solid dragging is enabled. 0 => Solid dragging disabled 1 => Solid dragging enabled.
static UINT32	IdleDragDelay = 200
	Defines delay time in milliseconds between detecting idle state and showing extra dragging info.
static UINT32	IdleDragDelay2 = 1000
	Defines delay time in milliseconds between detecting idle state and showing extra dragging info.
static BOOL	OriginOutlineShowNonOverlap = FALSE
	Original outlines will be shown as soon as dragged items don't overlap originals.
static BOOL	OriginOutlineShowAlways = FALSE
	Original outlines will be shown as soon as dragged items don't overlap originals.
static UINT32	SolidDragTimeLimit = 333
	Defines time limit in milliseconds for solid drag redraw. When redraw takes longer than this value, dragging falls back to outline mode.
static BOOL	OutlineShowBounds = TRUE
	Dragged outlines will show a bounding rectangle.
static double	DefaultConstrainAngle = PI / 4.0
	This is the default angle to which angles are constrained to (eg when rotating with constrain on, it will only rotate in multiples of this constrain angle. It must be greater than zero degrees and less than 360 degrees (note that it is recorded in radians).
Static Protected Member Functions
static void	SetSelectedInternal (DocView *NewSelected)
	This is an INTERNAL function, which MUST NOT BE CALLED by anything other than Document::SetSelectedViewAndSpread.
static void	SendSelectedMessage (DocView *OldSelected, DocView *NewSelected)
	This is an INTERNAL function, which MUST NOT BE CALLED by anything other than Document::SetSelectedViewAndSpread.
Protected Attributes
RulerPair *	pRulerPair
Private Member Functions
	CC_DECLARE_DYNAMIC (DocView)
RenderRegion *	NewRenderRegion (DocRect, Matrix &, CNativeDC *, Spread *, RenderType)
void	RenderView (RenderRegion *pRegion, Matrix &mxTxform, Spread *pSpread, BOOL fRenderPaper, BOOL fDeleteRegionAfter=TRUE, BOOL bForceImmediate=FALSE)
	To render a Document through a given RenderRegion. The dominating factor in this routine is that it renders the document with as little time overhead as possible. Obviously, this is mainly down to RenderRegions and the tree scanning routines working fast but we can do a bit to help. This routine is called directly by other functions in DocView and externally from the Background redraw Idle event processor.
CNativeDC *	GetRenderDC ()
	Access function for the device context of this kernel view object.
void	ScrollToShowAux (DocCoord *pCoord, DocCoord Margin)
	Scrolls the view to ensure that pCoord is in the view, with a margin of Margin between it and the edges of the view.
Private Attributes
BOOL	IsViewDying
INT32	PushToolCursorID
Cursor	m_PushCursor
DocCoord	StartDragPos
DocCoord	OldDragPos
WorkCoord	LastWorkClick
Operation *	pCurrentDragOp
DocCoord	DragPos
BOOL	m_bSolidDragSupported
DocView::CCAPI	ViewFlags
MonotonicTime	StartTime
PendingRedraws	PendingRedrawList
INT32	ZoomTableIndex
INT32	PrevIndex
FIXED16	PrevScale
WorkCoord	PrevOffset
CSnap *	pCSnap
BOOL	m_bPreventRenderView
BOOL	m_bBoundsChanged
Static Private Attributes
static DocView *	Selected = NULL
static OnTopCode	OnTopReason = Normal
static Spread *	OnTopSpread = NULL
static RenderRegion *	OnTopRenderRegion = NULL
static INT32	OnTopCount = 0
static UINT32	ScrollToShowMargin = 18000
	Margins to use (in millipoints) when autoscrolling with a margin.
Friends
class	Document
class	CCamView
Classes
struct	CCAPI

---

Detailed Description

The DocView class is used to hold non-oil data about views onto a document. When a CCamView object exists there is always a DocView object on the other side of the OIL- interface and they are linked. However, the DocView object is not destroyed when the CCamView object is destroyed so that it records the state of views while they are closed.

Author:

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

Date:

12/5/1993 Base Class: ListItem Friends: CCamView

Currently it contains: The rectangle of physical document space being shown by this view. The user viewing scale factor (as opposed to the PhysToWindow factor). The user WYSIWYG value for this view.

When fully implemented it will also hold: Information about the viewing of separations in this view. Information about the state of "snap-to-grid" in this view. Information about the viewing of print-borders and tile boundaries.

The kernel calls functions in this class to change the view, and DocView in turn, calls CCamView. There are also functions which the OIL layer calls to inform the kernel when the OS forcibly changes the view.

If you can't find the information that you want from a DocView object then the next place to try is it's associated CCamView (if there is one) and after that the Document object itself. All these objects are linked to each other.

See also:

View

Definition at line 228 of file docview.h.

---

Constructor & Destructor Documentation

DocView::DocView (  Document *  pOwnerDoc  )

DocView class constructor A DocView object is usually created by the Document and is linked into a list of DocViews owned by the Document. So the DocView constructor takes and stores a pointer to the Document object so that it can get to it quickly. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/93 Parameters: Pointer  to Document to which it belongs [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 732 of file docview.cpp. : m_PushCursor( (Tool_v1*)NULL, _R(IDC_PUSHTOOLCURSOR) ) { // Set the flag that indicates if the view is dying or not. Make sure it is not dying IsViewDying = FALSE; // Implementation... ERROR3IF( pOwnerDoc == NULL, "DocView has no Owner Document !!" ); pDoc = pOwnerDoc; // Maintain link to Document which owns us pViewWindow = NULL; // Clear pointer to window pVState = NULL; PushToolCursorID = 0; // Matt 12/01/2001 - Ensure it is set to a sensible value at creation pCurrentDragOp = NULL; // we aren't dragging just yet Scale = 1.0; // Viewing scale = 1.00 ViewFlags.BackgroundRender = BackgroundRendering; // Use preference ViewFlags.GridShow = FALSE; // Grid not shown ViewFlags.GridSnap = FALSE; // Grid not snapping ViewFlags.ObjectsSnap = FALSE; // All objects not snapping ViewFlags.MagObjectsSnap = FALSE; // Magnetic objects not snapping ViewFlags.PrintBorderShow = FALSE; // Print borders not shown ViewFlags.LogicalView = TRUE; // Chapters are shown one above the other ViewFlags.WorkClickCached = FALSE; // Haven't got a click cached ViewFlags.Dragging = FALSE; // We're not dragging anything ViewFlags.GuidesSnap = TRUE; // Not snapping to guides ViewFlags.GuidesShow = TRUE; // Show guides by default // Get the default quality level RenderQuality = Quality::DefaultQuality; // Initialise the snap object to NULL. This is set up in the Snap functions pCSnap = NULL; // init pointer to rulers pRulerPair = NULL; // make sure we don't prevent ourselves from rendering m_bPreventRenderView = FALSE; // Setup solid dragging flags m_bSolidDragSupported = FALSE; m_bSolidDrag = FALSE; // Make ourselves current. SetCurrent(); // Broadcast a message to all that there's a new view on the block . . . BROADCAST_TO_ALL(DocViewMsg(this, DocViewMsg::BORN)); }

DocView::~DocView (   )  [virtual]

DocView class destructor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 799 of file docview.cpp. { // delete the rulers (must be done first to prevent them receiving doc view dying messages) if(pRulerPair) { delete pRulerPair; } pRulerPair=NULL; // Set the flag that indicates if the view is dying. IsViewDying = TRUE; // Make sure that Current and Selected do not refer to the dying DocView if (this == Current) SetNoCurrent(); if (this == Selected) Document::SetNoSelectedViewAndSpread(); Camelot.DeleteRenderRegions(this); // Inform parent doc that we are about to die pDoc->OnDocViewDying(this); // Bye bye to the ViewState object (DON'T deallocate - done by CCamView). pVState = NULL; // If we have an attached CSnap object, junk it if (pCSnap != NULL) delete pCSnap; // Broadcast to everyone that this view is a dead duck. BROADCAST_TO_ALL(DocViewMsg(this, DocViewMsg::KILLED)); }

---

Member Function Documentation

BOOL DocView::AreRulersVisible (   )

Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Are Rulers Visible on this view See also: - Definition at line 5141 of file docview.cpp. { return pViewWindow->AreRulersVisible( ); }

BOOL DocView::AreScrollersVisible (   )

Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Are Rulers Visible on this view See also: - Definition at line 5161 of file docview.cpp. { return pViewWindow->AreScrollersVisible( ); }

DocView::CC_DECLARE_DYNAMIC (  DocView   )  [private]

BOOL DocView::ChangeDragType (  DragType  Type  )

Change the type of drag during the middle of a drag. This can only be called if there is a drag already happening (ie between calls to StartDrag and EndDrag). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 3/4/95 Parameters: Type  - The type of drag to change to [INPUTS] Returns: TRUE if it worked, FALSE if it failed Errors: ERROR3 if there is no render window or there is no drag happening See also: ScreenCamView::ChangeDragType Definition at line 3637 of file docview.cpp. { TRACE( _T("Warning - DocView::ChangeDragType called\n") ); // A bit of error checking ERROR3IF(pViewWindow == NULL, "ARGH! DocView is not connected to a window in ChangeDragType!"); ERROR3IF(pCurrentDragOp == NULL, "Not dragging in ChangeDragType"); // Ask the Oil side of things to change the drag BOOL Result = pViewWindow->ChangeDragType(Type); return Result; }

void DocView::ClearClickState (   )

Allows click handlers to reset the click logic if they are doing things that would break it. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/02/2004 Returns: - Errors: See also: Definition at line 5515 of file docview.cpp. { PORTNOTETRACE("other","DocView::ClearClickState - do nothing"); #ifndef EXCLUDE_FROM_XARALX if (pViewWindow) { pViewWindow->ClearClickState(); } #endif }

void DocView::ConstrainToAngle (  DocCoord &  Centre, double  Constrain, DocCoord *  CurCoord )  [static]

Constrains the mouse movement to rays coming out from a central point. This is ideal for rotation etc. DO NOT USE THIS VERSION OF THE FUNCTION. There is a newer version that makes use of the constrain angle in the preferences and should be used instead of this version. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/94 Parameters: Centre  - The point that all the constrain rays come from [INPUTS] Constrain - The constrain angle in Radians CurCoord  - contains the mouse coord on entry and contains the constrained [OUTPUTS] mouse coord afterwards Definition at line 4815 of file docview.cpp. { // Just call the new version of the function ConstrainToAngle(Centre, CurCoord, Constrain); }

void DocView::ConstrainToAngle (  DocCoord &  Centre, DocCoord *  CurCoord, double  Constrain = 0.0 )  [static]

Constrains the mouse movement to rays coming out from a central point. This is ideal for rotation etc. You should use this version of the function as the other verison of the function is being phased out right now. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/94 Parameters: Centre  - The point that all the constrain rays come from [INPUTS] Constrain - The constrain angle in Radians. You should not pass in this param except in very special circumstances. When this param is left out the constrain angle from the users preferences is used, which should be the way it is done in almost all circumstances. CurCoord  - contains the mouse coord on entry and contains the constrained [OUTPUTS] mouse coord afterwards Definition at line 4760 of file docview.cpp. { if (Constrain==0.0) { // Use the angle found in the preferences Constrain = DefaultConstrainAngle; } // Find out which of the 2 axis are the most significant double dx = CurCoord->x - Centre.x; double dy = CurCoord->y - Centre.y; // make sure that the cursor is not over the origin if ((dx==0) && (dy==0)) return; // Find the square of the length of the ray double RayLength = sqrt((dy*dy) + (dx*dx)); // Find the angle that this coord is around a circle double Angle = atan2(dy, dx); // constrain the angle to the nearest band double SnapAngle = (Angle + (Constrain/2)) / Constrain; SnapAngle = floor(SnapAngle); SnapAngle *= Constrain; // recalculate the new coordinate for the cursor dx = (INT32)(RayLength * cos(SnapAngle)); dy = (INT32)(RayLength * sin(SnapAngle)); // Calculate the new position for the cursor CurCoord->x = (INT32)(Centre.x + dx); CurCoord->y = (INT32)(Centre.y + dy); }

void DocView::ConstrainToAspect (  DocCoord &  FixedCoord, FIXED16 &  AspectLock, DocCoord *  CurCoord )  [static]

Forces the supplied coordinate to be constrained to positions that force the aspect ratio from the fixed corner to be the one supplied. It should be called by the tools to 'snap' the coordinates from a drag to positions where the shape is not deformed. NOT FINISHED. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/94 Parameters: FixedCoord  - a fixed reference point, usually the opposite corner of the [INPUTS] bounding rectangle to be constrained AspectLock - The aspect ratio to maintain (1 is square) CurCoord  - This coordinate will be modified so that it forms a rectangle of [OUTPUTS] the correct aspect ratio from the fixed corner. See also: DocView::ConstrainToAngle() Definition at line 4842 of file docview.cpp. { // Get something to avoid all the rampant *s in my code DocCoord& DiffCoord = *CurCoord; // Find out which of the 2 axis are the most significant INT32 dx = DiffCoord.x - FixedCoord.x; INT32 dy = DiffCoord.y - FixedCoord.y; double dAspect = AspectLock.MakeDouble(); if (abs(dx)>abs(dy)) { // The x coord is the most significant, so change the y coord to match // First work out the magnitude of the change and correct it for sign INT32 NewOffset = (INT32)(abs(dx) / dAspect); if (dy<0) NewOffset = -NewOffset; // add in the difference DiffCoord.y = FixedCoord.y + NewOffset; } else { // The y coord is the most significant, so chnage the x coord to match // First work out the magnitude of the change and correct it for sign INT32 NewOffset = (INT32)(abs(dy) * dAspect); if (dx<0) NewOffset = -NewOffset; // add in the difference DiffCoord.x = FixedCoord.x + NewOffset; } }

void DocView::ContinueRenderView (  RenderRegion *  pRRegion, Spread *  pSpread, BOOL  fRenderPaper = TRUE, BOOL  fDeleteRegionAfter = TRUE, BOOL  bForceImmediate = FALSE )  [virtual]

To re-start rendering a Document through a given RenderRegion. This call is different from RenderView because it may need to re-compute the Doc to OS matrix. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 11/7/93 Parameters: Pointer  to RenderRegion which needs rendering to be performed. [INPUTS] Pointer to chapter which RenderRegion represents. fRenderPaper --- if TRUE then render paper, blobs etc. By default TRUE. fDeleteRegionAfter --- if TRUE then this function will deallocate the RenderRegion passed to it when it has been completely rendered. By default TRUE. None  [OUTPUTS] Returns: None Scope: Public Errors: None Implements View. Definition at line 1929 of file docview.cpp. { // Diccon 10/5/2000 my awful flag that prevents rendering of the view from occurring // whilst a brush stroke is in progress if (m_bPreventRenderView == TRUE) return; // Remove the drag blobs from this region, if there are any. if (fRenderPaper) { Operation* pDragOp = Operation::GetCurrentDragOp(); if (pDragOp) pDragOp->RenderDragBlobs(pRRegion->GetClipRect(), pSpread, m_bSolidDrag); } // Render the document in one operation. Matrix mxConv = ConstructRenderingMatrix(pSpread); if (OnTopCount == 0 && GetColourPlate() != NULL && !GetColourPlate()->IsDisabled()) { ColourPlateType PlateType = GetColourPlate()->GetType(); if (PlateType != COLOURPLATE_NONE && PlateType != COLOURPLATE_COMPOSITE) { // We have to do this before the render as the RenderSimpleView call // will delete the render region DocRect BlobClipRect = pRRegion->GetRegionRect(); DocRect DragClipRect = pRRegion->GetClipRect(); // Do a printer style simple/complex ScanningRenderRegion type render RenderSimpleView(pRRegion, mxConv, pSpread, fRenderPaper); // Dragging blobs/boxes. if (fRenderPaper) { Operation* pDragOp = Operation::GetCurrentDragOp(); if (pDragOp) pDragOp->RenderDragBlobs(DragClipRect, pSpread, m_bSolidDrag); } // Draw the blobs if we are the "selected" view. // And we're not solid dragging... if (fRenderPaper && this == Selected && !(pCurrentDragOp!=NULL && m_bSolidDrag)) { Tool* pTool = Tool::GetCurrent(); if (pTool) pTool->RenderToolBlobs(pSpread, &BlobClipRect); // Render the Currently selected objects selection blobs RenderSelectBlobs(BlobClipRect, pSpread); } return; } } RenderView(pRRegion, mxConv, pSpread, fRenderPaper, fDeleteRegionAfter, bForceImmediate); }

BOOL DocView::DeclarePreferences (   )  [static]

Declares any preferences that the DocView class needs to decalre. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/94 Returns: TRUE if it worked, FALSE if it failed Definition at line 676 of file docview.cpp. { // NB. Constrain angle must be between 1 and 359 degrees. return GetApplication()->DeclareSection(TEXT("Constraints"), 1) && GetApplication()->DeclarePref(TEXT("Constraints"), TEXT("Constrain Angle"), &DefaultConstrainAngle, (2 * PI) / 360, ((2 * PI) * 359) / 360) && GetApplication()->DeclareSection(TEXT("Rendering"), 2) && GetApplication()->DeclarePref(TEXT("Rendering"), TEXT("BackgroundRendering"), &BackgroundRendering, FALSE, TRUE) && GetApplication()->DeclareSection(TEXT("AutoScrolling"), 1) && GetApplication()->DeclarePref(TEXT("AutoScrolling"), TEXT("ScrollToShowMargin"), &ScrollToShowMargin) && GetApplication()->DeclareSection(TEXT("Dragging"), 6) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("SolidDragging"), &SolidDragging, FALSE, TRUE) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("IdleDragDelay"), (UINT32*)&IdleDragDelay, 0, 10000) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("IdleDragDelay2"), (UINT32*)&IdleDragDelay2, 0, 10000) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("SolidDragTimeLimit"), (UINT32*)&SolidDragTimeLimit, 0, 10000) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OriginOutlineShowAlways"), &OriginOutlineShowAlways, FALSE, TRUE) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OriginOutlineShowNonOverlap"), &OriginOutlineShowNonOverlap, FALSE, TRUE) && GetApplication()->DeclarePref(TEXT("Dragging"), TEXT("OutlineShowBounds"), &OutlineShowBounds, FALSE, TRUE); }

BOOL DocView::DM_DragFinished (  DragInformation *  DragInfo, ViewDragTarget *  pDragTarget )

act at the end of a general drag according to the drag type. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (and Will) Date: 23/1/95 Parameters: DragInformation  - about this drag.. [INPUTS] pDragTarget - The drag target created for this DocView Definition at line 3028 of file docview.cpp. { // The DragInfo must know what to do, or else we wouldn't // have accepted the drag BOOL DropOK = DragInfo->OnPageDrop(pDragTarget); return DropOK; }

void DocView::DragFinished (  Operation *  pDragOp, OilCoord  PointerPos, ClickModifiers  Mods, BOOL  Success )

Tell the current dragging operation that the drag has ended either because the pointer buttons have all been released or the drag has been aborted in some way (Escape was pressed?). This function is ony called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: pDragOp  - Pointer to the current drag operation [INPUTS] PointerPos - Coordinate of pointer in OS space Mods - Click modifiers structure Success - Flag saying whether drag ended OK or was aborted for some reason Definition at line 3174 of file docview.cpp. { // Ignore if system is disabled if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore // SHOULD END THE DRAG // Find the spread that contains DocPos Spread *pSpread = FindEnclosingSpread(PointerPos); if (pSpread == NULL) { ERROR3("Could not find spread in which the click happened"); return; // Exit reasonably nicely } // First of all convert the OSRect into document coords DocCoord DocPos = PointerPos.ToDoc( pSpread, this ); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&DocPos); // Store away the WorkCoord version of this click in the DocView for later extraction by // GetClickWorkCoord(); LastWorkClick = PointerPos.ToWork( pVState->GetScrollPos() ); // Cached WorkCoord is valid. ViewFlags.WorkClickCached = TRUE; // Broadcast a "starting operation" message to begin with (normally broadcast by // OpDescriptor::Invoke, but thanks to the brain-damaged Camelot architecture, operations // which drag do not invoke, and this is the best place to catch them. Go figure.) BROADCAST_TO_ALL(OpMsg(pDragOp, OpMsg::BEGIN)); // Now call the current tool with the DocCoord click point pDragOp->DragFinished(DocPos, Mods, pSpread, Success, m_bSolidDrag); // Cached WorkCoord is no longer valid! ViewFlags.WorkClickCached = FALSE; m_bSolidDrag = FALSE; }

void DocView::DragPointerIdle (  Operation *  pDragOp, OilCoord  PointerPos, ClickModifiers  Mods )

Tell the current dragging operation that the pointer has NOT moved and that there is idle CPU time to be used. This function is only called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: pDragOp  - Pointer to the current drag operation [INPUTS] PointerPos - Coordinate of pointer in OS space Mods - Click modifiers structure Definition at line 3111 of file docview.cpp. { ERROR3IF(pDragOp == NULL, "Illegal NULL parameter!"); // Ignore if system is disabled if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore // Find the spread that contains DocPos Spread *pSpread = FindEnclosingSpread(PointerPos); // Note GetSelectedSpread is quicker in situations where you know you only have one spread // but it prevents drags on multiple spread views working properly... // Spread *pSpread = Document::GetSelectedSpread(); if (pSpread == NULL) { ERROR3("Could not find spread in which the click happened"); return; // Exit reasonably nicely } // First of all convert the OSRect into document coords DocCoord DocPos = PointerPos.ToDoc(pSpread, this); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&DocPos); // Store away the WorkCoord version of this click in the DocView for later extraction by // GetClickWorkCoord(); LastWorkClick = PointerPos.ToWork( pVState->GetScrollPos() ); ViewFlags.WorkClickCached = TRUE; // Cached WorkCoord is valid. // Now call the current tool with the DocCoord click point if (pDragOp != NULL) pDragOp->DragPointerIdle(DocPos, Mods, pSpread, m_bSolidDrag); // Cached WorkCoord is no longer valid! ViewFlags.WorkClickCached = FALSE; }

void DocView::DragPointerMove (  Operation *  pDragOp, OilCoord  PointerPos, ClickModifiers  Mods )

Tell the current dragging operation that the pointer has moved. This function is ony called when a drag has been started in CCamView by calling its StartDrag function and should not be called after EndDrag has been called. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: pDragOp  - Pointer to the current drag operation [INPUTS] PointerPos - Coordinate of pointer in OS space Mods - Click modifiers structure Definition at line 3052 of file docview.cpp. { // BOOL bDragSolidly = FALSE; // Ignore if system is disabled if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore // Find the spread that contains DocPos Spread *pSpread = FindEnclosingSpread(PointerPos); // Note GetSelectedSpread is quicker in situations where you know you only have one spread // but it prevents drags on multiple spread views working properly... // Spread *pSpread = Document::GetSelectedSpread(); if (pSpread == NULL) { ERROR3("Could not find spread in which the click happened"); return; // Exit reasonably nicely } // Convert the OSRect into document coords DocCoord DocPos = PointerPos.ToDoc(pSpread, this); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&DocPos); // Store away the WorkCoord version of this click in the DocView for later extraction by // GetClickWorkCoord(); LastWorkClick = PointerPos.ToWork( pVState->GetScrollPos() ); ViewFlags.WorkClickCached = TRUE; // Cached WorkCoord is valid. // Now call the current tool with the DocCoord click point ERROR3IF( pDragOp==NULL, "There was not operation in DragPointerMove()" ); if (pDragOp) pDragOp->DragPointerMove(DocPos, Mods, pSpread, m_bSolidDrag); ViewFlags.WorkClickCached = FALSE; // Cached WorkCoord is no longer valid! }

BOOL DocView::EndDrag (  Operation *  pDragOp  )

Tell the oil layer that the drag has finished. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: pDragOp  - The current operation [INPUTS] Returns: TRUE if it workded Definition at line 3602 of file docview.cpp. { ERROR3IF(pViewWindow == NULL, "ARGH! DocView is not connected to a window in EndDrag!"); // ERROR3IF(pCurrentDragOp == NULL, "Not dragging in DocView::EndDrag?"); // ERROR3IF(pDragOp != pCurrentDragOp, "DragOp pointer inconsistent in DocView::EndDrag"); pCurrentDragOp = NULL; // Matt 12/01/2001 - Restore the cursor if we've changed it earlier to the push tool cursor... if (PushToolCursorID && (PushToolCursorID != 0)) { CursorStack::GPop(PushToolCursorID); PushToolCursorID = 0; } return pViewWindow->EndDrag(pDragOp); }

Spread * DocView::FindEnclosingSpread (  OilCoord  Pos  )

Given a chapter and an OilCoord, finds the spread that contains the coordinate. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/12/93 Parameters: Pos  - the coord to look for. [INPUTS] Returns: The spread that contains the coordinate, or NULL if such a spread does not exist. Definition at line 4197 of file docview.cpp. { // Find first spread in chapter Chapter* pChapter = Node::FindFirstChapter(pDoc); if (pChapter==NULL) { ERROR3( "There was no chapter in this document"); return NULL; } Spread* pSpread = (Spread*)pChapter->FindFirstChild(); ERROR3IF((pSpread == NULL) || !pSpread->IsSpread(), "Chapter has no spreads"); // Optimisation for simple documents: // If only one chapter containing only one spread then that must be the // enclosing spread! if (pSpread && (pSpread->FindNext()==NULL || !pSpread->FindNext()->IsSpread()) && pChapter->FindNext()==NULL) return pSpread; // If the cursor was above the top of the document, then return the first spread // if there is one if (Pos.y >= 0) return pSpread; // Find this position in 64-bit work coords WorkCoord WorkPos = Pos.ToWork( pVState->GetScrollPos() ); do { pSpread = (Spread *) pChapter->FindFirstChild(); ERROR3IF((pSpread == NULL) || !pSpread->IsSpread(), "Chapter has no spreads"); do { // Convert spread bounding box to logical coords DocRect PhysSpreadRect = pSpread->GetWidePasteboard(this); WorkRect LogSpreadRect; LogSpreadRect.lo = PhysSpreadRect.lo.ToWork(pSpread, this); LogSpreadRect.hi = PhysSpreadRect.hi.ToWork(pSpread, this); // Check if spread intersects the clipping rect if ((WorkPos.y <= LogSpreadRect.hi.y) && (WorkPos.y >= LogSpreadRect.lo.y)) { // Found the correct spread so stop looking. return pSpread; } // try next spread pSpread = (Spread *) pSpread->FindNext(); ERROR3IF((pSpread != NULL) && !(pSpread->IsSpread()), "Spread is not a Spread!"); } while (pSpread != NULL); // Was not in that chapter, so try the next one pChapter = (Chapter*) pChapter->FindNext(); ERROR3IF( (pChapter!=NULL) && !(pChapter->IsKindOf(CC_RUNTIME_CLASS(Chapter))), "Chapter is not a Chapter!" ); } while (pChapter != NULL); ERROR3IF( pSpread == NULL, "Could not find spread in which the click happened"); return pSpread; }

void DocView::FlushRedraw (   )

Intelligently invalidate all the regions gathered so far for this DocView. This performs smart invalidation depending on the number and nature of the regions. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/94 See also: DocView::ForceRedraw; PendingRedraws; SpreadRedraws Definition at line 2749 of file docview.cpp. { // Ask the update list to do its stuff PendingRedrawList.FlushRedraw(this); }

void DocView::ForceRedraw (  Spread *  pSpread, DocRect  SpreadRect, BOOL  Accumulate = FALSE, Node *  pInvalidNode = NULL )

Force redraw of an area of a spread. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> & Rik Date: 14/12/93 Parameters: pSpread  - the spread which contains the invalid region. [INPUTS] SpreadRect - the invalid region (in spread coordinates, i.e. (0,0) based) Accumulate - TRUE => invalidate *now* FALSE => don't invalidate right now, but accumulate this into a list of rectangles for this view, and update intelligently when DocView::FlushRedraw() is called. ForceRecache - TRUE => Make sure that any overlapping cached bitmaps that capture bits of objects around/under/over them are thrown away during this redraw FALSE => Don't need to worry about cached objects because nothing in the tree has changed See also: DocView::FlushRedraw Definition at line 2652 of file docview.cpp. { ERROR3IF(pSpread == NULL, "ForceRedraw has been passed a NULL spread pointer"); // Make sure we use this DocView SetCurrent(); // This rectangle has come directly from the program and might not lie on pixel // boundaries. So pixelise it before passing it directly on to the rendering system. SpreadRect.lo.Pixelise(this); SpreadRect.hi.Pixelise(this); // Should we do it now? // IMMEDIATE REDRAW // if (FALSE) if (Accumulate) { // No - add it to our list and wait until the Operation finishes...as long as it // works. if (PendingRedrawList.AddInvalidRegion(pSpread, SpreadRect, pInvalidNode)) { // Worked - exit now and wait for FlushRedraw() to be called. return; } // Otherwise fall through to normal processing (which will probably fail too!) } // Is this a bodge I see before me??? // Not really. This modification expands the invalid region to take anti-aliasing // pixels into account. It could be made conditional on anti-aliasing being turned on // but this is simpler and the overhead when anti-aliasing is off is not great. SpreadRect.Inflate(ScaledPixelWidth.MakeLong(), ScaledPixelHeight.MakeLong()); // Translate spread coords to document coords pSpread->SpreadCoordToDocCoord(&SpreadRect); // Clip this region to the spread DocRect WidePasteRect = pSpread->GetWidePasteboard(this); SpreadRect = SpreadRect.Intersection(WidePasteRect); // need to check for valid intersections here as Intersecting with // an invalid rectangle again will give a valid rectangle would you // believe! (Mike 20/12/95) if ( SpreadRect.IsEmpty() || (!SpreadRect.IsValid()) ) { return; } // Convert clip rectangle to document coords DocRect DocClipRect = GetDocViewRect(pSpread); // Clip to spread rectangle SpreadRect = SpreadRect.Intersection(DocClipRect); // Check to see if the result is an empty rectangle if ((SpreadRect.IsValid()) && (!SpreadRect.IsEmpty())) { // Find type of rendering device CCamView *pCamView = GetConnectionToOilView(); ERROR2IF(pCamView == NULL, (void)0, "DocView has no CamView!"); // These next two are commented out because // a) rType is never used, and // b) pDevContext idn't needed in MakeNewRenderRegion if PaintPaper is FALSE (which is is) // CDC *pDevContext = pCamView->GetRenderDC(); // const RenderType rType = CCDC::GetType(pDevContext, TRUE); // Translate document coords back to spread coords pSpread->DocCoordToSpreadCoord(&SpreadRect); // Use this to make a render region. // MakeNewRenderRegion(pSpread, SpreadRect, pDevContext, RENDERTYPE_SCREEN, FALSE); // See changed line below // Notice that because the PaintPaper parameter (5th one) is FALSE, we can pass // NULL as a pointer to a device context, and thus we don't have to call // GetRenderDC above at all, and hopefully, this will speed up translation // no end. MakeNewRenderRegion(pSpread, SpreadRect, NULL, RENDERTYPE_SCREEN, FALSE, pInvalidNode); } }

void DocView::ForceRedraw (  WorkRect &  ForceRect  )

Force a specific rectangle of the view to be redrawn. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: ForceRect  - the rectangle to be invalidated [INPUTS] Definition at line 2613 of file docview.cpp. { PORTNOTETRACE("other","DocView::ForceRedraw - do nothing"); #ifndef EXCLUDE_FROM_XARALX ERROR3("Should not be called!"); OilCoord OilRectLo = (ForceRect.lo).ToOil(GetScrollOffsets()); OilCoord OilRectHi = (ForceRect.hi).ToOil(GetScrollOffsets()); OilRect RedrawOilRect(OilRectLo, OilRectHi); pViewWindow->InvalidateView(&RedrawOilRect); #endif }

void DocView::ForceRedraw (  BOOL  ForcePaper = FALSE  )

Force the entire view to be redrawn. NB. If you are redrawing because you have changed the zoom or scroll offsets, then you must pass in TRUE for ForcePaper!!! (Because (a) Otherwise our scroll offsets are invalid and the next time we scroll it gets mucked up, and (b) Scrolling or zooming should give instant feedback to the user.). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: ForcePaper,:  TRUE => do a normal OS-style invalidation [INPUTS] FALSE => do a 'clever' internal invalidation which does not cause paper to be drawn straight away, so we get a smoother feel to the update. Definition at line 2505 of file docview.cpp. { // Make sure we use this DocView SetCurrent(); // Get rid of any render regions associated with this DocView Camelot.DeleteRenderRegions(this); // Invalidate the whole view window if (ForcePaper) { // We want an instant update with paper drawn now, so use the OS to do the // invalidation. pViewWindow->InvalidateView(); return; } // find type of rendering device CCamView *pCamView = GetConnectionToOilView(); ERROR2IF(pCamView == NULL, (void)0, "DocView::ForceRedraw: DocView has no CamView"); pCamView->AllocateDC(); // allocate a DC CNativeDC* pDevContext = pCamView->GetRenderDC(); const RenderType rType = CCDC::GetType(pDevContext, TRUE); // Get DocView rectangle in 64 bit WorkCoods WorkRect ClipRect = GetViewRect(); ERROR3IF(ClipRect.lo.x > ClipRect.hi.x, "DocView::ForceRedraw: clipping rect is invalid"); ERROR3IF(ClipRect.lo.y > ClipRect.hi.y, "DocView::ForceRedraw: clipping rect is invalid"); // Find all the spreads in the document that intersect the clipping rect, and create // a render region for each of them. // Get the first chapter in the document for (Chapter* pChapter = Node::FindFirstChapter(pDoc); pChapter != 0; pChapter = pChapter->FindNextChapter()) { // Convert chapter bounding box to logical coords DocRect PhysChapterRect = pChapter->GetPasteboardRect(TRUE, this); WorkRect LogChapterRect; LogChapterRect.lo = PhysChapterRect.lo.ToWork(pDoc, this); LogChapterRect.hi = PhysChapterRect.hi.ToWork(pDoc, this); // 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. BOOL fIsLastChapter = (pChapter->FindNextChapter() == 0); if (ClipRect.lo.y <= LogChapterRect.hi.y && (fIsLastChapter || ClipRect.hi.y >= LogChapterRect.lo.y)) { for (Spread* pSpread = pChapter->FindFirstSpread(); pSpread != 0; pSpread = pSpread->FindNextSpread()) { // Convert spread bounding box to logical coords DocRect PhysSpreadRect = pSpread->GetPasteboardRect(TRUE); // Pixelised WorkRect LogSpreadRect; LogSpreadRect.lo = PhysSpreadRect.lo.ToWork(pSpread, this); LogSpreadRect.hi = PhysSpreadRect.hi.ToWork(pSpread, this); BOOL fIsLastSpread = (pSpread->FindNextSpread() == 0); // Check if spread intersects the clipping rect if (ClipRect.lo.y <= LogSpreadRect.hi.y && ((fIsLastChapter && fIsLastSpread) || 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 = GetDocViewRect(pSpread); // 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 it to Spread coords and create a render region pSpread->DocCoordToSpreadCoord(&SpreadClipRect); MakeNewRenderRegion(pSpread, SpreadClipRect, pDevContext, rType, FALSE); } } } } } pCamView->DoneWithDC(); // deallocate a DC }

BOOL DocView::ForceSnapToGrid (  Spread *  pSpread, DocCoord *  pDocCoord )  [static]

Calls grid snapper ignoring enabling flags. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/94 Parameters: pSpread  Pointer to spread on which node exists [INPUTS] pDocCoord A coordinate to test magnetically against the node Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast Errors: Will error in debug builds if there is no selected DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4467 of file docview.cpp. { ERROR3IF(Selected == NULL,"DocView::SnapSelected called when no selected DocView"); if (Selected != NULL) { BOOL Snapped = FALSE; if (Selected->pCSnap == NULL) Selected->pCSnap = new CSnap(Selected,pSpread); if (Selected->pCSnap != NULL) { Selected->pCSnap->SetSpread(pSpread); Snapped = Selected->pCSnap->SnapToGrids(pDocCoord); } return (Snapped); } else return (FALSE); }

BOOL DocView::ForceSnapToGuides (  Spread *  pSpread, DocCoord *  pDocCoord, GuidelineType  Type )  [static]

Calls guideline snapper ignoring enabling flags. Author: Martin Wuerthner <xara@mw-software.com> Date: 24/08/06 Parameters: pSpread  Pointer to spread on which node exists [INPUTS] pDocCoord A coordinate to test magnetically against the node Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast Errors: Will error in debug builds if there is no selected DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4357 of file docview.cpp. { ERROR3IF(Selected == NULL,"DocView::ForceSnapToGuides called when no selected DocView"); if (Selected != NULL) { BOOL Snapped = FALSE; if (Selected->pCSnap == NULL) Selected->pCSnap = new CSnap(Selected,pSpread); if (Selected->pCSnap != NULL) { Selected->pCSnap->SetSpread(pSpread); Snapped = Selected->pCSnap->SnapToGuidelines(pDocCoord, Type); } return (Snapped); } else return (FALSE); }

DocCoord DocView::GetCentreCoord (   )

Gets a DocCoord for the centre of the view. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The DocCoord for the centre of the view Errors: - See also: - Definition at line 5285 of file docview.cpp. { //First get the document associated with this view Document* pDocument=GetDoc(); //And find the first spread in that document PORTNOTE("spread", "Multi-spread warning!") Spread* pSpread=pDocument->FindFirstSpread(); //Check we got both of those ERROR2IF(pDocument==NULL || pSpread==NULL, DocCoord(0,0), "DocView::GetCentreImportPosition - no document or spread"); //So get the view rectangle DocRect rectView = GetDocViewRect(pSpread); //And find the middle of that rectangle DocCoord dcCentre; dcCentre.x = rectView.lo.x / 2 + rectView.hi.x / 2; dcCentre.y = rectView.lo.y / 2 + rectView.hi.y / 2; //Now make that into a spread coordinate DocRect rectSpread = pSpread->GetPasteboardRect(); DocCoord dcToReturn; dcToReturn.x = dcCentre.x - rectSpread.lo.x; dcToReturn.y = dcCentre.y - rectSpread.lo.y; //And return that DocCoord return dcToReturn; }

ImportPosition DocView::GetCentreImportPosition (   )

Gets an import position for the centre of the view. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The import position for the centre of the view Errors: - See also: - Definition at line 5332 of file docview.cpp. { //First get the document associated with this view Document* pDocument=GetDoc(); //And find the first spread in that document PORTNOTE("spread", "Multi-spread warning!") Spread* pSpread=pDocument->FindFirstSpread(); //Now get the DocCoord in the centre of the view DocCoord dcToReturn=GetCentreCoord(); //Put all those values into an ImportPosition structure ImportPosition posToReturn; posToReturn.pSpread=pSpread; posToReturn.Position=dcToReturn; //And return that ImportPosition return posToReturn; }

WorkCoord DocView::GetClickWorkCoord (   )

To let people know where the last click was in Work Coordinates. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/93 Returns: The position of the last click in work coords Definition at line 3521 of file docview.cpp. { ERROR3IF(!ViewFlags.WorkClickCached, "DocView::GetClickWorkCoord called when WorkClickCached is FALSE"); return LastWorkClick; }

DocView * DocView::GetCurrent (   )  [static]

This function returns the parameters which control the transformation of coordinates between Document space and OS space. These parameters can be used to build transformation matrices to perform the transformation in either direction. Clips the DocRect so that it does not go outside the Chapter Bounds. This is used to try and stop the problems with DocCoords that are not within any chapters (ie. in OffPaste area). Find the current DocView 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 DocView object. Reimplemented from View. Definition at line 2122 of file docview.cpp. { View *pView = View::GetCurrent(); // Make sure it really is a DocView; if ((pView == NULL) || (pView->IS_KIND_OF(DocView))) // Yes - return it. return (DocView *) pView; // Complain! //ERROR2(NULL, "DocView::GetCurrent called when current view is not a DocView!"); TRACEALL( _T("DocView::GetCurrent called when current view is not a DocView!\n") ); return NULL; }

BOOL DocView::GetCurrentMousePos (  Spread **  ppSpread, DocCoord *  pdcMousePos )  [static]

Reports the position of the mouse if it is within the "selected" DocView. It position is "returned" in Spread coordinates. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: -  [INPUTS] ppSpread  pointer to a Spread pointer that will hold the spread [OUTPUTS] containing the mouse pdcMousePos pointer to a DocCoord that will hold the coordinates of the mouse Returns: TRUE if the mouse is within the "selected" DocView, FALSE otherwise. Errors: - See also: CCamView::GetCurrentMousePos Definition at line 3779 of file docview.cpp. { // Valid output arguments must be provided. ERROR3IF(ppSpread == NULL, "Null Spread** in DocView::GetCurrentMousePos"); ERROR3IF(pdcMousePos == NULL, "Null DocCoord* in DocView::GetCurrentMousePos"); // Check if there is a "selected" DocView. if (Selected == NULL) return FALSE; // Ask the CCamView attached to the selected DocView to report the mouse position. OilCoord pt; if (!Selected->pViewWindow->GetCurrentMousePos(&pt)) return FALSE; // Convert the OIL coordinate to spread / doccoords. Spread* pSpread = Selected->FindEnclosingSpread(pt); if (pSpread == NULL) { ERROR3("Couldn't find a spread containing mouse position in DocView::GetCurrentMousePos"); return FALSE; } // Convert the OSRect into document coords DocCoord dc = pt.ToDoc(pSpread, Selected ); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&dc); // Return result and success code to caller. *ppSpread = pSpread; *pdcMousePos = dc; return TRUE; }

CNativeWnd * DocView::GetCurrentRenderWindow (   )  [static]

Useful function allowing fairly direct access to CCamView's render window, which comes in handy on the odd occasion. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (modified to use DocView::GetRenderWindow() by Ed 1/9/95) Date: 15 Oct 93 Returns: Pointer to the current CNativeWnd window object which is being rendered. Errors: Returns NULL if there isn't one. Definition at line 2167 of file docview.cpp. { DocView* pCurrent=GetCurrent(); if (pCurrent==NULL) return NULL; return pCurrent->GetRenderWindow(); }

BOOL DocView::GetCurrentSolidDragAbility (   )  [inline]

Definition at line 335 of file docview.h. {return m_bSolidDragSupported;}

BOOL DocView::GetCurrentSolidDragState (   )  [inline]

Definition at line 336 of file docview.h. {return m_bSolidDrag;}

DocRect DocView::GetDocViewRect (  Spread *  pSpread  )  [virtual]

To find the rectangle describing the viewport onto the document. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/93 Parameters: pSpread  - the spread that we are interested in [INPUTS] Returns: A DocCoords rectangle describing the viewport onto the document which this view is displaying. I.E. The top left corner of this rectangle is the same as the value returned by GetScrollOffsets() except in DocCoords. Implements View. Definition at line 1612 of file docview.cpp. { ERROR3IF(pViewWindow == NULL, "DocView::GetDocViewRect called when we have no view"); INT32 ClientWidth = 0; INT32 ClientHeight = 0; // Get the width and height of the view in OS units pViewWindow->GetClientSize(&ClientWidth, &ClientHeight); OilRect OilViewRect; OilViewRect.lo.x = 0; OilViewRect.lo.y = -ClientHeight; OilViewRect.hi.x = ClientWidth; OilViewRect.hi.y = 0; // Convert the OSRect into Doc coords return OilViewRect.ToDoc(pSpread, this); }

RenderRegion * DocView::GetFirstRenderRegion (  DocRect &  ClipRect, Spread *  pSpread, OnTopCode  Reason )

RenderRegion's cannt span Spreads, because different Matrices are needed for the Coordinate transforms. This Function (Along with GetNext...) is used to Split a DocRect area into a number of RenderRegions depending on the number of spreads the DocRect spans. First call this function to return the first RenderRegion (there will always be at least one for a valid DocRect), and then call GetNextRenderRegion until it returns NULL (which may be immediately). Repeat the Rendering process for each RenderRegion returned. You do NOT need to call Init/Exit Render as they will be set up for Immediate rendering. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/93 Parameters: ClipRect  - The Rectangle to clip to [INPUTS] pSpread - The Spread that the render region is for Reason - the kind of rendering needed Returns: A Ptr to a RenderRegion to render into. See also: DocView::GetNextRenderRegion() Definition at line 3840 of file docview.cpp. { // Construct the transformation matrix for the spread. Matrix RenderMatrix = ConstructRenderingMatrix(pSpread); // Make render region for intersection between spread and cliprect. // (Cliprect is still d) DocRect SpreadClipRect = pSpread->GetWidePasteboard(this); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&SpreadClipRect); // Clip to spread rectangle, if required if (Reason == ClippedEOR) SpreadClipRect = SpreadClipRect.Intersection(ClipRect); else SpreadClipRect = ClipRect; // Make sure that the clip region is valid after the intersection if ( (SpreadClipRect.IsValid()) && (!SpreadClipRect.IsEmpty()) ) { RenderType rType = RENDERTYPE_NONE; // Initialise it! Mark H switch (Reason) { case CLICKBITMAP: rType = RENDERTYPE_HITDETECT; break; case COLOURBITMAP: rType = RENDERTYPE_COLOURBITMAP; break; case Normal: rType = RENDERTYPE_SCREEN; default: rType = RENDERTYPE_SCREENXOR; break; } CNativeDC* pDC = pViewWindow->GetRenderDC(); ERROR3IF(!pDC, "No allocated DC"); RenderRegion *NewRegion = View::NewRenderRegion(SpreadClipRect, RenderMatrix, pDC, pSpread, rType); if (NewRegion == NULL) TRACEALL( _T("Not enough memory to create render region\n") ); else NewRegion->ImmediateRender(); return NewRegion; } // No render region could be created as the spread clip rect was empty or invalid return NULL; }

Spread * DocView::GetFirstSelectedSpread (   )

Searches for a selected object in the document, and returns a pointer to the spread containing said object. If there are no selected objects then it returns NULL. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to a Spread node in this view's document, or NULL. Errors: - See also: DocView::GetVisibleSpread Definition at line 5005 of file docview.cpp. { // Obtain the current selection, if any. //GetApplication()->UpdateSelection(); SelRange* pSel = GetApplication()->FindSelection(); if (pSel == NULL) return NULL; // Find the first selected object. Node* pFirstSelectedNode = pSel->FindFirst(); // If there isn't one, then there is no spread with sel objects. // Otherwise get the selected object's parent spread. return (pFirstSelectedNode != NULL) ? (Spread*) pFirstSelectedNode->FindParent(CC_RUNTIME_CLASS(Spread)) : NULL; }

BOOL DocView::GetForeBackMode (   )  [virtual]

To find out if background rendering is on. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Returns: TRUE if background rendering is on Implements View. Definition at line 1672 of file docview.cpp. { // As the flag is a BOOL in a bitfield, it seems to like returning -1 or 0 // Therefore, ensure that we always return TRUE or FALSE if (ViewFlags.BackgroundRender == FALSE) return (FALSE); else return (TRUE); }

RenderRegion * DocView::GetNextOnTop (  DocRect *  Rect  )  [static]

This function continues the RenderOnTop loop, returning the next RenderRegion to be considered. If we are not in the outer most rendering loop then this function will return NULL, as it will be up to the top level to re-call everyone with the next render region. It should always be used as part of a rendering loop as described in DocView::RenderOnTop. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/93 Parameters: Rect  - A pointer to the DocRect that the Rendering is to be clipped to [INPUTS] Returns: A RenderRegion if there is another valid one to be rendered into, or NULL if there is not See also: DocView::RenderOnTop Definition at line 4063 of file docview.cpp. { ERROR3IF( OnTopCount <= 0, "GetNextOnTop was called before RenderOnTop was called\n" ); RenderRegion* pRender = OnTopRenderRegion; if (OnTopCount == 1) { // Delete the old render region that is no longer needed if (pRender!=NULL) { pRender->StopRender(); if (( OnTopReason == UnclippedEOR ) || (OnTopReason == ClippedEOR)) { // Detach the Static OnTopRegion View::DeInitOnTopRegion(); } else { delete pRender; } pRender = NULL; OnTopRenderRegion = NULL; } // Find the current view DocView* pView = GetSelected(); if (pView==NULL) return NULL; // Get the next rectangle or region and make a RenderRegion DocRect ClipRect; if (Rect == NULL) { // Get the DocView's viewport and convert it from document coords to // spread coords ClipRect = pView->GetDocViewRect(OnTopSpread); OnTopSpread->DocCoordToSpreadCoord(&ClipRect); } else ClipRect = *Rect; // Go and build a new render region pRender = pView->GetNextRenderRegion(ClipRect, OnTopSpread, OnTopReason); OnTopRenderRegion = pRender; // See if we got one if (!pRender) { // There were no more render regions, so decrement the call count and // return NULL OnTopCount--; return NULL; } // Turn on EORing for the RenderRegion if needed if ((OnTopReason == UnclippedEOR) || (OnTopReason == ClippedEOR)) pRender->SetDrawingMode(DM_EORPEN); // return the render region return pRender; } else { // It is not up to this level to try and find more RenderRegions // so decrement the counter OnTopCount--; // No more RenderRegions here, so return NULL return NULL; } return NULL; }

RenderRegion * DocView::GetNextRenderRegion (  DocRect &  ClipRect, Spread *  pSpread, OnTopCode  Reason )

Used to split a DocRect to be redrawn into one or more RenderRegions. See DocView::GetFirstRenderRegion(DocRect& ClipRect) for more details. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 23/8/93 Parameters: ClipRect  - The Rectangle to clip to [INPUTS] pSpread - The Spread that the render region is for Reason - the kind of rendering needed Returns: A Ptr to a RenderRegion to render into. See also: DocView::GetFirstRenderRegion() Definition at line 3908 of file docview.cpp. { // This needs to be expanded! // It's ok for Windows, but maybe not for other platforms... return NULL; }

BOOL DocView::GetPreventRenderView (   )

As above. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/5/2000 Returns: The state of our flag which prevents the view from rendering Errors: See also: Definition at line 5495 of file docview.cpp. { return m_bPreventRenderView; }

INT32 DocView::GetPrevZoomIndex (   )  const

Returns the index into the zoom tool's tabel of a previous zoom on this DocView. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::SetPrevZoomIndex Definition at line 2375 of file docview.cpp. { return PrevIndex; }

WorkCoord DocView::GetPrevZoomOffset (   )  const

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The scroll offset of this DocView during a previous zoom. Errors: - See also: DocView::SetPrevZoomOffset Definition at line 2457 of file docview.cpp. { return PrevOffset; }

FIXED16 DocView::GetPrevZoomScale (   )  const

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The scale factor of this view as set by a previous zoom. Errors: - See also: DocView::SetPrevZoomScale Definition at line 2417 of file docview.cpp. { return PrevScale; }

RulerPair* DocView::GetpRulerPair (   )  [inline]

Definition at line 579 of file docview.h. { return pRulerPair; }

CNativeDC * DocView::GetRenderDC (   )  [private, virtual]

Access function for the device context of this kernel view object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/09/95 See also: PrintView; View Implements View. Definition at line 5177 of file docview.cpp. { // Ask our CCamView to give us its DC and return that. return pViewWindow->GetRenderDC(); }

CNativeWnd * DocView::GetRenderWindow (   )  [virtual]

Get a pointer to a CNativeWnd window object associated with a DocView. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/95 Returns: Pointer to CNativeWnd (else NULL if none) Definition at line 2186 of file docview.cpp. { if (pViewWindow==NULL) return NULL; return pViewWindow->GetRenderWindow(); }

DocView * DocView::GetSelected (   )  [static]

Find the selected DocView 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 selected DocView object. Definition at line 2207 of file docview.cpp. { return Selected; }

BOOL DocView::GetShowGridState (   )

To find the "Show grid" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: -  [INPUTS] Returns: TRUE - grids are visible in the doc view FALSE - grids are not visible in the doc view See also: Definition at line 4725 of file docview.cpp. { return (ViewFlags.GridShow); }

BOOL DocView::GetShowGuidesState (   )  [inline]

Definition at line 549 of file docview.h. { return (ViewFlags.GuidesShow != 0); }

BOOL DocView::GetShowPrintBorders (   )  [inline]

Definition at line 387 of file docview.h. { return (ViewFlags.PrintBorderShow != 0); }

BOOL DocView::GetSnapToGridState (   )

To find the "Snap to grid" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: -  [INPUTS] Returns: TRUE - snap to grids in the doc view FALSE - don't snap to grids in the doc view See also: Definition at line 4614 of file docview.cpp. { return (ViewFlags.GridSnap); }

BOOL DocView::GetSnapToGuidesState (   )  [inline]

Definition at line 546 of file docview.h. { return (ViewFlags.GuidesSnap != 0); }

BOOL DocView::GetSnapToMagObjectsState (   )

To find the "Snap to magnetic objects" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: -  [INPUTS] Returns: TRUE - snap to magnetic objects in the doc view FALSE - don't snap to magnetic objects in the doc view See also: Definition at line 4688 of file docview.cpp. { return (ViewFlags.MagObjectsSnap); }

BOOL DocView::GetSnapToObjectsState (   )

To find the "Snap to all objects" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: -  [INPUTS] Returns: TRUE - snap to objects in the doc view FALSE - don't snap to objects in the doc view See also: Definition at line 4651 of file docview.cpp. { return (ViewFlags.ObjectsSnap); }

DocCoord DocView::GetTopLeftCoord (   )

Gets a DocCoord for the top left of the view. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The DocCoord for the top left of the view Errors: - See also: - Definition at line 5370 of file docview.cpp. { //First get the document associated with this view Document* pDocument=GetDoc(); //And find the first spread in that document PORTNOTE("spread", "Multi-spread warning!") Spread* pSpread=pDocument->FindFirstSpread(); //Check we got both of those ERROR2IF(pDocument==NULL || pSpread==NULL, DocCoord(0,0), "DocView::GetCentreImportPosition - no document or spread"); //So get the view rectangle DocRect rectView = GetDocViewRect(pSpread); //And find the top left of that rectangle DocCoord dcTopLeft(rectView.lo.x, rectView.hi.y); //Now make that into a spread coordinate DocRect rectSpread = pSpread->GetPasteboardRect(); DocCoord dcToReturn; dcToReturn.x = dcTopLeft.x - rectSpread.lo.x; dcToReturn.y = dcTopLeft.y - rectSpread.lo.y; TRACEUSER( "luke", _T("rcToReturn (%x, %x), dcTopLeft (%x, %x), rectSpead (%x, %x)"), dcToReturn.x, dcToReturn.y, dcTopLeft.x, dcTopLeft.y, rectSpread.lo.x, rectSpread.lo.y ); //And return that DocCoord return dcToReturn; }

ImportPosition DocView::GetTopLeftImportPosition (   )

Gets an import position for the top left of the view. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The import position for the top left of the view Errors: - See also: - Definition at line 5418 of file docview.cpp. { //First get the document associated with this view Document* pDocument=GetDoc(); //And find the first spread in that document PORTNOTE("spread", "Multi-spread warning!") Spread* pSpread=pDocument->FindFirstSpread(); //Now get the DocCoord in the top left of the view DocCoord dcToReturn=GetTopLeftCoord(); //Put all those values into an ImportPosition structure ImportPosition posToReturn; posToReturn.pSpread=pSpread; posToReturn.Position=dcToReturn; //And return that ImportPosition return posToReturn; }

WorkRect DocView::GetViewRect (   )  [virtual]

To find the rectangle describing the viewport onto the document. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 5/7/93 Returns: A WorkCoords rectangle describing the viewport onto the document which this view is displaying. I.E. The top left corner of this rectangle is the same as the value returned by GetScrollOffsets(). Implements View. Definition at line 1572 of file docview.cpp. { ERROR3IF(pViewWindow == NULL, "DocView::GetViewRect called when we have no ViewWindow"); // Get the width and height of the view in OS units INT32 ClientWidth = 0; INT32 ClientHeight = 0; pViewWindow->GetClientSize(&ClientWidth, &ClientHeight); OilRect OilViewRect; OilViewRect.lo.x = 0; OilViewRect.lo.y = -ClientHeight; OilViewRect.hi.x = ClientWidth; OilViewRect.hi.y = 0; // Convert the OSRect into Workarea coords // WorkCoord pos; // pViewWindow->GetScrollOffset(&pos); // pVState->SetScrollPos(pos); // return OilViewRect.ToWork(pos); return OilViewRect.ToWork(pVState->GetScrollPos()); }

Spread * DocView::GetVisibleSpread (   )

Compares the bounding rectangles of Spreads in this view's document with the section of the document currently visible in the view, looking for the largest spread object that is within the view. If none are visible then the function returns NULL. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/94 Returns: A pointer to a Spread, or NULL. NB. hacked to simply return the first spread for the v1 release. Returns: Errors: - See also: DocView::GetFirstSelectedSpread Definition at line 4897 of file docview.cpp. { // Initially we have no visible spread, which has zero area (of course). Spread* pCandidateSpread = NULL; // XLONG xlCandidateArea = 0; // Begin by finding the extent of the viewport. WorkRect wrViewPort = GetViewRect(); // Check that we have a document. if (pDoc == NULL) return NULL; // Find the first node in the document's tree. Node* pNode = pDoc->GetFirstNode(); if (pNode == NULL) return NULL; // Find its first sibling, which should be a NodeDocument. pNode = pNode->FindNext(); if (pNode == NULL) return NULL; ERROR3IF(!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeDocument)), "Can't find a NodeDocument in DocView::GetVisibleSpread"); // Find the first child node of the NodeDocument. pNode = pNode->FindFirstChild(); if (pNode == NULL) return NULL; // Check if it's a chapter, skip it if it isn't. if (pNode->GetRuntimeClass() != CC_RUNTIME_CLASS(Chapter)) { pNode = pNode->FindNext(CC_RUNTIME_CLASS(Chapter)); if (pNode == NULL) return NULL; } // We've found a chapter. Chapter* pChapter = (Chapter*) pNode; // do { // Find the first child of the chapter. pNode = pChapter->FindFirstChild(); if (pNode == NULL) return NULL; // If it isn't a spread then skip it. if (pNode->GetRuntimeClass() != CC_RUNTIME_CLASS(Spread)) { pNode = pNode->FindNext(CC_RUNTIME_CLASS(Spread)); if (pNode == NULL) return NULL; } // Now check all sibling spreads. Spread* pSpread = (Spread*) pNode; /* do { // At last, we found a spread! Get its bounding rectangle in // document coordinates. DocRect drBound = pSpread->GetPageBounds(); // Convert to work coordinates. WorkRect wrBound(drBound.lo.ToWork(pSpread, this), drBound.hi.ToWork(pSpread, this)); // If it intersects with the current viewport then we check if it is // the largest considered so far. WorkRect wrIntersect = wrBound.Intersection(wrViewPort); if (wrIntersect.IsValid() && !wrIntersect.IsEmpty()) { XLONG xlArea = wrIntersect.Width() * wrIntersect.Height(); if (xlArea > xlCandidateArea) { */ // It is the largest so far, so remember it. pCandidateSpread = pSpread; /* xlCandidateArea = xlArea; } } // Find the next sibling spread, if any. pSpread = (Spread*) pSpread->FindNext(CC_RUNTIME_CLASS(Spread)); } while (pSpread != NULL); // Find the next sibling chapter, if any. pChapter = (Chapter*) pChapter->FindNext(CC_RUNTIME_CLASS(Chapter)); } while (pChapter != NULL); */ // If we get here we couldn't find anything! return pCandidateSpread; }

double DocView::GetZoomFactor (   )

Obtain the current zoom factor for this document view. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 17 February 2000 Returns: The current zoom factor for this document view. Errors: See also: GetScaledPixelWidth(), GetPixelWidth(). Definition at line 5455 of file docview.cpp. { return GetScaledPixelWidth().MakeDouble() / GetPixelWidth().MakeDouble(); }

INT32 DocView::GetZoomTableIndex (   )  const

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Returns the value of the zoom table index. Errors: - See also: DocView::SetZoomTableIndex Definition at line 2334 of file docview.cpp. { return ZoomTableIndex; }

BOOL DocView::HandleKeyPress (  KeyPress *  pKeyPress  )  [virtual]

Passes keystroke events to the current drag op, if dragging, or the current tool, if not. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/94 Parameters: A  pointer to the keypress event. [INPUTS] -  [OUTPUTS] Returns: TRUE if the event was handled by this function, or a function it called. Errors: - See also: App::OnKeyPress; Tool::OnKeyPress; Operation::DragKeyPress Definition at line 3472 of file docview.cpp. { // Ignore if system is disabled if (CCamApp::IsDisabled()) return FALSE; // If the system is disabled, ignore // If we are dragging then pass the event on to the current drag operation. if (pCurrentDragOp != NULL) { // Handle the TAB key out here on behalf of ALL drag ops if (m_bSolidDragSupported && pKeyPress->IsPress() && !pKeyPress->IsRepeat()) // I.e. is this a non-auto-repeated key-down event? { switch (pKeyPress->GetVirtKey()) { // TAB key means "change solid dragging mode" case CAMKEY(TAB): { DocView::SolidDragging = !DocView::SolidDragging; m_bSolidDrag = (m_bSolidDragSupported && DocView::SolidDragging); pCurrentDragOp->DragModeChanged(m_bSolidDrag); // update indicator in StatusLine DialogBarOp::SetSystemStateChanged(); break; } } } return pCurrentDragOp->DragKeyPress(pKeyPress, m_bSolidDrag); } // Otherwise give the current tool, if any, the chance to deal with it. Tool* pTool = Tool::GetCurrent(); return (pTool != NULL) ? pTool->OnKeyPress(pKeyPress) : FALSE; }

void DocView::HandleNodeDeletion (  Node *  pNode  )

Intelligently invalidate all the regions gathered so far for this DocView. This performs smart invalidation depending on the number and nature of the regions. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/94 See also: DocView::ForceRedraw; PendingRedraws; SpreadRedraws Definition at line 2768 of file docview.cpp. { // Ask the update list to do its stuff PendingRedrawList.HandleNodeDeletion(pNode); }

BOOL DocView::Init (  void   )

Init a doc view. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 1/9/95 Returns: FALSE if fails Reimplemented from SimpleCCObject. Definition at line 840 of file docview.cpp. { pRulerPair = NULL; pRulerPair = new RulerPair(); ERROR2IF(pRulerPair==NULL,FALSE,"DocView::Init() - failed to create RulerPair"); // update indicator in StatusLine DialogBarOp::SetSystemStateChanged(); return TRUE; }

BOOL DocView::IsMouseMoved (   )

This function finds out if the mouse has moved yet. This is only really useful if you are doing some processing as a result of a mouse move event. If, in the middle of your processing, you discover that the mouse has moved again, you may be able to stop processing immediatly and wait for the next mouse event to arrive in the not too distant future. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/11/94 Returns: TRUE if the mouse has moved, FALSE if not See also: CCamView::IsWaitingMouseMove Definition at line 3747 of file docview.cpp. { PORTNOTETRACE("other","DocView::IsMouseMoved - do nothing"); #ifndef EXCLUDE_FROM_XARALX // If there is a Cam View about, ask it to see if there are more ouse messages // kicking about if (pViewWindow!=NULL) return pViewWindow->IsWaitingMouseMove(); #endif // there was no CamView, so no mouse messages return FALSE; }

ObjectDragTarget DocView::IsPointerOverNode (  NodeRenderableInk **  pThisNode, INT32  Range, BOOL  Interrupt = TRUE, BOOL  bIsColourDrag = FALSE )

to determine whether pointer is over 1 - an objects outline 2 - any visible fill blobs 3 - a simple (non grouped) object Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> (and Will) Date: 23/1/95 Parameters: ThisNode  - ptr to node over if any NULL otherwise [OUTPUTS] Range  - Margin to use in line hittest [INPUTS] Interrupt - TRUE if the Hit Test should be interruptable or not. DMc inserted 6/5/99 For colour drags, you don't want to addess the shadow or bevel controller node, but what's inside Returns: an ObjectDragTarget - FILL/LINE/STARTFILL/ENDFILL Definition at line 2795 of file docview.cpp. { Spread *pSpread=NULL; DocCoord pMousePos; // get the current spread and mouse pos if(!GetCurrentMousePos(&pSpread, &pMousePos)) return NO_TARGET; // mouse pos to be used at end of drag DragPos = pMousePos; // ouch ! if(!pSpread) return NO_TARGET; // See if we are close to the TextStory caret - We can't hittest on it as it is only a blob if (TextStory::GetFocusStory() != NULL) { CaretNode* pCaret = TextStory::GetFocusStory()->GetCaret(); Matrix matrix; if ((pCaret != NULL) && pCaret->IsSelected() && (pCaret->GetStoryAndCharMatrix(&matrix)!=FALSE)) { // get the bounds of the caret path for the blob bounds Path* pCaretPath = pCaret->CreatePath(&matrix); if (pCaretPath != NULL) { INT32 CloseSlot = 0; double mu = 0.0; if (pCaretPath->IsPointCloseTo(pMousePos, Range*Range, &CloseSlot, &mu)) { *pThisNode = pCaret; delete pCaretPath; return FILL_TARGET; } delete pCaretPath; } } } // Allow the hit-test to be interrupted if the mouse moves! Node* pInterruptedNode = NULL; NodeRenderableInk * pCompoundNode = NULL; NodeRenderableInk* pSimpleNode = NodeRenderableInk::FindSimpleAtPoint(pSpread, pMousePos, NULL, Interrupt ? &pInterruptedNode : NULL); if (pInterruptedNode!=NULL) // hit-test was interrupted... pSimpleNode=NULL; // Now we have the 'Simple' node that the pointer was over. // If we can we should use any Selected nodes, so lets see if // this node or any of it's parents are selected. // We will stop if we get to the layer. if (pSimpleNode != NULL) // Did we hit anything ? { Node* pSelNode = NULL; if ((ClickModifiers::GetClickModifiers().Constrain) || pSimpleNode->IsSelected()) { // The node we hit was selected, so we will just use that pSelNode = pSimpleNode; } else { // Hunt up the tree, looking for a selected parent Node* pParent = pSimpleNode->FindParent(); while (pParent != NULL && !pParent->IsLayer()) { if (pParent->IsSelected()) { // Found a selected parent, so we'll use that // don't do it for shadow controller nodes, or bevel nodes if ((!pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeShadow)) && !pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevel))) || !bIsColourDrag) { pSelNode = pParent; } else { pSelNode = pSimpleNode; } break; } pParent = pParent->FindParent(); } } if (pSelNode != NULL) { // We will use the selected node in preference to anything else pSimpleNode = (NodeRenderableInk*)pSelNode; } else { // We didn't find any selected nodes, so we will try and apply // to a Parent group of the hit node. // This function will return the same node, if it has no parent group // DMc 6/5/99 // change to hit testing for drags - don't do a compound node // for bevel controller or shadow controller nodes pCompoundNode = NodeRenderableInk::FindCompoundFromSimple(pSimpleNode); pSimpleNode = pCompoundNode; if ((!pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeShadow)) && !pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeBevel))) || !bIsColourDrag) { pSimpleNode = pCompoundNode; } } } // we can pass this back to the drag target *pThisNode = pSimpleNode; // get the object bounds for this object DocRect pSimpleBounds; if(pSimpleNode) pSimpleBounds = pSimpleNode->GetBoundingRect(); else pSimpleBounds.MakeEmpty(); AttrColourDrop *Attrib = new AttrColourDrop(pMousePos,pSimpleBounds,DocColour(COLOUR_TRANS)); // this will sort out whether we are over any fill blobs // pThisNode will then point to the relevant Node // OverFill is the FillControl type we are currently over FillControl OverFill = AttrFillGeometry::DoColourDropTest(Attrib,pThisNode,NULL); delete Attrib; ObjectDragTarget TargetHit; // return the appropriate colour drag target switch(OverFill) { case FILLCONTROL_STARTPOINT: TargetHit = STARTCOL_TARGET; break; case FILLCONTROL_ENDPOINT: case FILLCONTROL_SECONDARYPOINT: TargetHit = ENDCOL_TARGET; break; case FILLCONTROL_ENDPOINT2: TargetHit = ENDCOL2_TARGET; break; case FILLCONTROL_ENDPOINT3: TargetHit = ENDCOL3_TARGET; break; case FILLCONTROL_MANY: TargetHit = MANY_TARGET; break; case FILLCONTROL_NULL: TargetHit = FILL_TARGET; break; default: TargetHit = FILL_TARGET; break; } // BODGE ??? This should all change when we can do hit testing on lines. if(pSimpleNode) { // we're over an object - we'll see how close to its path we are Path* pPath = NULL; if (IS_A(pSimpleNode, NodePath)) { // get the node as a NodePath NodePath* pNPath = (NodePath*) pSimpleNode; pPath= &(pNPath->InkPath); } else if (pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeSimpleShape))) { // get the node as a NodeSimpleShape NodeSimpleShape * pNShape = (NodeSimpleShape*) pSimpleNode; pPath= &(pNShape->InkPath); } else if (pSimpleNode->IsKindOf(CC_RUNTIME_CLASS(NodeRegularShape))) { NodeRegularShape * pNShape = (NodeRegularShape*) pSimpleNode; pNShape->BuildShapePath(&pPath); } // we'll use the snap range to determine whether we are close to the path or not if(pPath) { INT32 CloseSlot = 0; double mu = 0.0; if (pPath->IsPointCloseTo(pMousePos,Range*Range, &CloseSlot, &mu)) { return LINE_TARGET; // yes we are } } } return TargetHit; }

BOOL DocView::IsSingleClickReallyQuad (   )  const

For determining wether the current single click event is really a quad click It only makes sense to call this when you are processing a click event! Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the last click event was a quad click. FALSE if not, or the attached oil view is not a screen view. See also: DocView::IsSingleClickReallyTriple() Definition at line 5070 of file docview.cpp. { // Salary check if (pViewWindow == NULL) { ERROR3("No attached oil view"); return FALSE; } return pViewWindow->IsSingleClickReallyQuad(); }

BOOL DocView::IsSingleClickReallyTriple (   )  const

For determining wether the current single click event is really a triple click It only makes sense to call this when you are processing a click event! Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the last click event was a triple click. FALSE if not, or the attached oil view is not a screen view. See also: DocView::IsSingleClickReallyQuad() Definition at line 5040 of file docview.cpp. { // Salary check if (pViewWindow == NULL) { ERROR3("No attached oil view"); return FALSE; } return pViewWindow->IsSingleClickReallyTriple(); }

RenderRegion* DocView::NewRenderRegion (  DocRect  , Matrix &  , CNativeDC *  , Spread *  , RenderType  )  [private]

void DocView::NotifyBoundsChanged (  BOOL  bNewValue = TRUE  )  [inline]

Definition at line 615 of file docview.h. {m_bBoundsChanged = (m_bBoundsChanged || bNewValue);}

Spread * DocView::OilToSpreadCoord (  OilCoord  oilpos, DocCoord *  pdocpos )

Combines the functions of FindEnclosingSpread and OilCoord::ToDoc. Finds which spread an OilCoord is in and then computes the DocCoord of that position within the spread. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: oilpos  - OilCoord to find spread and DocCoord for. [INPUTS] pdocpos  - Pointer to DocCoord to receive DocCoord. [OUTPUTS] Returns: Spread* - Pointer to spread in which pdocpos is valid. Definition at line 4158 of file docview.cpp. { // Preconditions ERROR2IF(this==NULL,NULL,"DocView::OilToDoc called on NULL pointer"); // Clear the destination DocCoord in case it all goes horribly wrong... *pdocpos = DocCoord(0,0); // Find the spread that contains DocPos, if none then return NULL immediately... Spread *pSpread = FindEnclosingSpread(oilpos); if (pSpread != NULL) { // Convert the OilCoord into document coords... *pdocpos = oilpos.ToDoc(pSpread, this); // and then into Spread coords... pSpread->DocCoordToSpreadCoord(pdocpos); } // Return pointer to enclosing spread to caller. return pSpread; }

void DocView::OnClick (  OilCoord  PointerPos, ClickType  Click, ClickModifiers  Mods )

Convert click coordinates into DocCoords and pass them on to the current tool. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: PointerPos  - Position of click from OS [INPUTS] Click - Type of click (single, double or drag) Mods - Other inputs which modify the meaning of the click Definition at line 3240 of file docview.cpp. { // Ignore if system is disabled if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore // grab the focus if it's stuck in a control somewhere DialogManager::DefaultKeyboardFocus(); // Find the spread in which the click happened Spread *pSpread = FindEnclosingSpread(PointerPos); if (pSpread == NULL) { ERROR3("Could not find spread in which the click happened"); return; // Exit reasonably nicely } // When the user clicks on a spread which is not the selected spread then this spread becomes // selected and the selection is cleared. //Document::SetSelectedSpread(pSpread); Document::SetSelectedViewAndSpread(pDoc, this, pSpread); //GetApplication()->FindSelection()->SetSelectedSpread(pSpread); // First of all convert the OilRect into device coords DocCoord DocPos = PointerPos.ToDoc( pSpread, this ); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&DocPos); // Store away the WorkCoord version of this click in the DocView for later extraction by // GetClickWorkCoord(); LastWorkClick = PointerPos.ToWork( pVState->GetScrollPos() ); ViewFlags.WorkClickCached = TRUE; // Cached WorkCoord is valid. // Check the click mods to see if they specify an operation which we can do directly here if (Mods.IsHandledByTool()) { // Now call the current tool with the DocCoord click point // Graham 18/6/96: When one button clicks while another one is dragging // we call the current drag operation, not the tool if (Mods.ClickWhileDrag) { //First make sure there is a current drag operation ERROR3IF(Operation::GetCurrentDragOp()==NULL, "DocView::OnClick - no current drag operation"); //Now call the current drag operation. //If the current drag operation is not a transform operation, this //will call the empty virtual function Operator::OnClickWhileDragging. Operation::GetCurrentDragOp()->OnClickWhileDragging(PointerPos, Click, Mods, m_bSolidDrag); } else if (Mods.PushCentreTool) { // Matt 16/11/2000 - Use the push tool/auto-screen-centrey-tool when required OpPush* pOpPush = new OpPush; ERROR3IF(!pOpPush,"Out of memory in DocView() -> Cannot create PushOp"); // Matt 12/01/2001 // Change the cursor to show the hand icon PushToolCursorID = CursorStack::GPush( &m_PushCursor, TRUE ); // Start the drag operation and pass in the Anchor Point to the push operation pOpPush -> DoDrag( DocPos ); } else { Tool* pCurrentTool = Tool::GetCurrent(); if(pCurrentTool) { pCurrentTool->OnClick(DocPos, Click, Mods, pSpread); } else ERROR3("No current tool in DocView::OnClick()!"); } // --------------------------------------------------------------------------- // Do special handling for menu clicks // Allow the Selector to do it's normal stuff for "Click" events and "Up" events // So that menu clicks perform selection as required by Windows UI guidelines // On the up stroke show the context menu if (Mods.Menu) { #ifndef STANDALONE Tool* pSelector = Tool::FindTool(TOOLID_SELECTOR); ERROR3IF(pSelector==NULL, "ARGH! No Selector when DocView got a menu click!"); Tool* pCurrentTool = Tool::GetCurrent(); if (pSelector!=pCurrentTool && (Click == CLICKTYPE_SINGLE || Click == CLICKTYPE_UP) && // Don't allow menu drags while selector not current !Mods.ClickWhileDrag && Operation::GetCurrentDragOp()==NULL) { pSelector->OnClick(DocPos, Click, Mods, pSpread); } // On the up stroke if (Click==CLICKTYPE_UP && !Mods.ClickWhileDrag) { #ifdef PHOTOSHOPPLUGINS // As we are just about to invoke a context menu, check that the plug-in manager has its list // of available plug-ins otherwise, go and get it now as we are just about to need it. // Must do it now before even the hint of a context menu is started as the context // menus stack the automatic menu id and then restore it after they are destroyed. // This is bad if our main plug in menu ids are in this range! // We have to do it generally as at this point we don't know whether we are over a node // such as NodeBitmap which requires it. PlugInManager* pManager = GetApplication()->GetPlugInManager(); if (pManager) pManager->CheckHaveDetailsOnPlugIns(); #endif // PHOTOSHOPPLUGINS // Pop up the context sensitive view menu. ViewContextMenu* pViewPopup = new ViewContextMenu; pViewPopup->ShowOverView(pSpread, DocPos, Mods); } #endif } // --------------------------------------------------------------------------- } else { if (Click==CLICKTYPE_UP) { if (Mods.EditObject) { // Find the node under the pointer and ask it what its favourite editing // tool is. } else if (Mods.FullScreen) { // Use the full screen toggle. OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor( OPTOKEN_VIEWFULLSCREEN ); if (pOpDesc) pOpDesc->Invoke(); } else if (Mods.ZoomIn) { // Try to create an instance of the zoom operation. OpZoom* pZoomOp = new OpZoom; if (pZoomOp == NULL) { // We ran out of memory, so sorry. InformError(_R(IDE_NOMORE_MEMORY)); return; } // Zoom in or out around the mouse position. if (Mods.Adjust) { pZoomOp->ZoomOut(LastWorkClick); } else { pZoomOp->ZoomIn(LastWorkClick); } } else if (Mods.PushCentreTool) { // Then the user wants us to centre the view about their mouse position } } } ViewFlags.WorkClickCached = FALSE; // Cached WorkCoord is no longer valid! }

void DocView::OnLoadedView (   )

Called by CCamView as part of its "initial update" function provided that this view onto a document has been previously saved and reloaded. Currently does nothing, but one day - who knows. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 27/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::OnNewView; CCamView::OnInitialUpdate; struct ViewState Definition at line 1503 of file docview.cpp. { // empty for now }

void DocView::OnMouseMove (  OilCoord  Pos, ClickModifiers  mods )

Converts the mouse position into document coordinates, then calls the OnMouseMove() function of the currently selected tool with this information. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Updated by Tim & Rik) Date: 14 Oct 93 Parameters: Pos  - The position of the mouse, in OIL layer coordinates. [INPUTS] mods - which buttons/keys are down. Definition at line 3425 of file docview.cpp. { // Ignore if system is disabled if (CCamApp::IsDisabled()) return; // If the system is disabled, ignore Spread *pSpread = FindEnclosingSpread(Pos); if (pSpread != NULL) { // Convert from OIL coordinates to document coordinates DocCoord DocPos = Pos.ToDoc(pSpread, this ); // Convert the coord to spread coords pSpread->DocCoordToSpreadCoord(&DocPos); // Call the currently selected tool. Tool* pTool = Tool::GetCurrent(); //Is there a currently selected tool? if (pTool != NULL) { // And pass the mouse move event to the tool. pTool->OnMouseMove(DocPos, pSpread, mods); } else //No, there's no currently selected tool. We're in Camelot so that's worrying. //Show an error. ERROR3("No current tool in DocView::OnMouseMove()!"); } }

void DocView::OnNewView (   )

Called by CCamView as part of its "initial update" function provided that this view onto a document has not been previously saved and reloaded. Sets the defaults, eg. scroll offset, for newly created views. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::OnLoadedView; CCamView::OnInitialUpdate; struct ViewState Definition at line 1425 of file docview.cpp. { // Only set the scroll offsets if they have not been set yet. // eg. When a document is loaded it is possible that it has already set the Scroll Offsets // to something sensible. WorkCoord CurrentOffset = GetScrollOffsets(); if ((CurrentOffset.x==0) && (CurrentOffset.y==0)) { // Find the first page in the document and set the scroll offsets so that the top // left corner of the page is in the top left corner of the view. Node* pSearchNode = Node::DocFindFirstDepthFirst(pDoc); while (pSearchNode != NULL && !pSearchNode->IsSpread()) pSearchNode = pSearchNode->DocFindNextDepthFirst(); ERROR3IF(pSearchNode == NULL, "ViewStateChanged: Can't find first spread."); if (pSearchNode != NULL) { Spread *pSpread = (Spread *)pSearchNode; // OK, found the spread. Go look for the first page Page *pPage = pSpread->FindFirstPageInSpread(); ERROR3IF(pPage == NULL, "ViewStateChanged: Can't find first page in spread."); if (pPage != NULL) { // OK, found the first page. // Read its position in the spread, translate into Doc Coord space DocRect PageRect = pPage->GetPageRect(); DocCoord TopLeft(PageRect.lo.x, PageRect.hi.y); pSpread->SpreadCoordToDocCoord(&TopLeft); // Then translate to work coords WorkCoord TopLeftWrk = TopLeft.ToWork(pSpread, this); // Shift the corner of the page 1/8th of an inch into the window. TopLeftWrk.x -= (72000/8); TopLeftWrk.y += (72000/8); // Only set the new scroll offsets if valid. Otherwise we will get an Error2. // We may try to set illegal values now that we allow zero sized pasterboards. if (TopLeftWrk.x >= (XLONG)0 && TopLeftWrk.y <= (XLONG)0) { // And scroll to place that offset at the top left of the view window SetScrollOffsets(TopLeftWrk, FALSE); } } } } DialogBarOp::SetSystemStateChanged(); // Change the View State so that it is no longer marked as new PORTNOTE("other","Removed ViewState usage") #ifndef EXCLUDE_FROM_XARALX if (pVState!=NULL) pVState->IsNewView = FALSE; #endif }

void DocView::RenderEntireView (  RenderRegion *  pRRegion, Spread *  pSpread )

To render a Document through a given RenderRegion. This differs from your regular RenderView service in that it pays no mind as to how long things take. Once you start this function off it will run until it renders the lot. The reason for this is that it is designed for use with the brush tool. Here we will need to render the entire view into an offscreen bitmap which is then used to with the brush. It serves as an alternative when we cannot simply blit the contents of the screen. I don't really recommend using this function in other circumstances as if you have a complex document it will probably lock up for a while. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/8/2000 Parameters: pRRegion  - the region to use for rendering the spread [INPUTS] Definition at line 2010 of file docview.cpp. { DocRect ClipRect; Matrix ViewTransform = ConstructRenderingMatrix(pSpread); // Scroll offsets etc may have changed, so transfer matrix. pRRegion->SetMatrix(ViewTransform); // Get the region to clip all the rendering to ClipRect = pRRegion->GetClipRect(); // If the state is NULL I take this to mean that the RenderRegion has only just been // created and I will therefore ensure that the window background is rendered by rendering // all the "paper" parts of the document. That is, the pages, chapters, pasteboard, etc... if (pRRegion->IsPaperRendered == FALSE) { // Render all paper nodes from there into the real render region pRRegion->SaveContext(); RenderPaper(pRRegion, pSpread); pRRegion->RestoreContext(); // The Paper is now done pRRegion->IsPaperRendered = TRUE; } // Now render all the ink (non-paper) parts of the document. pRRegion->RenderTree(pSpread, FALSE); // Reset state to new posn in tree. pRRegion->StopRender(); }

RenderRegion * DocView::RenderOnTop (  DocRect *  Rect, Spread *  pSpread, OnTopCode  Reason )  [static]

Marks the start of an 'On Top' rendering loop. On Top simply means that the rendering will be done directly over the top of anything else that happens to be there, without causeing a redraw from the bottom of the tree. This functions main use is drawing on the EOR blobs that show selection, are part of a tool or are there to show a drag is in progress. This function could also be used to draw objects that we know will be placed on top of all other objects (ie a new object, being drawn for the first time). You should always use a loop like the one below :- MonoOn RenderRegion* pRegion = DocView::RenderOnTop( MyRect, EOR ); while ( pRegion ) { Do your EOR rendering in here pRegion = DocView::GetNextOnTop( MyRect ); } MonoOff This bit of code will loop through all the invalid regions that the OS needs redrawing as well as all the rectangles that Camelot splits a region into itself. IMPORTANT : Because this is a loop, you should not change the state of any data within it, because it will then be different the second time the code in the loop is executed. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 18/8/93 Parameters: Rect  - The DocRect of the area that needs to be redrawn [INPUTS] Reason - EOR or Normal or CLICKBITMAP Returns: A pointer to a render region, or NULL if a valid RRegion could not be generated (or there were none to make in the first place See also: DocView::GetNextOnTop Definition at line 3953 of file docview.cpp. { RenderRegion* pRender = NULL; //RenderRegion::GetCurrent(); if ( OnTopCount == 0 ) { // Find out about the current view DocView* pCurrentView = GetSelected(); // If there is no current view, then return NULL if (pCurrentView==NULL) return NULL; // We should only hand out render regions if the view is not in the process of dying if (pCurrentView->IsViewDying) return NULL; // if the spread is NULL then this is bad if (pSpread==NULL) return NULL; // Find the first rectangle or region that needs redrawing and make // a render region for it. DocRect ClipRect; if (Rect == NULL) { // Get the DocView's viewport, in Spread Coords ClipRect = pCurrentView->GetDocViewRect(pSpread); pSpread->DocCoordToSpreadCoord(&ClipRect); } else ClipRect = *Rect; // Make sure that the clip rect is valid if (!ClipRect.IsValid()) { // The Clip rect was not a valid rectangle ERROR3("RenderOnTop was asked to render to an invalid rect."); return NULL; } // Go and get a render region based on all this info pRender = pCurrentView->GetFirstRenderRegion(ClipRect, pSpread, Reason); // stop now if we did not get one if ( !pRender ) return NULL; // Set the static Reason code so that all future calls to RenderOnTop and // GetNextOnTop will do the same thing OnTopReason = Reason; OnTopSpread = pSpread; OnTopRenderRegion = pRender; // Turn on EORing for the RenderRegion if needed if (( OnTopReason == UnclippedEOR ) || (OnTopReason == ClippedEOR)) pRender -> SetDrawingMode( DM_EORPEN ); // Increment the Static Counter so that we know how many times this // function has been called OnTopCount++; // return the render region return pRender; } else { // Get the current RenderOnTop RenderRegion pRender = OnTopRenderRegion; // If there is no current render region, then we had better stop now if (!pRender) return NULL; // Increment the Static Counter so that we know how many times this // function has been nested through OnTopCount++; // if we want to be EORing, then make sure that EORing has been switched on if (( OnTopReason == UnclippedEOR ) || (OnTopReason == ClippedEOR)) pRender -> SetDrawingMode( DM_EORPEN ); // return the current render region return pRender; } }

BOOL DocView::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. 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] pRRegion - pointer to the render region to use. -  [OUTPUTS] Returns: - See also: View, PrintView Reimplemented from View. Definition at line 5265 of file docview.cpp. { return TRUE; }

void DocView::RenderSelectBlobs (  DocRect  Rect, Spread *  pSpread )

Renders the Selection blobs of all the currently selected objects. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/93 Parameters: Rect  - The Clipping Rectangle of the bit to draw [INPUTS] See also: DocView::OnDraw Definition at line 3663 of file docview.cpp. { // TRACEUSER("Gerry", _T("RenderSelectBlobs (%d, %d) - (%d, %d)\n"), Rect.lo.x, Rect.lo.y, Rect.hi.x, Rect.hi.y); // Only render blobs if there is a selection, and this spread owns it. SelRange* Selected = GetApplication()->FindSelection(); // Karim 29/06/2000 // PromoteToParent should never be set TRUE on the selection range, outside // of code in which its modifications are required. // I have included a TRACE statement here, as a 'quiet' note to programmers, // should this occur. RangeControl rc = Selected->GetRangeControlFlags(); if (rc.PromoteToParent) { TRACE( _T("DocView::RenderSelectBlobs; PromoteToParent is TRUE! Read inline comment for details.\n") ); rc.PromoteToParent = FALSE; Selected->Range::SetRangeControl(rc); } //PostProcessorStack* pStack = Selected->GetPostProcessorStack(); //ListRange* pLevel = pStack->GetNewLevelRange(FALSE); Node* pNode = Selected->FindFirst(); //Node* pNode = pLevel->FindFirst(); if ((pNode == NULL) || ( pNode->FindParentSpread() != pSpread)) // This spread does not own selection return; // Go find the blob manager BlobManager* BlobMgr = GetApplication()->GetBlobManager(); ERROR3IF( BlobMgr == NULL, "BlobManager unexpectedly turned out NULL!"); // Go and render the blobs RenderRegion* pRender = DocView::RenderOnTop( &Rect, pSpread, ClippedEOR ); while (pRender) { pNode = Selected->FindFirst(); //pNode = pLevel->FindFirst(); while (pNode != NULL) { ERROR3IF(!pNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk)), "Selected node is not a NodeRenderableInk in DocView::RenderSelectBlobs()"); // Make sure that the nodes bounding box overlaps the redraw box //if ( Rect.IsIntersectedWith(((NodeRenderableInk*)pNode)->GetBlobBoundingRect())) // tell the node to draw in its selection blobs // ((NodeRenderableInk*)pNode)->RenderSelectBlobs(); // Render those blobs BlobMgr->RenderMyBlobs(&Rect, pSpread, (NodeRenderable*)pNode); // Find the next selected node to render pNode = Selected->FindNext(pNode); //pNode = pLevel->FindNext(pNode); } // Get the next render region pRender = DocView::GetNextOnTop(&Rect); } //delete pLevel; // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void DocView::RenderView (  RenderRegion *  pRRegion, Matrix &  ViewTransform, Spread *  pSpread, BOOL  bPrintPaper, BOOL  fDeleteRegionAfter = TRUE, BOOL  bForceImmediate = FALSE )  [private]

To render a Document through a given RenderRegion. The dominating factor in this routine is that it renders the document with as little time overhead as possible. Obviously, this is mainly down to RenderRegions and the tree scanning routines working fast but we can do a bit to help. This routine is called directly by other functions in DocView and externally from the Background redraw Idle event processor. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 19/5/93 Parameters: pRRegion  - the region to use for rendering the spread [INPUTS] ViewTransform - the matrix to use when transforming document coordinates into Window coordinates. pSpread - the spread we are rendering with this render region. bPrintPaper should be TRUE if paper-like items need to be rendered e.g. page marks, blobs, etc, or FALSE otherwise. A TRUE value also will enable background rendering, so long as Viewflags.BackgroundRender is also set. fDeleteRegionAfter --- by default TRUE - if so then this function will deallocate the RenderRegion passed to it when it has been comletely rendered. Definition at line 1735 of file docview.cpp. { Node* pNode = NULL; BOOL CleanUp = TRUE; // TRUE if cleanup at end, FALSE if dont BOOL IsMoreBands = FALSE; DocRect ClipRect; BOOL HasRendered = FALSE; BOOL Continue = TRUE; BOOL bPaperRenderedThisTime = FALSE; // Record time when rendering started StartTime.Sample(); // Scroll offsets etc may have changed, so transfer matrix. pRRegion->SetMatrix(ViewTransform); // Prepare to find out whether any bounds in selection are changed during redraw m_bBoundsChanged = FALSE; // Start the first band if (!pRRegion->SetFirstBand()) { goto ExitRenderNoStop; } do { // See if we are actually waiting for memory if (pRRegion->IsWaitingForRAM) { // See if we can get the memory yet ? pRRegion->GetNextBand(); if (pRRegion->IsWaitingForRAM) break; // Nope still not enough } // Tell the RenderRegion that I am going to start rendering. if (!pRRegion->StartRender()) { TRACEALL( _T("StartRender failed in RenderView\n") ); // will be deleted quickly goto ExitRenderNoStop; // skip StopRender call } // If the state is NULL I take this to mean that the RenderRegion has only just been // created and I will therefore ensure that the window background is rendered by rendering // all the "paper" parts of the document. That is, the pages, chapters, pasteboard, etc... if (pRRegion->IsPaperRendered == FALSE) { if (bPrintPaper) { // Render all paper nodes from there into the real render region pRRegion->SaveContext(); RenderPaper(pRRegion, pSpread); pRRegion->RestoreContext(); if (pRRegion->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. pRRegion->SetClean(TRUE, FALSE); } } #ifdef _DEBUG // TEMP BODGE! DO NOT RELEASE! //if (pRRegion->IsKindOf(CC_RUNTIME_CLASS(GRenderRegion))) // ((GRenderRegion*)pRRegion)->DebugTrace(); #endif // The Paper is now done pRRegion->IsPaperRendered = TRUE; bPaperRenderedThisTime = TRUE; } // ------------------------------------------ // Call the central tree renderer... Continue = pRRegion->RenderTree(pSpread, ViewFlags.BackgroundRender && !bForceImmediate // Only timeslice if bgr && ! rendering paper ); // ------------------------------------------ // Reset state to new posn in tree. BOOL bRendered = pRRegion->StopRender(); HasRendered = HasRendered || bRendered; // Dragging blobs/boxes. Operation* pDragOp = Operation::GetCurrentDragOp(); if (pDragOp) pDragOp->RenderDragBlobs(pRRegion->GetClipRect(), pSpread, m_bSolidDrag); // Assume we ran out of time IsMoreBands = FALSE; // If we did not run out of time, prepare the next band if (Continue) { IsMoreBands = pRRegion->GetNextBand(); if (pRRegion->IsWaitingForRAM) break; // Leave this region for a while } } while (IsMoreBands); // Could jump straight to here if the render region was waiting for some ram to show up ExitRenderNoStop: pNode = pRRegion->GetRenderState(); // Find out whether all bounds have become cached during this render // If so, update the SelRange and tell all tools the SelRange has changed // This handles the situation where effects change their bounds during rendering if (m_bBoundsChanged) { // Only broadcast to the rest of the program if we're not trying to be quick Camelot.FindSelection()->Update(!Operation::GetQuickRender(NULL)); } // Find out the rectangle of the whole unbanded region DocRect BlobClipRect = pRRegion->GetRegionRect(); BOOL IsRegionFinished = CleanUp && !pRRegion->IsWaitingForRAM && pRRegion->IsLastBand && !pNode; // If the region has finished rendering, delete it, otherwise update its context node. if (IsRegionFinished) { if (fDeleteRegionAfter) { // Unlink the RenderRegion from list BOOL InList = Camelot.DeleteRenderRegion(pRRegion); ERROR2IF(!InList, (void)0, "DocView::RenderView tried to delete a RenderRegion not in list"); delete pRRegion; } } // Draw the blobs if we are the "selected" view. // And we're not solid dragging... if (this == Selected && !(pCurrentDragOp!=NULL && m_bSolidDrag)) { // Tool & selection blobs. // HasRendered really means "Has blitted and wiped out previous blobs within the changedrect..." // So we should redraw the blobs inside the changed rect (note that the paper chanegd rect // needs to be derived differently than the ink changed rect) // BUT we don't know here what the changed rect is! // SO, all we can do is wait until the render is over then put the blobs back on // if (HasRendered || bPaperRenderedThisTime)) if (IsRegionFinished) { Tool* pTool = Tool::GetCurrent(); if (pTool) { pTool->RenderToolBlobs(pSpread, &BlobClipRect); } // Render the Currently selected objects selection blobs RenderSelectBlobs(BlobClipRect, pSpread); } } }

void DocView::ResetRenderingStartTime (   )  [inline]

Definition at line 350 of file docview.h. { StartTime.Sample(); }

void DocView::ScrollToShow (  DocRect *  pBoundingBox, DocCoord  Direction )

Scrolls the currently selected view to ensure that edge(s) of pBoundingBox are visible. The Direction argument tells us which edges. If the movement was towards the top of the screen then we need to make the top edge of the DocRect visible. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/1996 Parameters: pBoundingBox  - DocRect to show in spread coords [INPUTS] Direction - Direction of movement -  [OUTPUTS] Returns: - If an ordinate of Direction is zero then we ignore it and no scrolling is done in that direction. Definition at line 1067 of file docview.cpp. { ERROR3IF(pBoundingBox == NULL,"pBoundingBox is NULL"); if (pBoundingBox == NULL) return; DocCoord Point; if (Direction.x > 0) Point.x = pBoundingBox->hi.x; else if (Direction.x < 0) Point.x = pBoundingBox->lo.x; else Point.x = 0; if (Direction.y > 0) Point.y = pBoundingBox->hi.y; else if (Direction.y < 0) Point.y = pBoundingBox->lo.y; else Point.y = 0; // call ScrollToShowAux which does the actual work ScrollToShowAux(&Point, DocCoord(0,0)); }

void DocView::ScrollToShow (  DocRect *  RectToShow  )

Scrolls the currently selected view to ensure that as much as possible of RectToShow is visible. If the entire rect cannot be seen, then it will scroll the minimum distance in order to make a part of it visible. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/3/96 Parameters: RectToShow  - Rectangle to show, in spread coords [INPUTS] i.e. Unlike the other ScrollToShow functions, this actually scrolls to show the given rectangle, as opposed to single points. Definition at line 941 of file docview.cpp. { ERROR3IF(RectToShow == NULL, "Illegal NULL params"); Spread* pSpread = GetFirstSelectedSpread(); if (pSpread == NULL) return; // The TRUE argument for GetPasteBoardRect means that the result gets // pixelised. Otherwise the clipping code below doesn't work properly DocRect ViewRect = (GetDocViewRect(pSpread)).ToSpread(pSpread, this); // If the rect is entirely visible, or as much as possible of it is visible, then don't scroll! if (ViewRect.ContainsRect(*RectToShow) || RectToShow->ContainsRect(ViewRect)) return; // Find the distance of the rectangle from each edge of the view rect, and work out // the distance we should scroll the view by DocCoord Offset(0,0); // If we need to scroll in x axis, work out by how much // "Need to scroll" means: The target rect lies outside the view rect on *only* one side if ( (RectToShow->lo.x < ViewRect.lo.x || RectToShow->hi.x > ViewRect.hi.x) && // Outside !(RectToShow->lo.x < ViewRect.lo.x && RectToShow->hi.x > ViewRect.hi.x) // On one side only ) { // Find the distance needed to scroll the left edge of target to the left edge of the view // and the right edge to the right edge. INT32 Diff1 = RectToShow->lo.x - ViewRect.lo.x; INT32 Diff2 = RectToShow->hi.x - ViewRect.hi.x; // We need to scroll by the smaller of these 2 distances INT32 AbsDiff1 = ABS(Diff1); INT32 AbsDiff2 = ABS(Diff2); Offset.x = (AbsDiff1 < AbsDiff2) ? Diff1 : Diff2; } // Repeat the above for the Y axis if ( (RectToShow->lo.y < ViewRect.lo.y || RectToShow->hi.y > ViewRect.hi.y) && // Outside !(RectToShow->lo.y < ViewRect.lo.y && RectToShow->hi.y > ViewRect.hi.y) // On one side only ) { // Find the distance to scroll to the left and right edges INT32 Diff1 = RectToShow->lo.y - ViewRect.lo.y; INT32 Diff2 = RectToShow->hi.y - ViewRect.hi.y; // We need to scroll by the smaller of these 2 distances INT32 AbsDiff1 = ABS(Diff1); INT32 AbsDiff2 = ABS(Diff2); Offset.y = (AbsDiff1 < AbsDiff2) ? Diff1 : Diff2; } // Ensure we don't scroll off the pasteboard area. This should really be done by // SetScrollOffsets, but it appears that function is complete pants, and I've already // had to change over 60 files because of poorly designed fundamental code, so // I really don't have time to fix yet more problems. DocRect PasteRect = (pSpread->GetPasteboardRect(TRUE)).ToSpread(pSpread, this); if (Offset.x < 0) { if (ViewRect.lo.x + Offset.x < PasteRect.lo.x) Offset.x = ViewRect.lo.x - PasteRect.lo.x; } else { if (ViewRect.hi.x + Offset.x > PasteRect.hi.x) Offset.x = PasteRect.hi.x - ViewRect.hi.x; } if (Offset.y < 0) { if (ViewRect.lo.y + Offset.y < PasteRect.lo.y) Offset.y = ViewRect.lo.y - PasteRect.lo.y; } else { if (ViewRect.hi.y + Offset.y > PasteRect.hi.y) Offset.y = PasteRect.hi.y - ViewRect.hi.y; } // determine if we need to scroll or not, if (Offset != DocCoord(0,0)) { WorkCoord ScrollOffset; WorkCoord WorkOffset; WorkOffset.x = (XLONG) (MakeXLong(Offset.x) * GetViewScale()); WorkOffset.y = (XLONG) (MakeXLong(Offset.y) * GetViewScale()); ScrollOffset = GetScrollOffsets(); ScrollOffset.x = ScrollOffset.x + WorkOffset.x; ScrollOffset.y = ScrollOffset.y + WorkOffset.y; if (ScrollOffset.x < (XLONG) 0) ScrollOffset.x = (XLONG) 0; if (ScrollOffset.y > (XLONG) 0) ScrollOffset.y = (XLONG) 0; SetScrollOffsets(ScrollOffset, TRUE); } }

void DocView::ScrollToShow (  DocCoord *  pCoord  )

Scrolls the currently selected document view to bring this coord into view. If this coord is already visible then we do nothing. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/1996 Parameters: pCoord  - coord to show in spread coords [INPUTS] -  [OUTPUTS] Returns: - If an ordinate of pCoord is zero then it is ignored and the view willnot be scrolled in that direction. Definition at line 913 of file docview.cpp. { ERROR3IF(pCoord == NULL,"pCoord is NULL"); if (pCoord == NULL) return; // call ScrollToShowAux, which does the actual work ScrollToShowAux(pCoord, DocCoord(0,0)); }

void DocView::ScrollToShowAux (  DocCoord *  pCoord, DocCoord  Margin )  [private]

Scrolls the view to ensure that pCoord is in the view, with a margin of Margin between it and the edges of the view. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/1996 Parameters: pCoord  - coord to show in spread coords [INPUTS] Margin - margin to give between point and edge of view -  [OUTPUTS] Returns: - If an ordinate of pCoord is zero then we ignore it and do not scroll in that direction. Definition at line 1231 of file docview.cpp. { ERROR3IF(pCoord == NULL,"pCoord is NULL"); if (pCoord == NULL) return; ERROR3IF(Margin.x < 0,"Negative X margin"); if (Margin.x < 0) return; ERROR3IF(Margin.y < 0,"Negative Y margin"); if (Margin.y < 0) return; Spread* pSpread = GetFirstSelectedSpread(); if (pSpread == NULL) { // do nothing } else { DocRect ViewRect; DocRect PasteRect; DocCoord Offset; // The TRUE argument for GetPasteBoardRect means that the result gets // pixelised. Otherwise the clipping code below doesn't work properly ViewRect = (GetDocViewRect(pSpread)).ToSpread(pSpread, this); PasteRect = (pSpread->GetPasteboardRect(TRUE)).ToSpread(pSpread, this); Offset = DocCoord(0,0); // suppose the view rectangle is smaller than two margins width, either in height or // width, we'll need to alter the margin to half the height or width as appropriate { INT32 Width = ViewRect.hi.x - ViewRect.lo.x; INT32 Height = ViewRect.hi.y - ViewRect.lo.y; if (Width < 2*Margin.x) Margin.x = Width/2; if (Height < 2*Margin.y) Margin.y = Height/2; } // only scroll in the X direction if pCoord->x is not zero if (pCoord->x != 0) { if (pCoord->x >= PasteRect.hi.x-Margin.x) pCoord->x = PasteRect.hi.x-Margin.x; if (pCoord->x <= PasteRect.lo.x+Margin.x) pCoord->x = PasteRect.lo.x+Margin.x; if (pCoord->x < (ViewRect.lo.x+Margin.x)) { // need to scroll to the left Offset.x = pCoord->x - (ViewRect.lo.x + Margin.x); } if (pCoord->x > (ViewRect.hi.x-Margin.x)) { // need to scroll to the right Offset.x = pCoord->x - (ViewRect.hi.x - Margin.x); } } else { Offset.x = 0; } // only scroll in the Y direction if pCoord->y is not zero if (pCoord->y != 0) { if (pCoord->y >= PasteRect.hi.y-Margin.y) pCoord->y = PasteRect.hi.y-Margin.y; if (pCoord->y <= PasteRect.lo.y+Margin.y) pCoord->y = PasteRect.lo.y+Margin.y; if (pCoord->y < (ViewRect.lo.y+Margin.y)) { // need to scroll down Offset.y = pCoord->y - (ViewRect.lo.y+Margin.y); } if (pCoord->y > (ViewRect.hi.y-Margin.y)) { // need to scroll up Offset.y = pCoord->y - (ViewRect.hi.y-Margin.y); } } else { Offset.y = 0; } // determine if we need to scroll or not, if (Offset != DocCoord(0,0)) { WorkCoord ScrollOffset; WorkCoord WorkOffset; WorkOffset.x = (XLONG) (MakeXLong(Offset.x) * GetViewScale()); WorkOffset.y = (XLONG) (MakeXLong(Offset.y) * GetViewScale()); ScrollOffset = GetScrollOffsets(); ScrollOffset.x = ScrollOffset.x + WorkOffset.x; ScrollOffset.y = ScrollOffset.y + WorkOffset.y; if (ScrollOffset.x < (XLONG) 0) ScrollOffset.x = (XLONG) 0; if (ScrollOffset.y > (XLONG) 0) ScrollOffset.y = (XLONG) 0; SetScrollOffsets(ScrollOffset, TRUE); } // else do nothing } }

void DocView::ScrollToShowWithMargin (  DocRect *  pBoundingBox, DocCoord  Direction )

Scrolls the current view to show parts of pBoundingBox. The edge(s) of pBoundingBox are determined by Direction, if we have moved objects towards the top of the screen then we need to ensure that the top edge of the DocRect is visible. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/1996 Parameters: pBoundingBox  - DocRect to show, in spread coords [INPUTS] Direction - direction of movement -  [OUTPUTS] Returns: - If an ordinate of Direction is zero then we ignore it and do not scroll in that direction. Definition at line 1183 of file docview.cpp. { ERROR3IF(pBoundingBox == NULL,"pBoundingBox is NULL"); if (pBoundingBox == NULL) return; DocCoord Point; DocCoord Margin; if (Direction.x > 0) Point.x = pBoundingBox->hi.x; else if (Direction.x < 0) Point.x = pBoundingBox->lo.x; else Point.x = 0; if (Direction.y > 0) Point.y = pBoundingBox->hi.y; else if (Direction.y < 0) Point.y = pBoundingBox->lo.y; else Point.y = 0; double Scale = GetViewScale().MakeDouble(); Margin.x = (INT32) (ScrollToShowMargin/Scale); Margin.y = (INT32) (ScrollToShowMargin/Scale); // call ScrollToShowAux, which does all the actual work ScrollToShowAux(&Point, Margin); }

void DocView::ScrollToShowWithMargin (  DocRect *  RectToShow  )

Scrolls the currently selected view to ensure that as much as possible of RectToShow is visible. If the entire rect cannot be seen, then it will scroll the minimum distance in order to make a part of it visible. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 22/3/96 Parameters: RectToShow  - Rectangle to show, in spread coords [INPUTS] i.e. Unlike the other ScrollToShow functions, this actually scrolls to show the given rectangle, as opposed to single points. Definition at line 1146 of file docview.cpp. { ERROR3IF(RectToShow == NULL, "Illegal NULL params"); DocRect Temp(*RectToShow); double Scale = GetViewScale().MakeDouble(); INT32 Margin = (INT32) (ScrollToShowMargin / Scale); Temp.Inflate(Margin, Margin); ScrollToShow(&Temp); }

void DocView::ScrollToShowWithMargin (  DocCoord *  pCoord  )

Scrolls the currently selected view to show the coord; if the coord in already in view then we do nothing. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 6/3/1996 Parameters: pCoord  - coord to show in spread coords [INPUTS] -  [OUTPUTS] Returns: - If an ordinate of pCoord is zero then we ignore it and do not scroll in that direction. Definition at line 1111 of file docview.cpp. { ERROR3IF(pCoord == NULL,"pCoord is NULL"); if (pCoord == NULL) return; DocCoord Margin; double Scale = GetViewScale().MakeDouble(); Margin.x = (INT32) (ScrollToShowMargin/Scale); Margin.y = (INT32) (ScrollToShowMargin/Scale); // call ScrollToShowAux, which does all the actual work ScrollToShowAux(pCoord, Margin); }

void DocView::SendSelectedMessage (  DocView *  OldSelected, DocView *  NewSelected )  [static, protected]

This is an INTERNAL function, which MUST NOT BE CALLED by anything other than Document::SetSelectedViewAndSpread. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/95 Parameters: OldSelected  - Points to the previously selected DocView (may be NULL) [INPUTS] NewSelected - Points to the new selected DocView (may be NULL) It is used to broadcast a DocViewMsg (SELCHANGED) to inform of a selection change. It follows a SetSelectedInternal call (a bit later, so that the message is only broadcast once the document, view, and spread states have all been updated correctly) See also: Document::SetSelectedViewAndSpread; DocView::SetSelectedInternal Definition at line 2314 of file docview.cpp. { BROADCAST_TO_ALL(DocViewMsg(OldSelected, NewSelected, DocViewMsg::SELCHANGED)); }

BOOL DocView::SetCurrent (   )

Make this object be the 'current' DocView. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if function set current correctly FALSE otherwise (then an Error has been set) Reimplemented from View. Definition at line 2229 of file docview.cpp. { return View::SetCurrent(); }

void DocView::SetExtent (  DocCoord  lolog, DocCoord  hilog )  [virtual]

Informs the DocView that the extent of the document has changed in some way and that the view must be altered to take this into account (namely the scrollbars). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: Two  DocCoords describing the low and high corners of a rectangle in logical [INPUTS] space describing the full extent of the document. I.E. the bottom-left corner of the last chapter and the top-right corner of the first. Implements View. Definition at line 1525 of file docview.cpp. { if (ViewFlags.LogicalView) { // "Pixelise" the extent DocCoords. // Effectively, this helps ensure that the spread will be aligned to a whole pixel boundary // and allows both GDraw and GDI to consistently plot the same pixels when rendering // the same primitive lolog.Pixelise(this); hilog.Pixelise(this); // Logical view means that chapters are shown in a contiguous column // Convert the extent given in DocCoord to WorkCoords... pVState->WorkAreaExtent.lo = lolog.ToWork(pDoc, this); pVState->WorkAreaExtent.hi = hilog.ToWork(pDoc, this); // If we know where the OIL view is then tell it that the extents have changed... if (pViewWindow) { pViewWindow->SetWorkAreaExtent(pVState->WorkAreaExtent, FALSE); } } else { // Physical view means that chapters are shown in their true positions in Document space ERROR3("DocView::SetExtent - Can't do physical views yet!"); } }

void DocView::SetForeBackMode (  BOOL  NewFlag  )  [virtual]

Set the background render flag for this view. Also sets the new value to be used as the default preference. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Parameters: NewFlag  - New bg render flag. [INPUTS] Implements View. Definition at line 1646 of file docview.cpp. { ViewFlags.BackgroundRender = NewFlag; // Update the preference to use this // Ensure that we either set TRUE or FALSE and not -1 or 0. // The preference is limited to 0 and 1 values and so -1 is illegal if (NewFlag == FALSE) BackgroundRendering = FALSE; else BackgroundRendering = TRUE; }

void DocView::SetNoCurrent (   )  [static]

Set the current DocView pointer to be NULL, i.e., there is no current DocView object. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented from View. Definition at line 2250 of file docview.cpp. { View::SetNoCurrent(); }

void DocView::SetPreventRenderView (  BOOL  Value  )

To set our member variable that will prevent rendering of the view. As you might imagine this is something to be careful about. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/5/2000 Parameters: Value  to set [INPUTS] Returns: - Errors: See also: Definition at line 5476 of file docview.cpp. { m_bPreventRenderView = Value; }

void DocView::SetPrevZoomIndex (  INT32  nIndex  )

Sets the zoom table index of a previous zoom onto this DocView. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: The  previous zoom index. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::GetPrevZoomIndex Definition at line 2395 of file docview.cpp. { PrevIndex = nIndex; }

void DocView::SetPrevZoomOffset (  const WorkCoord &  wcOffset  )

Sets the scroll offset this DocView will "remember" as a previous zoom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: The  previous zoom's scroll offset. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::GetPrevZoomOffset Definition at line 2477 of file docview.cpp. { PrevOffset = wcOffset; }

void DocView::SetPrevZoomScale (  FIXED16  fxScale  )

Sets the scale factor this DocView will "remember" as a previous zoom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/5/94 Parameters: The  previous zoom scale. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::GetPrevZoomScale Definition at line 2437 of file docview.cpp. { PrevScale = fxScale; }

BOOL DocView::SetScrollOffsets (  WorkCoord  NewTopLeft, BOOL  RedrawNeeded )  [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 from View. Definition at line 880 of file docview.cpp. { if (!View::SetScrollOffsets(NewTopLeft, RedrawNeeded)) // Something went wrong - report failure to caller. return FALSE; WorkCoord RoundedTopLeft = GetScrollOffsets(); // Tell Oil they've changed pViewWindow->SetScrollOffset(RoundedTopLeft, RedrawNeeded); return TRUE; }

void DocView::SetSelectedInternal (  DocView *  NewSelected  )  [static, protected]

This is an INTERNAL function, which MUST NOT BE CALLED by anything other than Document::SetSelectedViewAndSpread. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/95 Parameters: NewSelected  - NULL, or the new selected DocView [INPUTS] It sets the new selected DocView, but DOES NOT broadcast a message. The broadcast follows later, via SendSelectedMessage. It can be used to set No Selected DocView (NewSelected = NULL) It also sets this DocView as the Current DocView. See also: Document::SetSelectedViewAndSpread; DocView::SendSelectedMessage Definition at line 2280 of file docview.cpp. { Selected = NewSelected; if (NewSelected == NULL) DocView::SetNoCurrent(); else NewSelected->SetCurrent(); }

void DocView::SetShowGridState (  BOOL  ShowGrid  )

Allow you to change the "show grid" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: ShowGrid  - A bool used to set the visible status of grids in the view [INPUTS] Returns: - See also: Definition at line 4706 of file docview.cpp. { ViewFlags.GridShow = ShowGrid; }

void DocView::SetShowGuidesState (  BOOL  State  )  [inline]

Definition at line 550 of file docview.h. { ViewFlags.GuidesShow = State; }

void DocView::SetShowPrintBorders (  BOOL  State  )  [inline]

Definition at line 388 of file docview.h. { ViewFlags.PrintBorderShow = State; }

void DocView::SetSnapToGridState (  BOOL  SnapToGrid  )

Allow you to change the "snap to grid" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: SnapToGrid  - A bool used to set the snap status of grids in the view [INPUTS] Returns: - See also: Definition at line 4595 of file docview.cpp. { ViewFlags.GridSnap = SnapToGrid; }

void DocView::SetSnapToGuidesState (  BOOL  State  )  [inline]

Definition at line 547 of file docview.h. { ViewFlags.GuidesSnap = State; }

void DocView::SetSnapToMagObjectsState (  BOOL  SnapToMagObjects  )

Allow you to change the "snap to magnetic objects" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: SnapToMagObjects  - A bool used to set the snap status of magnetic objects in the view [INPUTS] Returns: - See also: Definition at line 4669 of file docview.cpp. { ViewFlags.MagObjectsSnap = SnapToMagObjects; }

void DocView::SetSnapToObjectsState (  BOOL  SnapToObjects  )

Allow you to change the "snap to all objects" state of a DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: SnapToObjects  - A bool used to set the snap status of all objects in the view [INPUTS] Returns: - See also: Definition at line 4632 of file docview.cpp. { ViewFlags.ObjectsSnap = SnapToObjects; }

void DocView::SetSolidDragState (  BOOL  bNewState  )  [inline]

Definition at line 333 of file docview.h. {m_bSolidDrag = bNewState;}

void DocView::SetViewPixelSize (   )  [virtual]

Sets up the normal and scaled pixel sizes according to this view. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 02/10/95 See also: OilCoord::SetPixelSize; DocCoord::SetScaledPixelSize Implements View. Definition at line 2149 of file docview.cpp. { // Set the scaled pixel size ScaledPixelWidth = PixelWidth / Scale; ScaledPixelHeight = PixelHeight / Scale; }

BOOL DocView::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 from View. Definition at line 1396 of file docview.cpp. { if (!View::SetViewScale(NewScale)) // Error return FALSE; // Tell everyone that a DocView scale has changed. BROADCAST_TO_ALL(DocViewMsg(this,DocViewMsg::SCALECHANGED)); return TRUE; }

void DocView::SetZoomTableIndex (  INT32  nIndex  )

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/94 Parameters: The  new index value. [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DocView::GetZoomTableIndex Definition at line 2354 of file docview.cpp. { ZoomTableIndex = nIndex; }

void DocView::ShowViewRulers (  BOOL  fIsVisible  )

Pass on Show Hide Rulers Message to CamView. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 5121 of file docview.cpp. { pViewWindow->ShowRulers(fIsVisible); }

void DocView::ShowViewScrollers (  BOOL  fIsVisible  )

Pass on Show Hide Scrollers Message to CamView. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 2/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 5099 of file docview.cpp. { PORTNOTETRACE("other","DocView::ShowViewScrollers - do nothing"); #ifndef EXCLUDE_FROM_XARALX pViewWindow->ShowScrollers(fIsVisible); #endif }

BOOL DocView::Snap (  Spread *  pSpread, DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )

Allows you to easily snap a rectangle to something relevant in the given spread (e.g. to a grid, magnetic object, etc). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 (modified 20/9/94) Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocRect = a rectangle relative to the given spread PrevCoord = Used to determine how rect is snapped CurCoord = As above Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4325 of file docview.cpp. { BOOL Snapped = FALSE; if (pCSnap == NULL) pCSnap = new CSnap(this,pSpread); if (pCSnap != NULL) { pCSnap->SetSpread(pSpread); Snapped = pCSnap->Snap(pDocRect,PrevCoord,CurCoord); } return (Snapped); }

BOOL DocView::Snap (  Spread *  pSpread, DocCoord *  pDocCoord, BOOL  TryMagSnap = TRUE, BOOL  TryGridSnap = TRUE )

Allows you to easily snap a coord to something relevant in the given spread (e.g. to a grid, magnetic object, etc). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 (modified 20/9/94) Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocCoord = a coord relative to the given spread Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4289 of file docview.cpp. { BOOL Snapped = FALSE; if (pCSnap == NULL) pCSnap = new CSnap(this,pSpread); if (pCSnap != NULL) { pCSnap->SetSpread(pSpread); Snapped = pCSnap->Snap(pDocCoord,TryMagSnap,TryGridSnap); } return (Snapped); }

BOOL DocView::SnapCurrent (  Spread *  pSpread, DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [static]

Calls the Snap(pSpread,pDocRect,PrevCoord,CurCoord) function of the Current DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocRect = a rectangle relative to the given spread PrevCoord = Used to determine how rect is snapped CurCoord = As above Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast Errors: Will error in debug builds if there is no Current DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4568 of file docview.cpp. { ERROR3IF(Current == NULL,"DocView::SnapCurrent called when no Current DocView"); DocView *pCurrent = GetCurrent(); if (pCurrent != NULL) return (pCurrent->Snap(pSpread,pDocRect,PrevCoord,CurCoord)); else return (FALSE); }

BOOL DocView::SnapCurrent (  Spread *  pSpread, DocCoord *  pDocCoord, BOOL  TryMagSnap = TRUE, BOOL  TryGridSnap = TRUE )  [static]

Calls the Snap(pSpread,pDocCoord) function of the Current DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocCoord = a coord relative to the given spread Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast Errors: Will error in debug builds if there is no Current DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4536 of file docview.cpp. { ERROR3IF(Current == NULL,"DocView::SnapCurrent called when no Current DocView"); DocView *pCurrent = GetCurrent(); if (pCurrent != NULL) return (pCurrent->Snap(pSpread,pDocCoord,TryMagSnap,TryGridSnap)); else return (FALSE); }

BOOL DocView::SnapSelected (  Spread *  pSpread, DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [static]

Calls the Snap(pSpread,pDocRect,PrevCoord,CurCoord) function of the selected DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocRect = a rectangle relative to the given spread PrevCoord = Used to determine how rect is snapped CurCoord = As above Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast Errors: Will error in debug builds if there is no selected DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4508 of file docview.cpp. { ERROR3IF(Selected == NULL,"DocView::SnapSelected called when no selected DocView"); if (Selected != NULL) return (Selected->Snap(pSpread,pDocRect,PrevCoord,CurCoord)); else return (FALSE); }

BOOL DocView::SnapSelected (  Spread *  pSpread, DocCoord *  pDocCoord, BOOL  TryMagSnap = TRUE, BOOL  TryGridSnap = TRUE )  [static]

Calls the Snap(pSpread,pDocCoord) function of the selected DocView. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/94 Parameters: pSpread  = a ptr to a spread node [INPUTS] pDocCoord = a coord relative to the given spread Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast Errors: Will error in debug builds if there is no selected DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4398 of file docview.cpp. { ERROR3IF(Selected == NULL,"DocView::SnapSelected called when no selected DocView"); if (Selected != NULL) return (Selected->Snap(pSpread,pDocCoord,TryMagSnap,TryGridSnap)); else return (FALSE); }

BOOL DocView::SnapToMagneticNode (  Spread *  pSpread, Node *  pNode, DocCoord *  pDocCoord )  [static]

Calls magnetic snapping functions taking into acount the control flags held in this DocView. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 25/3/94 Parameters: pSpread  Pointer to spread on which node exists [INPUTS] pNode Pointer to node to test magnetically pDocCoord A coordinate to test magnetically against the node Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast Errors: Will error in debug builds if there is no selected DocView See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 4428 of file docview.cpp. { ERROR3IF(Selected == NULL,"DocView::SnapSelected called when no selected DocView"); if (Selected != NULL) { BOOL Snapped = FALSE; if (Selected->pCSnap == NULL) Selected->pCSnap = new CSnap(Selected,pSpread); if (Selected->pCSnap != NULL) { Selected->pCSnap->SetSpread(pSpread); Snapped = Selected->pCSnap->TryToSnapToObject(pNode, pDocCoord); } return (Snapped); } else return (FALSE); }

BOOL DocView::StartDrag (  Operation *  pDragOp, DragType  type, DocRect *  pMoveBBox, DocCoord *  StartPos, BOOL  KeepAccuracy, BOOL  bSolidDragSupported = FALSE )

Tells the world that a drag is starting. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/7/93 Parameters: pDragOp  - Pointer to the operation [INPUTS] type - the type of drag to do pMoveBBox - StartPos - KeepAccuracy - TRUE if drag is biased towards accurate following of all mouse movements; FALSE if drag is biased towards keeping up to date with user. bSolidDragSupported FALSE (default) Do EORed outline dragging TRUE Update the tree during dragging Returns: TRUE if all went well Definition at line 3556 of file docview.cpp. { // Ignore if system is disabled if (CCamApp::IsDisabled()) return TRUE; // If the system is disabled, ignore if (pMoveBBox != NULL) { StartDragPos = *StartPos; if (pMoveBBox->ContainsCoord(StartDragPos)) { } } // Remember the drag operation (this also serves as a flag to indicate whether we // are dragging or not). ERROR3IF(pCurrentDragOp != NULL, "Nested drag in DocView::StartDrag"); ERROR3IF(pDragOp == NULL, "Null DragOp* in DocView::StartDrag?"); pCurrentDragOp = pDragOp; m_bSolidDragSupported = bSolidDragSupported; m_bSolidDrag = (m_bSolidDragSupported && DocView::SolidDragging); ERROR3IF(pViewWindow==NULL, "ARGH! DocView is not connected to a window in StartDrag!"); return pViewWindow->StartDrag(pDragOp, type, KeepAccuracy); }

BOOL DocView::ViewStateChanged (   )  [virtual]

Inform the DocView that the ViewState has been changed in some way. When this function detects a new ViewState object (IsNewView = TRUE) it sets the scroll offsets to the top left hand corner of the first page in the document. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/93 Implements View. Definition at line 1362 of file docview.cpp. { // Local variables... DocCoord ExtentLo; // coord of bottom-left of logical extent DocCoord ExtentHi; // coord of top-right of logical extent DialogBarOp::SetSystemStateChanged(); // Implementation... ERROR2IF(this==NULL,FALSE,"DocView member func called on NULL pointer"); ERROR2IF(pDoc==NULL,FALSE,"ViewStateChanged: There MUST be an owner doc for this view!"); // Read DocCoords extent of document & set extent in platform-indy ViewState struct. pDoc->GetExtents(&ExtentLo, &ExtentHi, &PhysExtent, this); SetExtent(ExtentLo, ExtentHi); // Set extent in platform-indy ViewState struct ViewFlags.WorkClickCached = FALSE; return TRUE; }

---

Friends And Related Function Documentation

friend class CCamView [friend]

Definition at line 373 of file docview.h.

friend class Document [friend]

Definition at line 230 of file docview.h.

---

Member Data Documentation

BOOL DocView::BackgroundRendering = TRUE [static]

Defines whether or not to use background rendering on new views. 0 => No background rendering 1 => Use background rendering. Preference: BackgroundRendering Section: Rendering Range: 0 or 1 Definition at line 420 of file docview.h.

double DocView::DefaultConstrainAngle = PI / 4.0 [static]

This is the default angle to which angles are constrained to (eg when rotating with constrain on, it will only rotate in multiples of this constrain angle. It must be greater than zero degrees and less than 360 degrees (note that it is recorded in radians). Preference: ConstrainAngle Section: Constraints Range: >0 ---> <2PI Definition at line 561 of file docview.h.

DocCoord DocView::DragPos [private]

Definition at line 295 of file docview.h.

UINT32 DocView::IdleDragDelay = 200 [static]

Defines delay time in milliseconds between detecting idle state and showing extra dragging info. Preference: IdleDragDelay Section: Dragging Range: 0 to 10000 Definition at line 422 of file docview.h.

UINT32 DocView::IdleDragDelay2 = 1000 [static]

Defines delay time in milliseconds between detecting idle state and showing extra dragging info. Preference: IdleDragDelay2 Section: Dragging Range: 0 to 10000 Definition at line 423 of file docview.h.

BOOL DocView::IsViewDying [private]

Definition at line 257 of file docview.h.

WorkCoord DocView::LastWorkClick [private]

Definition at line 293 of file docview.h.

BOOL DocView::m_bBoundsChanged [private]

Definition at line 618 of file docview.h.

BOOL DocView::m_bPreventRenderView [private]

Definition at line 610 of file docview.h.

BOOL DocView::m_bSolidDragSupported [private]

Definition at line 296 of file docview.h.

Cursor DocView::m_PushCursor [private]

Definition at line 285 of file docview.h.

DocCoord DocView::OldDragPos [private]

Definition at line 292 of file docview.h.

INT32 DocView::OnTopCount = 0 [static, private]

Definition at line 439 of file docview.h.

OnTopCode DocView::OnTopReason = Normal [static, private]

Definition at line 436 of file docview.h.

RenderRegion * DocView::OnTopRenderRegion = NULL [static, private]

Definition at line 438 of file docview.h.

Spread * DocView::OnTopSpread = NULL [static, private]

Definition at line 437 of file docview.h.

BOOL DocView::OriginOutlineShowAlways = FALSE [static]

Original outlines will be shown as soon as dragged items don't overlap originals. Preference: OriginOutlineShowAlways Section: Dragging Range: 0 or 1 Definition at line 425 of file docview.h.

BOOL DocView::OriginOutlineShowNonOverlap = FALSE [static]

Original outlines will be shown as soon as dragged items don't overlap originals. Preference: OriginOutlineShowNonOverlap Section: Dragging Range: 0 or 1 Definition at line 424 of file docview.h.

BOOL DocView::OutlineShowBounds = TRUE [static]

Dragged outlines will show a bounding rectangle. Preference: OutlineShowBounds Section: Dragging Range: 0 or 1 Definition at line 427 of file docview.h.

CSnap* DocView::pCSnap [private]

Definition at line 553 of file docview.h.

Operation* DocView::pCurrentDragOp [private]

Definition at line 294 of file docview.h.

PendingRedraws DocView::PendingRedrawList [private]

Definition at line 430 of file docview.h.

INT32 DocView::PrevIndex [private]

Definition at line 487 of file docview.h.

WorkCoord DocView::PrevOffset [private]

Definition at line 489 of file docview.h.

FIXED16 DocView::PrevScale [private]

Definition at line 488 of file docview.h.

RulerPair* DocView::pRulerPair [protected]

Definition at line 582 of file docview.h.

INT32 DocView::PushToolCursorID [private]

Definition at line 284 of file docview.h.

UINT32 DocView::ScrollToShowMargin = 18000 [static, private]

Margins to use (in millipoints) when autoscrolling with a margin. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 3/6/1996 See Also: ScrollToShowWithMargin Definition at line 453 of file docview.h.

DocView * DocView::Selected = NULL [static, private]

Definition at line 256 of file docview.h.

BOOL DocView::SolidDragging = TRUE [static]

Defines whether or not solid dragging is enabled. 0 => Solid dragging disabled 1 => Solid dragging enabled. Preference: SolidDragging Section: Dragging Range: 0 or 1 Definition at line 421 of file docview.h.

UINT32 DocView::SolidDragTimeLimit = 333 [static]

Defines time limit in milliseconds for solid drag redraw. When redraw takes longer than this value, dragging falls back to outline mode. Preference: SolidDragTimeLimit Section: Dragging Range: 0 to 10000 Definition at line 426 of file docview.h.

DocCoord DocView::StartDragPos [private]

Definition at line 291 of file docview.h.

MonotonicTime DocView::StartTime [private]

Definition at line 375 of file docview.h.

struct DocView::CCAPI DocView::ViewFlags [private]

INT32 DocView::ZoomTableIndex [private]

Definition at line 486 of file docview.h.

---

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

• Kernel/docview.h (r1785/r1718)
• Kernel/docview.cpp (r1785/r1729)

---