Spread Class Reference

#include <spread.h>

Inheritance diagram for Spread:

List of all members.

Public Member Functions
	Spread ()
	This constructor creates a Spread linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles.
	Spread (Node *ContextNode, AttachNodeDirection Direction, const DocRect &PasteRect, MILLIPOINT BleedOffset=0, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	returns the nodes bounding rectangle. If the rectangle is valid the rectangle is simply returned, but is IsBoundingRectValid is FALSE (cos someone called InvaldateBoundingRect() on this node, or one of its children) then the bounding rect is first calculated and the flag reset, before it is returned. The Spreads bounds rect is measured in Document Coords and this conversion is made in here. ie. All objects below the spread measure their coords etc relative to the spread, but the spread itself is measured relative to the document.
DocRect	GetDrawingSize () const
	Works out the size of the rectangle encompassing the drawing. Code also used to work out the pixel size in the bitmap export options dialog box. Graeme (13/7/00) - Changed the code so that the background layer is ignored.
String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method.
Spread *	FindNextSpread ()
	To find the next sibling spread.
Spread *	FindPreviousSpread ()
	To find the current spreads previous sibling spread.
Page *	FindFirstPageInSpread () const
	To find the first page in a spread.
Page *	FindLastPageInSpread () const
	To find the spread's last page. Layers and other renderable nodes should always be inserted after the last page. Otherwise, there is likely to be redraw problems.
Document *	FindParentDocument ()
	Finds the parent document for this spread. Should always be one present. Defined as an explicit function so that caller just has to check for NULL returns, rather than also checking that the parent is a chapter. Also, makes it more encapsulated and friendly.
Chapter *	FindParentChapter ()
	Finds the parent chapter for this spread. Should always be one present. Defined as an explicit function so that caller just has to check for NULL returns, rather than also checking that the parent is a chapter. Also, makes it more encapsulated and friendly.
Layer *	FindActiveLayer ()
	For finding the spreads active layer.
Layer *	FindFirstLayer () const
	To find the spread's first layer.
Layer *	FindLastLayer () const
	To find the spread's last layer.
Layer *	FindFirstGuideLayer () const
	To find the spread's first guide layer.
Layer *	FindFirstPageBackgroundLayer () const
	To find the spread's first page background layer.
Layer *	FindFirstFrameLayer () const
	To find the spread's first frame layer.
Layer *	FindLastFrameLayer () const
	To find the spread's last framelayer.
DimScale *	GetPtrDimScale ()
	For getting a ptr to the Spread's dimension scale object.
MILLIPOINT	GetBleedOffset () const
	For getting the Spread's bleed area size.
BOOL	SetBleedOffset (MILLIPOINT Bleed)
	For setting a new value for the Spread's bleed area size.
BOOL	GetShowDropShadow () const
	Finds out the current drop shadow display state.
BOOL	SetShowDropShadow (BOOL NewState)
	Allows the setting of a new drop shadow display state.
virtual BOOL	IsSpread () const
	Tell the caller that this is a spread node.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
BOOL	NeedsToExport (RenderRegion *pRender, BOOL VisibleLayersOnly=FALSE, BOOL CheckSelected=FALSE)
	Indicate that we don't want to export this class of nodes.
void	Render (RenderRegion *pRender)
	Renders spread items: Pasteboard and off-paste area Main fold line Spread dividers Bleed Area Drop-shadows Spread outline Print margin.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual void	GetDebugDetails (StringBase *Str)
	For obtaining debug information about the Node.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Web files do not write out spreads.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
	Writes the spread record to the filter.
virtual BOOL	WriteBeginChildRecordsWeb (BaseCamelotFilter *pFilter)
	Begins the child record sequence for spread in the web format.
virtual BOOL	WriteBeginChildRecordsNative (BaseCamelotFilter *pFilter)
	Begins the child record sequence for spread in the native format.
virtual BOOL	WriteEndChildRecordsWeb (BaseCamelotFilter *pFilter)
	Ends the child record sequence for spread in the web format.
virtual BOOL	WriteEndChildRecordsNative (BaseCamelotFilter *pFilter)
	Ends the child record sequence for spreads in the native format.
DocCoord	GetUserOrigin ()
void	SetUserOrigin (DocCoord origin)
void	SpreadCoordToDocCoord (DocCoord *pSpreadCoord) const
	To convert between Document and Spread coordinate spaces.
void	SpreadCoordToDocCoord (DocRect *pSpreadCoord) const
void	DocCoordToSpreadCoord (DocCoord *pDocCoord) const
	To convert between Document and Spread coordinate spaces.
void	DocCoordToSpreadCoord (DocRect *pDocCoord) const
BOOL	SpreadCoordToPagesCoord (DocCoord *pPagesCoord, DocCoord SpreadCoord)
	Convert SpreadCoord to PagesCoord (relative to union of pages in spread).
BOOL	PagesCoordToSpreadCoord (DocCoord *pSpreadCoord, DocCoord PagesCoord)
	Convert PagesCoord (relative to union of pages in spread) to SpreadCoord.
BOOL	GetPagesRect (DocRect *pPagesRect)
	Get the union rect of all pages on the spread (in SpreadCoords).
BOOL	TextToSpreadCoord (DocCoord *pDocCoord, StringBase *pxText, StringBase *pyText)
	Convert Coord in text form (relative to union of pages in spread) into SpreadCoord.
BOOL	SpreadCoordToText (String_256 *pxText, String_256 *pyText, DocCoord DocCoord, BOOL xUnitSpecifier=TRUE, BOOL yUnitSpecifier=TRUE, INT32 dp=-1)
	Convert SpreadCoord into Coord in text form (relative to union of pages in spread) Note: If only Y specifier required and units are prefix then the unit specifier is actually placed before the x value.
BOOL	GetDecimalPlacesForPixelResolution (View *pView, INT32 *dp)
	Find the number of dp to resolve a pixel in units and scale associated with spread (calulates the both x and y and returns max).
NodeGrid *	FindFirstDefaultGridInSpread ()
	Finds the first default grid that has been defined in this spread. Should be the only one present.
BOOL	CreateDefaultPageAndGrid (BOOL CreateGrid=TRUE)
DocRect	GetPageBounds () const
	Finds the bounding rectangle of this Spread, defined as the smallest rectangle enclosing all the Pages the Spread contains.
DocRect	GetPageVisibleBounds () const
	Finds the bounding rectangle of this Spread, defined as the smallest rectangle enclosing all the Pages the Spread contains.
BOOL	GetPageSize (MILLIPOINT *Width, MILLIPOINT *Height, MILLIPOINT *Margin, MILLIPOINT *Bleed, BOOL *Dps, BOOL *ShowDropShadow)
	Allows the current page size specified for a spread to be determined. Assumes that all pages in one spread are the same size and hence returns this size.
BOOL	SetPageSize (const MILLIPOINT Width, const MILLIPOINT Height, const MILLIPOINT Margin, const MILLIPOINT Bleed, const BOOL Dps, const BOOL ShowDropShadow)
	Allows the setting of a new page size by height and width for all pages in this spread. Also allows changing of other spread attributes such as:- margin around pages in spread, bleed size single/double page spread whether a drop shadow is displayed for this spread.
DocRect	GetWidePasteboard (View *pView)
	Return the pixelised boundary of the "wide pasteboard".
DocCoord	GetSpreadCoordOrigin (BOOL Pixelise=TRUE, View *pView=NULL) const
	To determine the spread coordinate origin This is used to convert between document and spread coordinates: DocCoord = SpreadCoord + Origin SpreadCoord = DocCoord - Origin.
void	SetSpreadCoordOrigin (DocCoord NewOrigin)
	To set the spread coordinate origin This is used to convert between document and spread coordinates: DocCoord = SpreadCoord + Origin SpreadCoord = DocCoord - Origin.
DocCoord	GetMaxPasteboardSize (void)
	To determine the maximum size that the pasteboard will allow itself to be expanded to.
BOOL	ExpandPasteboardToInclude (DocRect IncludeRect)
	To expand the pasteboard area to include the given rectangle. Used when objects are moved outside the current pasteboard area to keep them in an area which the user can see. The pasteboard will never expand beyond a maximum size (see Spread::GetMaxPasteboardSize).
void	AdjustPasteboards (void)
	This runs through all spreads in this spread's parent chapter, doing the following:.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
BOOL	SetSpreadAnimPropertiesParam (const DWORD &Loop, const DWORD &GlobalDelay, const DITHER &Dither, const WEB_PALETTE &WebPalette, const PALETTE_COLOURS &ColoursPalette, const DWORD &NumColsInPalette, const BOOL &UseSystemColours, const BOOL &IsBackgroundTransparent)
BOOL	GetSpreadAnimPropertiesParam (DWORD *Loop, DWORD *GlobalDelay, DITHER *Dither, WEB_PALETTE *WebPalette, PALETTE_COLOURS *ColoursPalette, DWORD *NumColsInPalette, BOOL *UseSystemColours, BOOL *pIsBgTransparent)
	Allows access to the Animation Properties details for this spread. Notes: Karim 07/12/00 - added IsBgTransparent parameter.
AnimPropertiesParam &	GetSpreadAnimPropertiesParam ()
	Returns the the Animation Properties details for this spread.
void	SetSpreadAnimPropertiesParam (const AnimPropertiesParam &Param)
void	SetAnimationDelay (const DWORD GlobalDelay)
	Sets the the delay value within the class data member m_AnimPropertiesParam. This value has been recieved from the Animation properties tab.
void	SetAnimationLoop (const DWORD &Loop)
	Sets the loop value within the class data member m_AnimPropertiesParam. This value has been recieved from the Animation properties tab.
void	SetAnimationColours (const DITHER &Dither, const WEB_PALETTE &WebPalette, const PALETTE_COLOURS &ColoursPalette, const DWORD &NumColsInPalette, const BOOL &IsBackgroundTransparent)
void	GetAnimationColours (DITHER *pDither, WEB_PALETTE *pWebPalette, PALETTE_COLOURS *pColoursPalette, DWORD *pNumColsInPalette, BOOL *pIsBackgroundTransparent)
virtual BOOL	WriteSpreadAnimProperties (BaseCamelotFilter *pFilter)
DocRect	GetAnimationBoundingRect ()
	Returns the stored animation bounding rect for this spread.
void	SetAnimationBoundingRect (const DocRect &BoundingRect)
	Sets the new stored bounding rect for this spread.
Quality	GetAnimationQuality ()
	Returns the stored quality that the animation for this spread was captured at.
void	SetAnimationQuality (const Quality &NewQuality)
	Sets the new stored quality that the animation for this spread was captured at.
Protected Member Functions
virtual BOOL	WriteSpreadInformation (BaseCamelotFilter *pFilter)
	Exports the page details, margins, bleed size and other spread related information for this spread to the filter. We output an information record rather than the individual pages as:- all the pages in the spread are defined to be the same size this is the same way that the old format used (not a good argument I know!) all the code to do it this way is present and proved it is a logical packing of all spread related information into one record.
virtual BOOL	WriteSpreadScaling (BaseCamelotFilter *pFilter)
	Exports the scaling information for this spread to the filter.
BOOL	SetSizeOfAllPages (const MILLIPOINT Width, const MILLIPOINT Height, const MILLIPOINT Margin, const BOOL Dps)
	Sets the sizes of all pages in this spread to conform to the newly specified width and height. It will try and align all the pages. It will also try and create and or delete any pages which are necessary to conform to the specified single/double page spread flag. Assumes all the pages in a spread are the same size.
BOOL	AlignPasteboards (const DocRect NewPasteRect, const MILLIPOINT Margin)
	Tries to align all the pasteboards of the spreads in this chapter to the new size of this spread. Checks to see if the objects on the spread are bigger than the newly specified pasteboard rectangle and if so will put a margin around the object rectangle and then combine this with the specified pasteboard height. This means we will not loose any objects off the spread. As it is changing the size and position of the spread, it will invalidate the spreads bounding rectangle so that hopefully all bounding boxes will be recalculated rather than using the old and more than likely wrong cached one. Assumes at present that it is only called on the first spread in the chapter.
virtual void	SetInitialPasteboardRect (const DocRect &PasteRect)
	To set the initial pasteboard rectangle of this node, and then change the pasteboard rectangles of all its parents.
virtual BOOL	PostImport ()
	This function is called after a document is imported. Nodes should override this function to do any post-import processing.
void	RenderPasteboard (RenderRegion *pRender)
	To render the pasteboard and off-paste area.
void	RenderBleedArea (RenderRegion *pRender)
	Renders the Bleed Area rectangle if the BleedOffset is not 0 Scope: private.
virtual Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
void	CopyNodeContents (Spread *NodeCopy)
	This method copies the node's contents to the node pointed to by NodeCopy.
void	RenderDropShadows (RenderRegion *pRender)
	To render right-hand and bottom drop shadows Scope: private.
Protected Attributes
MILLIPOINT	BleedOffset
BOOL	ShowDropShadow
BOOL	RalphDontShowPaper
DocCoord	SpreadOrigin
DocCoord	UserOrigin
AnimPropertiesParam	m_AnimPropertiesParam
Private Attributes
DimScale	SpreadDimScale

---

Detailed Description

Definition at line 138 of file spread.h.

---

Constructor & Destructor Documentation

Spread::Spread (   )

This constructor creates a Spread linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 13/5/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: - Errors: Definition at line 178 of file spread.cpp. : NodeRenderablePaper() { UserOrigin = DocCoord(0, 0); SpreadOrigin = DocCoord(0, 0); BleedOffset = 36000; ShowDropShadow = TRUE; RalphDontShowPaper = FALSE; //AnimPropertiesParam = constructed //SpreadDimScale = constructed }

Spread::Spread (  Node *  ContextNode, AttachNodeDirection  Direction, const DocRect &  PasteRect, MILLIPOINT  Bleed = 0, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This method initialises the node and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which this node is to be attached to the ContextNode. The values this variable can take are as follows: PREV : Attach node as a previous sibling of the context node NEXT : Attach node as a next sibling of the context node FIRSTCHILD: Attach node as the first child of the context node LASTCHILD : Attach node as a last child of the context node BoundingRect: Bounding rectangle The remaining inputs specify the status of the node: Locked: Is node locked ? Mangled: Is node mangled ? Marked: Is node marked ? Selected: Is node selected ? Parameters: -  [OUTPUTS] Returns: - Errors: An assertion error will occur if ContextNode is NULL Definition at line 238 of file spread.cpp. : NodeRenderablePaper(ContextNode, Direction, Locked, Mangled, Marked, Selected) { BleedOffset = Bleed; // Set the default spread coord origin SpreadOrigin = PasteRect.lo; // Pasteboard is used to indicate the width of the document (for scroll bars etc) SetInitialPasteboardRect(PasteRect); // Default to showing the drop shadow on the page ShowDropShadow = TRUE; // we only render paper in some ralph document modes RalphDontShowPaper = FALSE; UserOrigin = DocCoord(0,0); }

---

Member Function Documentation

void Spread::AdjustPasteboards (  void   )

This runs through all spreads in this spread's parent chapter, doing the following:. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/3/96 1) Find the minimum and maximum x values of all spread pasteboards in the chapter, and set all pasteboards to have this same x extent so that they all line up tidily in a nice clean column. 2) Move the pasteboards (and contents) as necessary so that recently expanded pasteboards do not overlap neighbouring spreads, and they all butt up against each other nicely. (Note: The whole pasteboard is moved, including shifting the spread coord origin to keep it in the same relative position) 3) Ensure that all default grids fully cover their pasteboard. Finally, it will cause a redraw of all views onto this document to ensure that they are correctly updated. Notes: **** This has only been tested for single-spread Chapters **** (Although it has been written to hopefully handle multiple spreads) See also: Spread::GetMaxPasteboardSize; NodeRenderablePaper::ChangePasteboardRect Definition at line 3365 of file spread.cpp. { //#if NEW_PASTEBOARD Chapter* ParentChapter = FindParentChapter(); ERROR3IF(ParentChapter == NULL, "No parent Chapter?!"); // First, find the minimum and maximum pasteboard x extents for the entire document. // Helpfully, our parent Chapter's pasteboard rect is a union of all of ours! DocRect ChapterBounds = ParentChapter->GetPasteboardRect(); // Now we loop through all spreads from this one onwards, doing 2 things // 1) Make sure that each following spread is shifted to the correct document coordinates // by ensuring its pasteboard is placed after this spread's one. // 2) Make sure that all default grids in all spreads fully cover the pasteboards. Spread* pThisSpread = ParentChapter->FindFirstSpread(); // Force the x extent of the first pasteboard to match all others in this chapter DocRect TempPasteRect = pThisSpread->GetPasteboardRect(); TempPasteRect.lo.x = ChapterBounds.lo.x; TempPasteRect.hi.x = ChapterBounds.hi.x; /*if (pThisSpread->FindNextSpread()) { DocCoord OriginOffset(pThisSpread->SpreadOrigin.x - pThisSpread->PasteboardRect.lo.x, pThisSpread->SpreadOrigin.y - pThisSpread->PasteboardRect.lo.y); DocRect r; pThisSpread->GetPagesRect(&r); pThisSpread->SpreadCoordToDocCoord(&r); r.Inflate(18000); INT32 ydiff = r.lo.y - TempPasteRect.lo.y; TempPasteRect.lo.y = r.lo.y; pThisSpread->SpreadOrigin.x = TempPasteRect.lo.x + OriginOffset.x; pThisSpread->SpreadOrigin.y = TempPasteRect.lo.y + OriginOffset.y - ydiff; } */ pThisSpread->ChangePasteboardRect(TempPasteRect); pThisSpread->InvalidateBoundingRect(); // For each spread... while (pThisSpread != NULL) { Progress::Update(); // Update any active hourglass Spread* pNextSpread = pThisSpread->FindNextSpread(); // --- If there is a spread following this one, fix its pasteboard rect position if (pNextSpread != NULL) { DocRect FirstPasteRect = pThisSpread->GetPasteboardRect(FALSE); /*if (pThisSpread->FindNextSpread()) { DocRect r; pThisSpread->GetPagesRect(&r); pThisSpread->SpreadCoordToDocCoord(&r); r.Inflate(18000); FirstPasteRect.lo.y = r.lo.y; } if (pThisSpread->FindPreviousSpread()) { DocRect r; pThisSpread->GetPagesRect(&r); pThisSpread->SpreadCoordToDocCoord(&r); r.Inflate(18000); FirstPasteRect.hi.y = r.hi.y; } */ DocRect SecondPasteRect = pNextSpread->GetPasteboardRect(FALSE); DocCoord OriginOffset(pNextSpread->SpreadOrigin.x - pNextSpread->PasteboardRect.lo.x, pNextSpread->SpreadOrigin.y - pNextSpread->PasteboardRect.lo.y); /*if (pNextSpread->FindNextSpread()) { DocRect r; pNextSpread->GetPagesRect(&r); pNextSpread->SpreadCoordToDocCoord(&r); r.Inflate(18000); INT32 ydiff = r.lo.y - SecondPasteRect.lo.y; SecondPasteRect.lo.y = r.lo.y; OriginOffset.y -= ydiff; } if (pNextSpread->FindPreviousSpread()) { DocRect r; pNextSpread->GetPagesRect(&r); pNextSpread->SpreadCoordToDocCoord(&r); r.Inflate(18000); SecondPasteRect.hi.y = r.hi.y; } */ // Construct a new Pasteboard rectangle of the correct size, and move it // to lie just below the previous spread's pasteboard area TempPasteRect = SecondPasteRect; TempPasteRect.Translate(-TempPasteRect.lo.x, -TempPasteRect.lo.y); TempPasteRect.Translate(FirstPasteRect.lo.x, FirstPasteRect.lo.y - TempPasteRect.Height()); // And force the x extent of this pasteboard to match all others in this chapter TempPasteRect.lo.x = ChapterBounds.lo.x; TempPasteRect.hi.x = ChapterBounds.hi.x; // Move the spread coordinate origin so that it stays at the same relative offset // from the pasteboard bottom left corner, or else all objects inside the spread // will suddenly shift to a new place on (or off) the pasteboard! pNextSpread->SpreadOrigin.x = TempPasteRect.lo.x + OriginOffset.x; pNextSpread->SpreadOrigin.y = TempPasteRect.lo.y + OriginOffset.y; // Set the new paste rect pNextSpread->ChangePasteboardRect(TempPasteRect); // Make sure bounding rectangles are invalidated so that they are recalculated pNextSpread->InvalidateBoundingRect(); } // --- Fix all the default grids to exactly cover their pasteboards Node *ptr = pThisSpread->FindFirstChild(); while (ptr != NULL) { if (ptr->IsKindOf(CC_RUNTIME_CLASS(NodeGrid))) { // Found a grid type node. Check if its a default type. NodeGrid* pCurrentGrid = (NodeGrid*)ptr; if (pCurrentGrid->IsDefault()) { // Default grids need to fill the spread's pasteboard rect DocRect Bounds = pThisSpread->GetPasteboardRect(); DocCoordToSpreadCoord(&Bounds); // And set the new bounding rect pCurrentGrid->SetBoundingRect(Bounds); } } ptr = ptr->FindNext(); } // --- And move on to the next spread to fix pThisSpread = pNextSpread; } // And invalidate all displayed views on this document, in order to make sure they // correctly update on screen. Document *pDoc = (Document *)FindOwnerDoc(); if (pDoc != NULL) pDoc->ForceRedraw(); //#else //ERROR3("Spread::AdjustPasteboards is unimplemented - see Jason/Phil"); //#endif }

BOOL Spread::AlignPasteboards (  const DocRect  NewPasteRect, const MILLIPOINT  Margin )  [protected]

Tries to align all the pasteboards of the spreads in this chapter to the new size of this spread. Checks to see if the objects on the spread are bigger than the newly specified pasteboard rectangle and if so will put a margin around the object rectangle and then combine this with the specified pasteboard height. This means we will not loose any objects off the spread. As it is changing the size and position of the spread, it will invalidate the spreads bounding rectangle so that hopefully all bounding boxes will be recalculated rather than using the old and more than likely wrong cached one. Assumes at present that it is only called on the first spread in the chapter. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: New  size of the paste board rectangle for this spread. [INPUTS] -  [OUTPUTS] Returns: Whether we completed the operation ok or not as True or False. Errors: - See also: - Definition at line 2357 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::AlignPasteboards called on NULL pointer"); // Work out the overall bounds of the pages and objects on the page in the spread // This will be in document coordinates DocRect ObjectsBounds = GetBoundingRect(FALSE); // Take copy of entry pasteboard rectangle size DocRect PasteRect = NewPasteRect; // Note:: The tops of the old paste board rectangle and the new are aligned rather // than the bottoms. Hence the 0,0s are different. This means that direct comparisons // between new size, old size and bounding rectangles are not possible. // First, get the current paste board rectangle for this spread. DocRect SpreadRect = GetPasteboardRect(); // Work out the maximum height and width of pasteboard required to encompass all the // current objects on the page. Include a margin around the outside. MILLIPOINT HeightReqd = ObjectsBounds.hi.y - SpreadRect.lo.y + Margin; MILLIPOINT WidthReqd = ObjectsBounds.hi.x - SpreadRect.lo.x + Margin; // Above calculations will not include objects off the bottom and/or left hand side of // the page. We would need to shift the bottom left hand corner of the page plus all // objects if we were going to move these objects back onto the page. // If bounding rectangle of objects on page is bigger than the size of this new pasteboard // rectangle then resize the pasteboard to include the objects bounding box. if (PasteRect.Width() < WidthReqd || PasteRect.Height() < HeightReqd ) { // Work out what the new required width and height of the pasteboard rectangle is // including a margin size border around the outside of the objects bounding rectangle // so that all the handles are accessable. MILLIPOINT SpreadHeight = 0; MILLIPOINT SpreadWidth = 0; if (HeightReqd < PasteRect.Height() ) SpreadHeight = PasteRect.Height(); else SpreadHeight = HeightReqd; if (WidthReqd < PasteRect.Width() ) SpreadWidth = PasteRect.Width(); else SpreadWidth = WidthReqd; // Contruct a new PasteRect to take this object bounding rectangle into account. PasteRect = DocRect(MinDocCoord + 0x10000, (MaxDocCoord - 0x10000) - (SpreadHeight), (MinDocCoord + 0x10000) + (SpreadWidth), MaxDocCoord - 0x10000); } // Now we have the required size and position, go and set it ChangePasteboardRect(PasteRect); // Make the wide pasteboard align to the new one // REMOVED - WPB now calculated on the fly rather than cached // WidePasteboard.lo.y = PasteRect.lo.y; // WidePasteboard.hi.y = PasteRect.hi.y; // Make sure bounding rectangles are invalidated so that they are recalculated InvalidateBoundingRect(); // Now ensure all following spreads are properly attached to this one // Assumes that we are altering the first spread in the document // Note this spread as a possible last spread in the document Spread* pLastSpread = this; Spread* pThisSpread = this; Spread* pNextSpread = FindNextSpread(); while (pNextSpread != NULL) { // Next spread present, so adjust the pasteboard on the first/previous spread to // be correct assuming that it is not the last one present. // REMOVED- AdjustPasteboardHeight used to set the wide pasteboard - this is no longer necessary // as the Wide Pasteboard is calculated on the fly rather than cached now. // pThisSpread->AdjustPasteboardHeight(FALSE); DocRect FirstPasteRect = pThisSpread->GetPasteboardRect(FALSE); DocRect SecondPasteRect = pNextSpread->GetPasteboardRect(FALSE); // Construct a new Pasteboard rectangle of the correct size and initial position // and then move it down by the height of the first spread (Down = -ve). DocRect TempPasteRect(MinDocCoord + 0x10000, (MaxDocCoord - 0x10000) - SecondPasteRect.Height(), (MinDocCoord + 0x10000) + SecondPasteRect.Width(), MaxDocCoord - 0x10000); TempPasteRect.Translate(0, -( FirstPasteRect.Height() )); // Now we have the required size and position, go and set it pNextSpread->ChangePasteboardRect(TempPasteRect); // Make the wide pasteboard align to the new one // REMOVED - WPB now calculated on the fly rather than cached // pNextSpread->WidePasteboard.lo.y = TempPasteRect.lo.y; // pNextSpread->WidePasteboard.hi.y = TempPasteRect.hi.y; #ifdef _DEBUG // On Debug versions check that the spreads are aligned correctly FirstPasteRect = pThisSpread->GetPasteboardRect(FALSE); SecondPasteRect = pNextSpread->GetPasteboardRect(FALSE); TRACEUSER( "Neville", _T("First spread low corner y = %d\n"),FirstPasteRect.LowCorner().y); TRACEUSER( "Neville", _T("Second spread high corner y = %d\n"),SecondPasteRect.HighCorner().y); ENSURE((SecondPasteRect.HighCorner().y == FirstPasteRect.LowCorner().y), "Spread::SetPageSize() Spreads are not properly vertically aligned"); #endif // Make sure bounding rectangles are invalidated so that they are recalculated pNextSpread->InvalidateBoundingRect(); // Note this next spread as a possible last spread and this spread pLastSpread = pNextSpread; pThisSpread = pNextSpread; // Now, see whether there is a next spread or not. pNextSpread = pNextSpread->FindNextSpread(); } // Last spread in document/chapter so adjust the bottom pasteboard to be correct // REMOVED - this method just adjusts the Wide pasteboard - no longer necessary as the WPB // is calculated on the fly rather than cached // if (pLastSpread != NULL) // pLastSpread->AdjustPasteboardHeight(TRUE); return TRUE; }

void Spread::CopyNodeContents (  Spread *  NodeCopy  )  [protected]

This method copies the node's contents to the node pointed to by NodeCopy. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Parameters: [INPUTS]  A  copy of this node [OUTPUTS] Returns: - Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Definition at line 953 of file spread.cpp. { ERROR3IF(NodeCopy == NULL,"Trying to copy node contents to\n" "a node pointed to by a NULL pointer"); NodeRenderablePaper::CopyNodeContents(NodeCopy); NodeCopy->BleedOffset = BleedOffset; NodeCopy->ShowDropShadow = ShowDropShadow; NodeCopy->SpreadOrigin = SpreadOrigin; NodeCopy->UserOrigin = UserOrigin; NodeCopy->m_AnimPropertiesParam = m_AnimPropertiesParam; NodeCopy->SpreadDimScale = SpreadDimScale; NodeCopy->RalphDontShowPaper = RalphDontShowPaper; }

BOOL Spread::CreateDefaultPageAndGrid (  BOOL  CreateGrid = TRUE  )

Definition at line 2730 of file spread.cpp. { // Work out where to put the page and create it DocRect PageRect(Gap, Gap, Gap+PageWidth, Gap+(1*PageHeight)); Page *pPage = new Page(this, FIRSTCHILD, PageRect); if (pPage == NULL) return(FALSE); // Create a default blanket grid in the given spread if (CreateGrid) NodeGrid::MakeDefaultGrid(this); return TRUE; }

String Spread::Describe (  BOOL  Plural, BOOL  Verbose )  [virtual]

To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the object The description will always begin with a lower case letter. Returns: Errors: A resource exception will be thrown if a problem occurs when loading the string resource. See also: - Reimplemented from Node. Definition at line 295 of file spread.cpp. { if (Plural) return(String(_R(IDS_SPREAD_DESCRP))); else return(String(_R(IDS_SPREAD_DESCRS))); };

void Spread::DocCoordToSpreadCoord (  DocRect *  pDocCoord  )  const

Definition at line 3145 of file spread.cpp. { ERROR3IF(pDocRect == NULL, "Illegal NULL params"); DocCoordToSpreadCoord(&pDocRect->lo); DocCoordToSpreadCoord(&pDocRect->hi); }

void Spread::DocCoordToSpreadCoord (  DocCoord *  pDocCoord  )  const

To convert between Document and Spread coordinate spaces. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 11/3/96 Parameters: }  pDocCoord/pDocRect - The coordinate/rectangle to be converted [INPUTS] }  [OUTPUTS] See also: Spread::GetSpreadCoordOrigin Definition at line 3133 of file spread.cpp. { ERROR3IF(pDocCoord == NULL, "Illegal NULL params"); DocCoord Origin = GetSpreadCoordOrigin(); pDocCoord->x -= Origin.x; pDocCoord->y -= Origin.y; }

BOOL Spread::ExpandPasteboardToInclude (  DocRect  IncludeRect  )

To expand the pasteboard area to include the given rectangle. Used when objects are moved outside the current pasteboard area to keep them in an area which the user can see. The pasteboard will never expand beyond a maximum size (see Spread::GetMaxPasteboardSize). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/2/96 Parameters: IncludeRect  - The rectangle (in SPREAD coordinates, i.e. standard renderable [INPUTS] object bounds) which you wish to include into the spread's pasteboard range. Returns: TRUE if the pasteboard was successfully expanded. FALSE if the pasteboard has reached its maximum size and cannot be expanded further (note: the pasteboard may still expand during this call, but the return code indicates that it has now reached maximum extent). The given rectangle lies outside the available maximum bounds. Notes: **** This has only been tested for single-spread documents **** The pasteboard expands equally in all directions in order to keep all page "margins" equal. This is necessary so that window scroll positions are not messed when we re-load a file See also: Spread::GetMaxPasteboardSize; NodeRenderablePaper::ChangePasteboardRect Definition at line 3221 of file spread.cpp. { #if NEW_PASTEBOARD #error ("This code has been commented out for safety. Please uncomment and try again"); Progress Hourglass; // Ensure an hourglass is running while we're busy // Convert the Spread coordinates "IncludeRect" into Document coordinates "IncludeDocRect" DocRect IncludeDocRect(IncludeRect); SpreadCoordToDocCoord(&IncludeDocRect); // If the pasteboard is already big enough, return immediately (success) if (PasteboardRect.ContainsRect(IncludeDocRect)) return(TRUE); // Remember where the view was looking before we moved things about DocView *pView = DocView::GetSelected(); DocRect ViewRect; if (pView != NULL) { ViewRect = pView->GetDocViewRect(this); DocCoordToSpreadCoord(&ViewRect); } // Inflate the IncludeRect in order to add a margin outside it. 72000mpt => 1 inch IncludeDocRect.Inflate(72000); // And include the rectangle into the new pasteboard rectangle DocRect NewBounds(PasteboardRect); NewBounds = NewBounds.Union(IncludeDocRect); // And now find the amount by which the "margin" should change, and inflate the pasteboard // rect in all directions, to keep the margin equal around the pages. INT32 InflateBy = 0; { InflateBy = ABS(NewBounds.lo.x - PasteboardRect.lo.x); INT32 temp = ABS(NewBounds.lo.y - PasteboardRect.lo.y); if (temp > InflateBy) InflateBy = temp; temp = ABS(NewBounds.hi.x - PasteboardRect.hi.x); if (temp > InflateBy) InflateBy = temp; temp = ABS(NewBounds.hi.y - PasteboardRect.hi.y); if (temp > InflateBy) InflateBy = temp; // Make sure we don't expand beyond the maximum size DocCoord MaxSize = GetMaxPasteboardSize(); if (PasteboardRect.Width() + 2*InflateBy > MaxSize.x) InflateBy = (MaxSize.x - PasteboardRect.Width()) / 2; if (PasteboardRect.Height() + 2*InflateBy > MaxSize.y) InflateBy = (MaxSize.y - PasteboardRect.Height()) / 2; // And inflate the original pasteboard NewBounds = PasteboardRect; NewBounds.Inflate(InflateBy, InflateBy); } // Now we have the required size and position, go and set it ChangePasteboardRect(NewBounds); // Make sure bounding rectangles are invalidated so that they are recalculated InvalidateBoundingRect(); // Now run through all spreads, lining up their pasteboards so they don't overlap, // and making sure that their default grids fully cover the pasteboards. // Note that this also ensures that the document is redrawn AdjustPasteboards(); Document *pParentDoc = (Document *) FindOwnerDoc(); if (pParentDoc != NULL) { // Pretend that page size has changed to cause related UI to change (rulers mainly) BROADCAST_TO_ALL(OptionsChangingMsg(pParentDoc, OptionsChangingMsg::NEWPAGESIZE)); } // Try to keep the scroll offsets sensible if (pView != NULL && pView->GetDoc() == pParentDoc) { // First, scroll to the previously visible view rectangle - this will adjust for the // new size of the pasteboard (i.e. new size of the view window extent) to make the // view look like it has not moved at all. pView->ScrollToShow(&ViewRect); // Now, make sure that the IncludeRect is visible on screen pView->ScrollToShow(&IncludeRect); } return(TRUE); // return - successful #else // Pasteboard can never expand. Sniffle, Sob! // We return TRUE if the pasteboard already includes the specified rectangle, and // FALSE if we would have to expand to include it. // Convert the Spread coordinates "IncludeRect" into Document coordinates "IncludeDocRect" DocRect IncludeDocRect(IncludeRect); SpreadCoordToDocCoord(&IncludeDocRect); // If the pasteboard is already big enough, return immediately (success) if (PasteboardRect.ContainsRect(IncludeDocRect)) return(TRUE); return(FALSE); #endif }

Layer * Spread::FindActiveLayer (  void   )

For finding the spreads active layer. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The active layer for the spread, or NULL if there is no active layer Note: a spread should always have one active layer, so in a DEBUG build an ENSURE failure will occur if no active layer exists. Errors: An ENSURE failure will occur if the spread has no active layer, or if the spread has more than one active layer. See also: - Definition at line 1096 of file spread.cpp. { // Changed by MarkN 11/8/94 to use Spread::FindFirstLayer()and Layer::FindNextLayer() Layer* pActiveLayer = NULL; Layer* pLayer = FindFirstLayer(); // Get first child BOOL MultipleActiveLayers = FALSE; while (pLayer != NULL) { if (pLayer->IsActive()) // we have found an active layer { // There should only ever be one active layer ERROR3IF(pActiveLayer != NULL, "Spread has more than one active layer"); if (pActiveLayer != NULL) MultipleActiveLayers = TRUE; pActiveLayer = pLayer; } pLayer = pLayer->FindNextLayer(); // Find next layer } // This line added by MarkN 22/3/95, to ensure that this function cannot fail // as long as there is at least one layer in this spread. // The MultipleActiveLayers added by Neville 12/6/96 so that multiple active layers // are fixed, if found. if (pActiveLayer == NULL || MultipleActiveLayers) LayerSGallery::EnsureActiveLayerIntegrity(this,&pActiveLayer); // Fail if the spread has no active layer return (pActiveLayer); }

NodeGrid * Spread::FindFirstDefaultGridInSpread (   )

Finds the first default grid that has been defined in this spread. Should be the only one present. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to the grid node. Will be NULL if no default grid is found. Errors: - See also: - Definition at line 2682 of file spread.cpp. { ERROR2IF(this==NULL,NULL,"Spread::FindFirstDefaultGridInSpread called on NULL pointer"); Node* pCurrentNode = FindFirstChild(); while(pCurrentNode != NULL) { if (pCurrentNode->IsKindOf(CC_RUNTIME_CLASS(NodeGrid))) { // Found a grid type node. Check if its a default type. NodeGrid* pCurrentGrid = (NodeGrid*)pCurrentNode; if (pCurrentGrid->IsDefault()) return (pCurrentGrid); } pCurrentNode = pCurrentNode->FindNext(); } return (NULL); // No default grids were found }