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"),