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 }

Layer * Spread::FindFirstFrameLayer (   )  const

To find the spread's first frame layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The first frame layer on the spread, or NULL if the spread has no layers. Errors: - See also: - Definition at line 1279 of file spread.cpp. { // Search through the children of this Spread, looking for Layer nodes. // Use the special flag for frame layers as its identifier. Layer* pLayer = FindFirstLayer(); while (pLayer != NULL) { // See if this is a frame layer if (pLayer->IsFrame()) { // Cor blimey, we've found one, so return this layer to the caller return pLayer; } pLayer = pLayer->FindNextLayer(); } // Nothing found return NULL; }

Layer * Spread::FindFirstGuideLayer (   )  const

To find the spread's first guide layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The first guide layer on the spread, or NULL if the spread has no layers. Errors: - See also: - Definition at line 1214 of file spread.cpp. { Layer* pLayer = FindFirstLayer(); while (pLayer != NULL) { if (pLayer->IsGuide()) return pLayer; pLayer = pLayer->FindNextLayer(); } return NULL; }

Layer * Spread::FindFirstLayer (   )  const

To find the spread's first layer. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The first layer on the spread, or NULL if the spread has no layers. Errors: - See also: - Definition at line 1146 of file spread.cpp. { Node* Current = FindFirstChild(); while (Current != NULL) { if (Current->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer)) { return (Layer*)Current; } Current = Current->FindNext(); } return (NULL); }

Layer * Spread::FindFirstPageBackgroundLayer (   )  const

To find the spread's first page background layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The first page background layer on the spread, or NULL if the spread has no layers. Errors: - See also: - Definition at line 1243 of file spread.cpp. { // Search through the children of this Spread, looking for Layer nodes. // Use the special flag of the page background layer as its identifier. Layer* pLayer = FindFirstLayer(); while (pLayer != NULL) { // See if this is a page background layer if (pLayer->IsPageBackground()) { // Cor blimey, we've found one, so return this layer to the caller return pLayer; } pLayer = pLayer->FindNextLayer(); } // Nothing found return NULL; }

Page * Spread::FindFirstPageInSpread (   )  const

To find the first page in a spread. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The first page in the spread, or NULL if the spread has no pages Errors: - See also: - Definition at line 1007 of file spread.cpp. { Node* CurrentNode = FindFirstChild(); while(CurrentNode != NULL) { if (CurrentNode->IsKindOf(CC_RUNTIME_CLASS(Page))) return ((Page*)CurrentNode); CurrentNode = CurrentNode->FindNext(); } return (NULL); // No pages were found }

Layer * Spread::FindLastFrameLayer (   )  const

To find the spread's last framelayer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The last frame layer on the spread, or NULL if the spread has no frame layers. Errors: - See also: - Definition at line 1315 of file spread.cpp. { // Search through the children of this Spread, looking for Layer nodes. // Use the special flag for frame layers as its identifier. Layer* pLayer = FindFirstLayer(); Layer* pLastLayer = NULL; while (pLayer != NULL) { // See if this is a frame layer if (pLayer->IsFrame()) { // Cor blimey, we've found one, so remember this as a potential last frame layer pLastLayer = pLayer; } pLayer = pLayer->FindNextLayer(); } // Return what we found as the last layer return pLastLayer; }

Layer * Spread::FindLastLayer (   )  const

To find the spread's last layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The last layer on the spread, or NULL if the spread has no layers. Errors: - See also: - Definition at line 1179 of file spread.cpp. { Node* pNode = FindFirstChild(); Layer* pLastLayer = NULL; while (pNode != NULL) { if (pNode->GetRuntimeClass() == CC_RUNTIME_CLASS(Layer)) pLastLayer = (Layer*)pNode; pNode = pNode->FindNext(); } return (pLastLayer); }

Page * Spread::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The last page on the spread, or NULL if the spread has no pages. Errors: - See also: FindFirstPageInSpread; Definition at line 1354 of file spread.cpp. { // Get the first page and then continually get the next page until one is not found // Each time we get a real page we note this as a potential last page. Page *pLastPage = NULL; Page *pPage = FindFirstPageInSpread(); while (pPage != NULL) { pLastPage = pPage; // note this page as a potential last page pPage = pPage->FindNextPage(); } // return what we think is the last page return pLastPage; }

Spread * Spread::FindNextSpread (  void   )

To find the next sibling spread. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The next sibling spread of this node, or NULL if there are no more spreads. Errors: - See also: - Definition at line 1036 of file spread.cpp. { Node* CurrentNode = FindNext(); while (CurrentNode != 0) { if (CurrentNode->IsSpread()) return (Spread*) CurrentNode; CurrentNode = CurrentNode->FindNext(); } return 0; // No spread found }

Chapter * Spread::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to the parent chapter of this spread. Will be NULL if no parent chapter is found. This of course should never happen. Errors: - See also: - Definition at line 2652 of file spread.cpp. { ERROR2IF(this==NULL,NULL,"Spread::FindParentChapter called on NULL pointer"); Node* pCurrentNode = FindParent(); while(pCurrentNode != NULL) { if (pCurrentNode->IsKindOf(CC_RUNTIME_CLASS(Chapter))) return ((Chapter*)pCurrentNode); pCurrentNode = pCurrentNode->FindParent(); } return NULL; }

Document * Spread::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 12/6/97 Returns: A pointer to the parent document of this spread. Definition at line 2610 of file spread.cpp. { BaseDocument *pBaseDoc = FindOwnerDoc(); // Make sure we have a real document if (!pBaseDoc || !pBaseDoc->IS_KIND_OF(Document)) { if (pBaseDoc == NULL) { ERROR3("Eh up, the spread has no parent document"); } else { ERROR3("Document is not a real Document - it's a BaseDocument!"); } return NULL; } Document *pDoc = (Document *) pBaseDoc; return pDoc; }

Spread * Spread::FindPreviousSpread (  void   )

To find the current spreads previous sibling spread. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The previous sibling spread of this node, or NULL if there are none. Errors: - See also: - Definition at line 1064 of file spread.cpp. { Node* CurrentNode = FindPrevious(); while (CurrentNode != 0) { if (CurrentNode->IsSpread()) return (Spread*) CurrentNode; CurrentNode = CurrentNode->FindPrevious(); } return 0; // No spread found }

DocRect Spread::GetAnimationBoundingRect (   )

Returns the stored animation bounding rect for this spread. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 10/06/97 Returns: the stored bounding rect for the animation Definition at line 4240 of file spread.cpp. { return m_AnimPropertiesParam.GetBoundingRect(); }

void Spread::GetAnimationColours (  DITHER *  pDither, WEB_PALETTE *  pWebPalette, PALETTE_COLOURS *  pColoursPalette, DWORD *  pNumColsInPalette, BOOL *  pIsBackgroundTransparent )

Definition at line 3941 of file spread.cpp. { if (pDither != NULL) *pDither = m_AnimPropertiesParam.GetDither(); if (pWebPalette != NULL) *pWebPalette = m_AnimPropertiesParam.GetPalette(); if (pColoursPalette != NULL) *pColoursPalette = m_AnimPropertiesParam.GetPaletteCols(); if (pNumColsInPalette != NULL) *pNumColsInPalette = m_AnimPropertiesParam.GetNumColsInPalette(); if (pIsBackgroundTransparent != NULL) *pIsBackgroundTransparent = m_AnimPropertiesParam.GetIsBackGroundTransp(); }

Quality Spread::GetAnimationQuality (   )

Returns the stored quality that the animation for this spread was captured at. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/97 Returns: the stored quality for the animation Definition at line 4274 of file spread.cpp. { return m_AnimPropertiesParam.GetAnimationQuality(); }

MILLIPOINT Spread::GetBleedOffset (   )  const

For getting the Spread's bleed area size. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current size in millipoints of this spreads bleed are. Errors: - See also: SetBleedOffset(); Definition at line 1608 of file spread.cpp. { return BleedOffset; }

DocRect Spread::GetBoundingRect (  BOOL  DontUseAttrs = FALSE, BOOL  HitTest = FALSE )  [virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 11/9/94 Parameters: DontUseAttrs  - If this is TRUE the node should not try to use the [INPUTS] attributes associated with the node. It will also leave the flag IsBoundingRectValid FALSE. This var defaults to FALSE HitTest - TRUE if being called during HitTest Returns: The nodes bounding rectangle Reimplemented from NodeRenderableBounded. Definition at line 328 of file spread.cpp. { // if the bounding rect of this node is not valid then fill in something if (!IsBoundingRectValid || DontUseAttrs) { // just set it to be an empty rectangle DocRect BoundRect(0,0,0,0); Node* pNode = FindFirstChild(); while (pNode!=NULL) { // Add in the bounding rect of this node with all the others if (pNode->IsBounded()) BoundRect = BoundRect.Union(((NodeRenderableBounded*)pNode)->GetBoundingRect(DontUseAttrs)); // And find the next node pNode = pNode->FindNext(); } // Convert the bounding rect obtained from spread coords to document coords SpreadCoordToDocCoord(&BoundRect); if (DontUseAttrs) return BoundRect; // Copy the unions into the nodes bounding rect param BoundingRectangle = BoundRect; // mark the bounding rect as valid IsBoundingRectValid = TRUE; } // and return the bounding rect return BoundingRectangle; }

void Spread::GetDebugDetails (  StringBase *  Str  )  [virtual]

For obtaining debug information about the Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: -  [INPUTS] Str,:  String giving debug info about the node [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from NodeRenderablePaper. Definition at line 1433 of file spread.cpp. { NodeRenderablePaper::GetDebugDetails(Str); String_256 TempStr; TempStr._MakeMsg(TEXT("\r\nBleed Offset = #1%ld"), BleedOffset); *Str += TempStr; TempStr._MakeMsg(TEXT("\r\nSpreadCoord Origin = #1%ld, #2%ld"), SpreadOrigin.x, SpreadOrigin.y); *Str += TempStr; }

BOOL Spread::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). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 18/1/95 Returns: FALSE if fails Parameters: dp  - number of dp (-ve values limited to 0) [OUTPUTS] Definition at line 2933 of file spread.cpp. { DimScale* pDimScale=DimScale::GetPtrDimScale(this); ERROR2IF(pDimScale==NULL,FALSE,"Spread::GetDecimalPlacesForPixelResolution() - pDimScale==NULL"); INT32 xdp=2; INT32 ydp=2; double MPPerUnit=0.0; if( pDimScale->ConvertToDouble( String_8( _T("1") ), &MPPerUnit ) == FALSE ) return FALSE; FIXED16 PixelWidth, PixelHeight; pView->GetScaledPixelSize(&PixelWidth, &PixelHeight); if (PixelWidth==0 || PixelHeight==0) return FALSE; ERROR2IF(MPPerUnit<1,FALSE,"Spread::GetDecimalPlacesForPixelResolution() - Millipoints per Unit < 1!"); xdp=(INT32)log10(MPPerUnit/PixelWidth.MakeDouble() )+1; ydp=(INT32)log10(MPPerUnit/PixelHeight.MakeDouble())+1; if (xdp<0) xdp=0; if (ydp<0) ydp=0; *dp = xdp>ydp ? xdp : ydp; return TRUE; }

DocRect Spread::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. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 25/09/96 Returns: Size of the rectangle encompassing the drawing. Definition at line 381 of file spread.cpp. { // Start out with an empty clip rectangle. DocRect SpreadRect; SpreadRect.MakeEmpty (); // Find the first layer in the spread. Layer* pLayer = FindFirstLayer (); // Loop through the layers, and union the bounding boxes of all visible, non-background // layers. while ( pLayer != NULL ) { // Let's see if it is visible, and not a background layer. if ( pLayer->IsVisible() && !pLayer->IsBackground () ) { // This one is visible, so union its bounding box in. SpreadRect = SpreadRect.Union(pLayer->GetBoundingRect () ); } // Find the next layer. pLayer = pLayer->FindNextLayer (); } // Return the found rectangle to the caller. return SpreadRect; }

DocCoord Spread::GetMaxPasteboardSize (  void   )

To determine the maximum size that the pasteboard will allow itself to be expanded to. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/2/96 Returns: The maximum pasteboard size (x,y) Notes: In document coordinates, the bottom left of the pasteboard is fixed. However, by moving all objects inside the pasteboard (all spread coords) we can effectively expand the pasteboard in any direction. Thus, if the pasteboard width/height is smaller than the returned maximum, you can still expand the pasteboard in any direction. Thus, the return value from this method gives the maximum size rather than the max position rectangle. See also: Spread::ExpandPasteboardToInclude Definition at line 3178 of file spread.cpp. { #if !NEW_PASTEBOARD ERROR3("Warning: GetMaxPasteboardSize is unsupported at present! See Jason/Phil"); #endif DocCoord MPB(MaxPasteboardSize, MaxPasteboardSize); return(MPB); }

UINT32 Spread::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Definition at line 1463 of file spread.cpp. { return (sizeof(Spread)); }

DocRect Spread::GetPageBounds (   )  const

Finds the bounding rectangle of this Spread, defined as the smallest rectangle enclosing all the Pages the Spread contains. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A document rectangle which is the rectangle bounding all Pages in this Spread. This really is a document rectangle, not a spread rectangle hiding as a DocRect, ie. it is relative to the bottom-left of the document, not the spread. Errors: - See also: Page::GetPageRect Definition at line 1489 of file spread.cpp. { // Start with an empty bounding rectangle. DocRect drBound; drBound.MakeEmpty(); // Search through the children of this Spread, looking for Page nodes. Node* Current = FindFirstChild(); while (Current != NULL) { if (Current->GetRuntimeClass() == CC_RUNTIME_CLASS(Page)) { // Found a page node. Take the union of its bounding rectangle and // the accumulated bounds. drBound = drBound.Union(((Page*) Current)->GetPageRect()); } Current = Current->FindNext(); } // Convert the value from spread coordinates to document coords SpreadCoordToDocCoord(&drBound); // Return the accumulated bounds. return drBound; }

BOOL Spread::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/1/95 Parameters: -  [INPUTS] Width  returned width of the page in millipoints [OUTPUTS] Height returned height of the page in millipoints Margin returned size of the margin area in millipoints (0 = none) Bleed returned size of the bleed area in millipoints (0 = none) Dps returned whether another page (or pages) is present or not. ShowDropShadow returned new drop shadow display state. Returns: Whether we completed the scanning operation ok or not as True or False. Note: Any of the input params can be NULL (Markn 4/4/95) Returns: Errors: Will error if pages are not consistent. See also: SetPageSize; Definition at line 2097 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::GetPageSize called on NULL pointer"); // Set up defaults in case of dodgy exit if (Width != NULL) *Width = 0; if (Height != NULL) *Height = 0; if (Margin != NULL) *Margin = 0; if (Bleed != NULL) *Bleed = 0; if (Dps != NULL) *Dps = FALSE; // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER if (ShowDropShadow != NULL) *ShowDropShadow = TRUE; #endif //webster Page *pPage = FindFirstPageInSpread(); ERROR2IF(pPage == NULL,FALSE,"Spread::GetPageSize(): Could not find first Page"); // Measured in millipoints DocRect PageRect = pPage->GetPageRect(); MILLIPOINT PageWidth = PageRect.Width(); MILLIPOINT PageHeight = PageRect.Height(); // Set up the return height and width according to this first page if (Width != NULL) *Width = PageWidth; if (Height != NULL) *Height = PageHeight; // Get present low corner position, we will use this to calculate the gap around the pages DocCoord Low = PageRect.LowCorner(); // Assume: Margin = the position of the bottom left hand corner of the old page. // Use y as the initial defualt page is shifted across giving large x and correct y. if (Margin != NULL) *Margin = Low.y; // Find out if dps by finding the next page in the spread and see if measurements are // the same as at present. Will only work in the simple case. pPage = pPage->FindNextPage(); if (pPage != NULL) { // Measured in millipoints DocRect Page2Rect = pPage->GetPageRect(); MILLIPOINT Page2Width = PageRect.Width(); MILLIPOINT Page2Height = PageRect.Height(); // lox,loy,hix,hiy if( Page2Rect.lo.x == PageRect.hi.x && Page2Rect.lo.y == PageRect.lo.y && Page2Width == PageWidth && Page2Height == PageHeight) { if (Dps != NULL) *Dps = TRUE; } else { // unrecognised page structure found ERROR2(FALSE,"bad page structure found in Spread::GetPageSize"); } } else { if (Dps != NULL) *Dps = FALSE; } // Now get the current bleed size for the spread if (Bleed != NULL) *Bleed = GetBleedOffset(); if (ShowDropShadow != NULL) *ShowDropShadow = GetShowDropShadow(); return TRUE; }

BOOL Spread::GetPagesRect (  DocRect *  pPagesRect  )

Get the union rect of all pages on the spread (in SpreadCoords). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: pPagesRect  [OUTPUTS] Returns: FALSE if fails (PagesRect unchanged) Errors: pPagesRect==NULL no pages in spread Definition at line 2771 of file spread.cpp. { ERROR2IF(pPagesRect==NULL,FALSE,"Spread::GetPagesRect() - pPagesRect==NULL"); Page* pPage=FindFirstPageInSpread(); ERROR2IF(pPage==NULL,FALSE,"Spread::GetPagesRect() - no pages in spread!"); *pPagesRect=pPage->GetPageRect(); pPage=pPage->FindNextPage(); while (pPage) { DocRect PageRect=pPage->GetPageRect(); *pPagesRect=pPagesRect->Union(PageRect); pPage=pPage->FindNextPage(); } return TRUE; }

DocRect Spread::GetPageVisibleBounds (   )  const

Finds the bounding rectangle of this Spread, defined as the smallest rectangle enclosing all the Pages the Spread contains. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A document rectangle which is the rectangle bounding all Pages in this Spread. This really is a document rectangle, not a spread rectangle hiding as a DocRect, ie. it is relative to the bottom-left of the document, not the spread. The visible bounds exclude all non-visible layers Returns: Errors: - See also: Page::GetPageRect Definition at line 1540 of file spread.cpp. { // Start with an empty bounding rectangle. DocRect drBound; drBound.MakeEmpty(); // Search through the children of this Spread, looking for Layer nodes. Layer* pCurrent = ((Spread*)this)->FindFirstLayer(); while (pCurrent != NULL) { // Only add the bounding box of the layer in if it is visible and if it is not // either a guide layer or the page background layer. if (pCurrent->IncludeLayerInBoundingCalcs()) { // Found a visible layer node. Take the union of its bounding rectangle and // the accumulated bounds. drBound = drBound.Union(pCurrent->GetBoundingRect()); } pCurrent = pCurrent->FindNextLayer(); } // Convert the value from spread coordinates to document coords SpreadCoordToDocCoord(&drBound); // Return the accumulated bounds. return drBound; }

DimScale * Spread::GetPtrDimScale (   )

For getting a ptr to the Spread's dimension scale object. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A ptr to the dimension scale object for all objects in this Spread Errors: - See also: - Definition at line 1586 of file spread.cpp. { return (&SpreadDimScale); }

BOOL Spread::GetShowDropShadow (   )  const

Finds out the current drop shadow display state. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current drop shadow display state as either True or False. Errors: - See also: SetShowDropShadow(); Definition at line 1654 of file spread.cpp. { return ShowDropShadow; }

AnimPropertiesParam & Spread::GetSpreadAnimPropertiesParam (   )

Returns the the Animation Properties details for this spread. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 07/05/97 Definition at line 4145 of file spread.cpp. { return m_AnimPropertiesParam; }

BOOL Spread::GetSpreadAnimPropertiesParam (  DWORD *  Loop, DWORD *  GlobalDelay, DITHER *  Dither, WEB_PALETTE *  WebPalette, PALETTE_COLOURS *  ColoursPalette, DWORD *  NumColsInPalette, BOOL *  UseSystemColours, BOOL *  IsBgTransparent )

Allows access to the Animation Properties details for this spread. Notes: Karim 07/12/00 - added IsBgTransparent parameter. BOOL Spread::GetSpreadAnimPropertiesParam(DWORD *Loop, DWORD *GlobalDelay, DITHER *Dither, WEB_PALETTE *WebPalette, PALETTE_COLOURS* ColoursPalette, DWORD* NumColsInPalette, BOOL* UseSystemColours, BOOL* IsBgTransparent) Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 01/04/97 Definition at line 4193 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::GetSpreadAnimProperties cslled on NULL pointer"); *Loop = m_AnimPropertiesParam.GetAnimLoop(); *GlobalDelay = m_AnimPropertiesParam.GetGlobalAnimDelay(); *Dither = m_AnimPropertiesParam.GetDither(); *WebPalette = m_AnimPropertiesParam.GetPalette(); *ColoursPalette = m_AnimPropertiesParam.GetPaletteCols(); *NumColsInPalette = m_AnimPropertiesParam.GetNumColsInPalette(); *UseSystemColours = m_AnimPropertiesParam.GetUseSystemCols(); if (IsBgTransparent != NULL) *IsBgTransparent= m_AnimPropertiesParam.GetIsBackGroundTransp(); return TRUE; }

DocCoord Spread::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. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/96 Parameters: Pixelise  - TRUE if you want the coordinate pixelised [INPUTS] pView - NULL, or the View to use for pixelisation purposes. (These inputs are exactly the same as those in GetPasteboardRect) Returns: The spread coordinate origin, in document coordinates Notes: In the past, spread coords shared their origin with the bottom left corner of a spread's pasteboard. Obviously, if we tried to move this corner, we got into deep strife, so I've separated out the 2 points. By default the origin will happen to sit on the bottom left corner of the pasteboard, but this will change if the pasteboard is ever resized. Generally the SCO does not move (unless you have multiple spreads and a whole spread has to shift down to make room). WARNING: Because the SCO is not associated with the pasteboard corner any more, it is easy to resize the pasteboard so that the SCO lies *outside* the pasteboard. This can cause ERROR3's to go off if you try to call FindEnclosingChapter on the SCO (because no chapter encloses it!). Note that FindEnclosingChapter is called by the (document form) of DocCoord::ToWork. I have changed the ERROR3 message to point at this warning. See also: NodePaper::GetPasteBoardRect; Spread::SetSpreadCoordOrigin Definition at line 3001 of file spread.cpp. { #if NEW_PASTEBOARD // New functionality: Spread Origin is separate from pasteboard bottom left corner if (Pixelise) { DocCoord temp(SpreadOrigin); if (pView != NULL) temp.Pixelise(pView); else temp.Pixelise(); return(temp); } return(SpreadOrigin); #else // To keep the old functionality, the spread origin currently always sits on the // pasteboard bottom left corner. if (Pixelise) { DocCoord temp(PasteboardRect.lo); if (pView != NULL) temp.Pixelise(pView); else temp.Pixelise(); return(temp); } return(PasteboardRect.lo); #endif }

DocCoord Spread::GetUserOrigin (   )

Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/95 Returns: Offset from SpreadCoords to UserCoords Definition at line 2753 of file spread.cpp. { return UserOrigin; }

DocRect Spread::GetWidePasteboard (  View *  pView  )

Return the pixelised boundary of the "wide pasteboard". Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 22/11/94 Parameters: pView  - the view to pixelise to. [INPUTS] Definition at line 1381 of file spread.cpp. { ERROR2IF(this==NULL,DocRect(0,0,0,0),"GetWidePasteboard called on NULL pointer"); // A large size - roughly the width/height of 30 A4 pages. We use this to extend // the WPB to an effective "infinity" in certain directions. const MILLIPOINT LargeNumber = 30 * (10 * 72000); DocRect WPB(PasteboardRect); // Inflate the left/right sides out to effective "infinity" WPB.Inflate(LargeNumber, 0); // If this is the very last spread in the chapter, expand its WPB down by "infinity" if (FindNextSpread() == NULL) WPB.lo.y -= LargeNumber; // Pixelise and return the result WPB.lo.Pixelise(pView); WPB.hi.Pixelise(pView); return(WPB); }

BOOL Spread::IsSpread (   )  const [virtual]

Tell the caller that this is a spread node. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 15/02/95 Returns: TRUE - this IS a spread node. Reimplemented from Node. Definition at line 421 of file spread.cpp. { // Yes, this is a spread! return TRUE; }

BOOL Spread::NeedsToExport (  RenderRegion *  pRender, BOOL  VisibleLayersOnly = FALSE, BOOL  CheckSelected = FALSE )  [virtual]

Indicate that we don't want to export this class of nodes. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/12/2004 Parameters: pRender  - A pointer to the current export region (null if none) [INPUTS] VisibleLayersOnly - TRUE => remove nodes which are on invisible layers FALSE => export everything CheckSelected - TRUE => we check if object selected and only export selected bjects FALSE => we don't bother checking for selection or not Returns: FALSE => we never want to export NodeRenderablePaper objects. See also: NodeRenderablePaper::NeedsToRender Reimplemented from NodeRenderablePaper. Definition at line 4315 of file spread.cpp. { return TRUE; }

BOOL Spread::PagesCoordToSpreadCoord (  DocCoord *  pSpreadCoord, DocCoord  PagesCoord )

Convert PagesCoord (relative to union of pages in spread) to SpreadCoord. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: PagesCoord  [INPUTS] pSpreadCoord  [OUTPUTS] Returns: FALSE if fails (SpreadCoord unchanged) Definition at line 2826 of file spread.cpp. { ERROR2IF(pSpreadCoord==NULL,FALSE,"Spread::PagesCoordToSpreadCoord() - pSpreadCoord==NULL"); DocRect PagesRect; if (GetPagesRect(&PagesRect)==FALSE) return FALSE; *pSpreadCoord=PagesCoord+PagesRect.lo; return TRUE; }

void Spread::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeRenderablePaper. Definition at line 981 of file spread.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, Spread), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, Spread)) CopyNodeContents((Spread*)pNodeCopy); }

BOOL Spread::PostImport (  void   )  [protected, virtual]

This function is called after a document is imported. Nodes should override this function to do any post-import processing. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/3/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE/FALSE for success/failure The spread overrides this function in order to automatically resize its pasteboard to include all the newly imported nodes if possible. Notes: Calls the base class PostImport after doing its own processing See also: Node::PostImport Reimplemented from Node. Definition at line 3578 of file spread.cpp. { // Get the bounding rect. This comes back in document coords, so we convert to spread // coords and then call ExpandPasteboardToInclude to include our bounds in the PB area. if (NodeRenderablePaper::PostImport()) { DocRect Bounds = GetBoundingRect(); DocCoordToSpreadCoord(&Bounds); ExpandPasteboardToInclude(Bounds); AdjustPasteboards(); return(TRUE); } return(FALSE); }

void Spread::Render (  RenderRegion *  pRender  )  [virtual]

Renders spread items: Pasteboard and off-paste area Main fold line Spread dividers Bleed Area Drop-shadows Spread outline Print margin. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 10/5/93 Parameters: pRender  - The render region to draw into [INPUTS] Reimplemented from Node. Definition at line 797 of file spread.cpp. { // If we should blow up, then blow up - don't worry, this is a very quick inline check OpException::BlowUpOnCrashMe(); // ralph only renders paper/pasteboard in some view modes #ifdef RALPH //find the parent NodeDocument Node* pCurrentNode = FindParent(); while(pCurrentNode != NULL) { if (pCurrentNode->IsNodeDocument()) break; pCurrentNode = pCurrentNode->FindParent(); } BaseDocument * pDoc =NULL; // get a Document * if(pCurrentNode) pDoc = ((NodeDocument*)(pCurrentNode))->GetParentDoc(); // set RalphDontShowPaper - it will be tested in RenderPasteboard if(pDoc) RalphDontShowPaper =((Document*)pDoc)->RalphDontShowPaper(); #endif // --- Render pasteboard --- RenderPasteboard(pRender); if(!RalphDontShowPaper) { // --- Render main fold line --- Chapter* pChapter = FindParentChapter(); ERROR3IF(pChapter == NULL,"Spread::Render: Could not find parent chapter"); if (pChapter != NULL && pChapter->ShouldShowFoldLine()) { MILLIPOINT MainFoldLineXCoord = pChapter->GetFoldLineXCoord(); DocRect PBRect = GetPasteboardRect(TRUE, pRender->GetRenderView()); pRender->SetLineWidth(0); // Means single-pixel lines pRender->SetLineColour(COLOUR_TRANS); DocColour COLOUR_FOLDLINE = DocColour(150L, 150L, 150L); COLOUR_FOLDLINE.SetSeparable(FALSE); // Don't colour-separate the fold line pRender->SetFillColour(COLOUR_FOLDLINE); pRender->DrawPixelLine(DocCoord(MainFoldLineXCoord, PBRect.lo.y), DocCoord(MainFoldLineXCoord, PBRect.hi.y)); } // --- Render spread dividers --- // Set the colour for the spread divide (mid grey) /* DocColour COLOUR_SPREADDIVIDE = DocColour(64L, 32L, 32L); //DocColour(127L, 127L, 127L); COLOUR_SPREADDIVIDE.SetSeparable(FALSE); // Don't colour-separate the spread divider pRender->SetLineColour(COLOUR_SPREADDIVIDE); // Set the line width (Wider for the first spread in the chapter) if (FindPrevious()==NULL) { MILLIPOINT LineWidth = 4*PixelHeight; pRender->SetLineWidth(LineWidth); } else pRender->SetLineWidth(0); // Draw line along the top of the pasteboard View *pView = pRender->GetRenderView(); MILLIPOINT Width = GetWidePasteboard(pView).Width(); MILLIPOINT Height = GetWidePasteboard(pView).Height(); pRender->DrawLine(DocCoord(-Width, Height), DocCoord(Width, Height)); */ if (FindPreviousSpread()!=NULL) { DocColour COLOUR_SPREADDIVIDE = DocColour(64L, 32L, 32L); //DocColour(127L, 127L, 127L); COLOUR_SPREADDIVIDE.SetSeparable(FALSE); // Don't colour-separate the spread divider pRender->SetFillColour(COLOUR_SPREADDIVIDE); View *pView = pRender->GetRenderView(); DocRect sd = GetWidePasteboard(pView); DocCoordToSpreadCoord(&sd); FIXED16 ScaledPixelWidth; FIXED16 ScaledPixelHeight; pRender->GetRenderView()->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); sd.lo.y = sd.hi.y - ScaledPixelWidth.MakeLong(); pRender->DrawRect(&sd); } // --- Render drop shadows --- if (ShowDropShadow) RenderDropShadows( pRender ); // --- Render bleed area, if not 0 size --- // Render after page shadow as otherwise page shadow may overdraw the bleed margin // and the bleed margin will disappear. RenderBleedArea(pRender); } }

void Spread::RenderBleedArea (  RenderRegion *  pRender  )  [protected]

Renders the Bleed Area rectangle if the BleedOffset is not 0 Scope: private. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/93 Definition at line 741 of file spread.cpp. { if (BleedOffset != 0) { // Draw a rectangle BleedOffset outside the common bounding rectangle of all pages // in the spread. // Calculate the common bounding rectangle of all the spread's pages DocRect BleedRectangle; Page* CurrentPage = FindFirstPageInSpread(); while(CurrentPage != NULL) { DocRect PageRect = CurrentPage->GetPageRect(); BleedRectangle = BleedRectangle.Union(PageRect); CurrentPage = CurrentPage->FindNextPage(); } BleedRectangle.Inflate(BleedOffset); // Ensure plotting does not use dithered colours pRender->SetSolidColours(TRUE); // Draw a rectangle covering the page // Set up attributes for drawing page rectangle pRender->SetLineWidth(0); // Means single-pixel lines pRender->SetLineColour(COLOUR_TRANS); DocColour COLOUR_BLEEDAREA(COLOUR_RED); pRender->SetFillColour(COLOUR_BLEEDAREA); pRender->DrawPixelRect(&BleedRectangle); // And return to normal dithered rendering pRender->SetSolidColours(FALSE); } }

void Spread::RenderDropShadows (  RenderRegion *  pRender  )  [protected]

To render right-hand and bottom drop shadows Scope: private. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 11/5/93 Definition at line 582 of file spread.cpp. { // If we have the new page background layer present then we needn't bother redrawing the // page as we might get a flash of white as we redraw // Therefore, we don't need to add a pixel on the right hand side page border BOOL PageBackgroundPresent = FALSE; // Is there a page background layer on the spread? Layer* pLayer = FindFirstPageBackgroundLayer(); // Yes, the layer is present but is it visible? if (pLayer && pLayer->IsVisible()) PageBackgroundPresent = TRUE; // Ensure filled areas are not dithered pRender->SetSolidColours(TRUE); // Setup attributes pRender->SetLineWidth(0); // means single pixel lines pRender->SetLineColour(COLOUR_TRANS); DocColour COLOUR_SHADOW(COLOUR_MIDGREY); pRender->SetFillColour(COLOUR_SHADOW); // Get the scaled pixel size for the view FIXED16 ScaledPixelWidth; FIXED16 ScaledPixelHeight; pRender->GetRenderView()->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); // Find out how many millipoints 4 pixels is MILLIPOINT DropWidth = 4 * (min(ScaledPixelWidth.MakeLong(), ScaledPixelHeight.MakeLong() )); MILLIPOINT ExtraPixel = ScaledPixelWidth.MakeLong(); if (PageBackgroundPresent) ExtraPixel = 0; // The page we are currently drawing drop shadows for Page* CurrentPage = FindFirstPageInSpread(); //Render drop shadows for each page in turn while (CurrentPage != NULL) { // Will indicate if page has a left or right drop shadow BOOL PageHasADropShadow = FALSE; DocRect PageRect = CurrentPage->GetPageRect(); // If the current page has no page to its right then we should render a right-hand // drop shadow if (!(CurrentPage->FindRightPage())) { // Take width of page outline into account by rendering drop shadow one pixel beyond // edge of page! This makes drop shadow same width as its height below the page. DocRect RightHandDropShadow(PageRect.HighCorner().x + ExtraPixel, PageRect.LowCorner().y - DropWidth, PageRect.HighCorner().x + DropWidth + ExtraPixel, PageRect.HighCorner().y - DropWidth ); pRender->DrawRect(&RightHandDropShadow); /* // Attempt to render fuzzy shadow edge using bitmap... { DocRect r = RightHandDropShadow; CWxBitmap* pBitmap = new CWxBitmap(); pBitmap->LoadBitmap(_R(IDB_SPREAD_RIGHTEDGE)); KernelBitmap* pkBitmap = new KernelBitmap(pBitmap, TRUE); pRender->RenderBits(pkBitmap, (DocCoord*)&r, 2, TRUE, NULL); // Unclean! if (pBitmap) { pBitmap->BMBytes = ((CWxBitmap*)OILBitmap::Default)->BMBytes; } if (pkBitmap) { delete pkBitmap; pkBitmap = NULL; } } */ PageHasADropShadow = TRUE; } // If the current page has no page vertically joined beneath it then render a // bottom drop shadow. if (!(CurrentPage->FindBottomPage())) { //Render bottom drop shadow DocRect BottomDropShadow(PageRect.LowCorner().x + DropWidth, PageRect.LowCorner().y - DropWidth, PageRect.HighCorner().x + DropWidth, PageRect.LowCorner().y ); pRender->DrawRect(&BottomDropShadow); /* // Attempt to render fuzzy shadow edge using bitmap... { DocRect r = BottomDropShadow; CWxBitmap* pBitmap = new CWxBitmap(); pBitmap->LoadBitmap(_R(IDB_SPREAD_BOTTOMEDGE)); KernelBitmap* pkBitmap = new KernelBitmap(pBitmap, TRUE); pRender->RenderBits(pkBitmap, (DocCoord*)&r, 2, TRUE, NULL); // Unclean! if (pBitmap) { pBitmap->BMBytes = ((CWxBitmap*)OILBitmap::Default)->BMBytes; } if (pkBitmap) { delete pkBitmap; pkBitmap = NULL; } } */ PageHasADropShadow = TRUE; } // This bit is not very beautiful. If a page has a page to its right and a page beneath // it, and the page to its right does not have have a page beneath it, then there will // be a little cube of drop shadow left to draw at the bottom right hand corner of the // page. if (!PageHasADropShadow) { // The page has a page to its right and a page beneath it ENSURE( CurrentPage->FindRightPage(), "Spread::RenderDropShadows: Cannot find right page"); if (CurrentPage->FindRightPage()->FindBottomPage() == NULL) { DocRect MissingCube(PageRect.HighCorner().x, PageRect.LowCorner().y - DropWidth, PageRect.HighCorner().x + DropWidth, PageRect.LowCorner().y); pRender->DrawRect(&MissingCube); } } // Move to next page CurrentPage = CurrentPage->FindNextPage(); } // And return to normal dithered rendering pRender->SetSolidColours(FALSE); }

void Spread::RenderPasteboard (  RenderRegion *  pRender  )  [protected]

To render the pasteboard and off-paste area. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Scope: Private See also: - Definition at line 445 of file spread.cpp. { // Ensure we don't dither the filled areas pRender->SetSolidColours(TRUE); // Ensure that the top coord of this pasteboard is exactly the same as the bottom of // the upper pasteboard. #ifdef _DEBUG Spread* PrevSpread = FindPreviousSpread(); if (PrevSpread != NULL) ENSURE((PasteboardRect.HighCorner().y == PrevSpread->GetPasteboardRect(FALSE,pRender->GetRenderView()).LowCorner().y), "Spreads are not properly vertically aligned"); #endif // Find out the Clip rect of the render region to help decide which rectangles to try to draw DocRect SpreadPasteboard = GetWidePasteboard(pRender->GetRenderView()); DocCoordToSpreadCoord(&SpreadPasteboard); Page* CurrentPage = FindFirstPageInSpread(); // --- Divide the pasteboard up into filled rectangles and render them --- DocRect CurrentPageRect = CurrentPage->GetPageRect(); // Ensure that we have a transparent line colour throughout pRender->SetLineColour(COLOUR_TRANS); // Set up a pasteboard colour DocColour COLOUR_PASTEBOARD(192L, 192L, 192L); #ifdef NO_SPREAD COLOUR_PASTEBOARD = DocColour(Page::PageColour); #endif // colour the pasteboard white to hide it if we're in ralph DRAWING_VIEW mode // ( this flag is set in Render() ) if (RalphDontShowPaper) COLOUR_PASTEBOARD = DocColour(255L, 255L, 255L); COLOUR_PASTEBOARD.SetSeparable(FALSE); // Don't colour-separate the pasteboard // We can now have a zero sized top pasteboard and due to pixelization of the // SpreadPasteboard DocRect this may give rise to errors if Top is just // constructed. So we must check it before hand. // Effectively doing the same as the ENSURE((Low.x <= High.x) && (Low.y <= High.y) // in the DocRect constructor. if (SpreadPasteboard.HighCorner().y > CurrentPageRect.HighCorner().y) { // Render the top pasteboard rectangle DocRect Top(DocCoord(SpreadPasteboard.LowCorner().x, CurrentPageRect.HighCorner().y), DocCoord(SpreadPasteboard.HighCorner().x, SpreadPasteboard.HighCorner().y)); pRender->SetFillColour(COLOUR_PASTEBOARD); pRender->DrawRect(&Top); } // For each row of pages in a spread, render a rectangle to the left of the left-most // page reaching the left of the pasteboard, and a rectangle to the right of the right-most // page reaching the right of the pasteboard. Also if any off-paste area needs to be rendered // then render a rectangle to the right of the right pasteboard rectangle. do { // Render rectangle to the left of the left-most page but first check // that there is enough of a left section to worry about if (CurrentPageRect.LowCorner().x > SpreadPasteboard.LowCorner().x) { // Render rectangle to the left of the left-most page DocRect Left(DocCoord(SpreadPasteboard.LowCorner().x, CurrentPageRect.LowCorner().y), DocCoord(CurrentPageRect.LowCorner().x, CurrentPageRect.HighCorner().y)); pRender->SetFillColour(COLOUR_PASTEBOARD); pRender->DrawRect(&Left); } // Find the right-most page in the current row while (CurrentPage->FindRightPage()) CurrentPage = CurrentPage->FindNextPage(); CurrentPageRect = CurrentPage->GetPageRect(); // Render rectangle to the right of the right-most page but first check // that there is enough of a right section to worry about if (SpreadPasteboard.HighCorner().x > CurrentPageRect.HighCorner().x) { // Render a rectangle to the right of the right-most page DocRect Right(DocCoord(CurrentPageRect.HighCorner().x, CurrentPageRect.LowCorner().y), DocCoord(SpreadPasteboard.HighCorner().x, CurrentPageRect.HighCorner().y)); pRender->SetFillColour(COLOUR_PASTEBOARD); // added 24/3/97 pRender->DrawRect(&Right); } CurrentPage = CurrentPage->FindNextPage(); // Move to the first page in the next row if (CurrentPage != NULL) { CurrentPageRect = CurrentPage->GetPageRect(); } } while (CurrentPage != NULL); // While there are more rows // Check that there is enough of a bottom section to worry about if (CurrentPageRect.LowCorner().y > SpreadPasteboard.LowCorner().y) { // Render a rectangle below the lowest page DocRect Bottom(DocCoord(SpreadPasteboard.LowCorner().x, SpreadPasteboard.LowCorner().y), DocCoord(SpreadPasteboard.HighCorner().x, CurrentPageRect.LowCorner().y)); pRender->SetFillColour(COLOUR_PASTEBOARD); pRender->DrawRect(&Bottom); } // And revert to normal dithered plotting pRender->SetSolidColours(FALSE); }

SubtreeRenderState Spread::RenderSubtree (  RenderRegion *  pRender, Node **  ppNextNode = NULL, BOOL  bClip = TRUE )  [virtual]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 12/07/2004 Returns: indicator as to whether rendering can proceed in this subtree Reimplemented from NodeRenderablePaper. Definition at line 4291 of file spread.cpp. { return SUBTREE_ROOTANDCHILDREN; }

void Spread::SetAnimationBoundingRect (  const DocRect &  BoundingRect  )

Sets the new stored bounding rect for this spread. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 10/06/97 Parameters: BoundingRect  - the new bounding rect for this spread. [INPUTS] Definition at line 4224 of file spread.cpp. { m_AnimPropertiesParam.SetBoundingRect(BoundingRect); }

void Spread::SetAnimationColours (  const DITHER &  Dither, const WEB_PALETTE &  WebPalette, const PALETTE_COLOURS &  ColoursPalette, const DWORD &  NumColsInPalette, const BOOL &  IsBackgroundTransparent )

Definition at line 3900 of file spread.cpp. { // test if we need to junk any cached bitmaps if (Dither != m_AnimPropertiesParam.GetDither() || WebPalette != m_AnimPropertiesParam.GetPalette() || ColoursPalette != m_AnimPropertiesParam.GetPaletteCols() || NumColsInPalette != m_AnimPropertiesParam.GetNumColsInPalette() || IsBackgroundTransparent != m_AnimPropertiesParam.GetIsBackGroundTransp()) { // force a refresh (regrab) of all frames as // the palette has changed etc.. PORTNOTETRACE("OpGrabAllFrames","Spread::SetAnimationColours - Not setting OpGrabAllFrames force refresh flag"); #ifndef EXCLUDE_FROM_XARALX OpGrabAllFrames::ms_ForceRefreshOfAllFrames = TRUE; #endif } m_AnimPropertiesParam.SetDither(Dither); m_AnimPropertiesParam.SetPalette(WebPalette); m_AnimPropertiesParam.SetPaletteCols(ColoursPalette); m_AnimPropertiesParam.SetNumColsInPalette(NumColsInPalette); m_AnimPropertiesParam.SetIsBackGroundTransp(IsBackgroundTransparent); }

void Spread::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. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 8/5/97 Input: Global Delay :- Global Delay value. Parameters: -  [OUTPUTS] Returns: - Definition at line 3879 of file spread.cpp. { m_AnimPropertiesParam.SetGlobalanimDelay(GlobalDelay); }

void Spread::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. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 8/5/97 Input: Loop :- Global loop value. Parameters: -  [OUTPUTS] Returns: - Definition at line 3860 of file spread.cpp. { m_AnimPropertiesParam.SetAnimLoop(Loop); }

void Spread::SetAnimationQuality (  const Quality &  NewQuality  )

Sets the new stored quality that the animation for this spread was captured at. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/97 Parameters: NewQuality  - the new capture quality for this spread. [INPUTS] Definition at line 4257 of file spread.cpp. { m_AnimPropertiesParam.SetAnimationQuality(NewQuality); }

BOOL Spread::SetBleedOffset (  MILLIPOINT  Bleed  )

For setting a new value for the Spread's bleed area size. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The current size in millipoints of this spreads bleed are. Errors: - See also: GetBleedOffset(); Definition at line 1630 of file spread.cpp. { BleedOffset = Bleed; // set up new bleed value return TRUE; }

void Spread::SetInitialPasteboardRect (  const DocRect &  PasteRect  )  [protected, virtual]

To set the initial pasteboard rectangle of this node, and then change the pasteboard rectangles of all its parents. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 12/3/96 Parameters: PasteRect,:  Rectangle representing the outer limits of the pasteboard [INPUTS] The method also changes the document extents in the NodeDocument node at the root of the tree. Notes: Spread overrides this base class method in order to set its Spread Coordinate Origin suitably. It then calls the base class to do the normal things. See also: NodeRenderablePaper::SetInitialPasteboardRect Reimplemented from NodeRenderablePaper. Definition at line 3544 of file spread.cpp. { // Call the base class to do its stuff NodeRenderablePaper::SetInitialPasteboardRect(PasteRect); // Set the spread coordinate origin to be at the bottom left of the pasteboard by default SpreadOrigin = PasteboardRect.lo; }

BOOL Spread::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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: Width  New width of the page in millipoints [INPUTS] Height New height of the page in millipoints Margin New size of the margin area in millipoints (0 = none) Bleed New size of the bleed area in millipoints (0 = none) Dps Whether another page is required or not. ShowDropShadow New drop shadow display state. -  [OUTPUTS] Returns: Whether we completed the operation ok or not as True or False. Errors: - See also: - Definition at line 2196 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::SetPageSize called on NULL pointer"); // Resize all the pages in the spread to be of the new size specified. // To set page size for all pages in this spread we will... // Find the layout of the pages in the spread (could be X or T shaped!) and calculate // the overall bounds plus the bounds of the objects on the page. // Expand pasteboard rect to give same offsets around new pages // (We won't allow pasteboard to shrink smaller than outermost objects) // Translate any spread after this one so there's no gap or overlap with this one // Set each page to the new page size // Translate pages so they butt up exactly to each other // (in their original layout of course) // (We won't try to translate any objects on this spread.) BOOL ok = TRUE; // Note the present pages rect DocRect OldPagesRect; GetPagesRect(&OldPagesRect); // find the position of the grid relative to the pages so this can be maintained NodeGrid* pGrid=FindFirstDefaultGridInSpread(); ERROR2IF(pGrid==NULL,FALSE,"Spread::SetPageSize() no current default grid"); DocCoord GridOrigin; pGrid->GetOrigin(&GridOrigin.x,&GridOrigin.y); DocCoord PageRelGridOrigin; SpreadCoordToPagesCoord(&PageRelGridOrigin,GridOrigin); // Check if Margin < Bleed, if so then add the margin to the bleed MILLIPOINT PageMargin = 0; if (Margin < Bleed) PageMargin = Margin + Bleed; else PageMargin = Margin; // Set up a new pasteboard rectangle to be of the correct size according to the new spec // for the page or pages for this spread. // First set up the width of the pages according to whether we require one or two pages. MILLIPOINT WidthOfPages = 0; if (Dps) WidthOfPages = PageMargin + 2 * Width; else WidthOfPages = Width; // Set up the class variables for page height/width to echo the new values so any // pasteboard calculations use them. // REMOVED - No other code actually references these variables, so I've removed 'em! // PageWidth = Width; // PageHeight = Height; // Get current pasteboard rectangle //DocRect OldPasteRect = GetPasteboardRect(FALSE); // Resize this by the required amount i.e. difference between old and new DocRect PasteRect(MinDocCoord + 0x10000, (MaxDocCoord - 0x10000) - (PageMargin + Height + PageMargin), (MinDocCoord + 0x10000) + (PageMargin + WidthOfPages + PageMargin), MaxDocCoord - 0x10000); // Align all the pasteboards for all spreads in this chapter ok = AlignPasteboards(PasteRect, PageMargin); if (!ok) return FALSE; // Find the chapter which we belong to Chapter* pChapter = FindParentChapter(); ERROR3IF(pChapter == NULL,"Spread::SetPageSize: Could not find parent chapter"); if (pChapter != NULL) { // Set the main fold line x coordinate. Initialise to non-showing value MILLIPOINT FoldLineX = -1000; // Check if there is another spread present or not // If not and only a single page then do not show the fold line Spread* pNextSpread = FindNextSpread(); if (pNextSpread != NULL || Dps == TRUE) { // We have more than one spread and/or a double page spread so // set the fold line to the join between the two pages or the right hand // side of the left page FoldLineX = PageMargin + Width; } pChapter->SetFoldLineXCoord(FoldLineX); pChapter->InvalidateBoundingRect(); } // Now change the position of all pages in the spread. // Calling routine has checked if the page size has changed or not and not called us // if nothing has changed. // Should have checked everything including going from dps to sps or sps to dps and // deleting/adding pages accordingly and setting the new bleed and shadow state. ok = SetSizeOfAllPages(Width, Height, PageMargin, Dps); if (!ok) return FALSE; // Now set the current bleed size for this spread ok = ok && SetBleedOffset(Bleed); if (!ok) return FALSE; SetShowDropShadow(ShowDropShadow); // Adjust the default grid size to fit the new page layout DocRect Rect = GetPasteboardRect(FALSE); Rect.Translate(-Rect.lo.x, -Rect.lo.y); pGrid->SetBoundingRect(Rect); pGrid->InvalidateBoundingRect(); PagesCoordToSpreadCoord(&GridOrigin,PageRelGridOrigin); pGrid->SetOrigin(GridOrigin.x,GridOrigin.y); // Now, we must ensure that the special page background layer, if present // gets resized to fit around the new page structure Layer * pLayer = FindFirstPageBackgroundLayer(); if (pLayer) { // Call the static function in the background op to go and fix up // the covering rectangle // First, get that size of the rectangle required to fill the present // pages. DocRect NewPagesRect; GetPagesRect(&NewPagesRect); // Translate the old pages from the old origin to the new OldPagesRect.Translate(-OldPagesRect.lo.x, -OldPagesRect.lo.y); OldPagesRect.Translate(NewPagesRect.lo.x, NewPagesRect.lo.y); PORTNOTE("other","Removed OpBackground usage") #ifndef EXCLUDE_FROM_XARALX OpBackground::FixBackgroundLayer(pLayer, NewPagesRect, OldPagesRect); #endif } return TRUE; }

BOOL Spread::SetShowDropShadow (  BOOL  NewState  )

Allows the setting of a new drop shadow display state. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/94 Parameters: New  drop shadow display state. [INPUTS] -  [OUTPUTS] Returns: The old drop shadow display state as either True or False. Errors: - See also: GetShowDropShadow(); Definition at line 1676 of file spread.cpp. { // WEBSTER-ranbirr-13/11/96 #ifndef WEBSTER BOOL OldState = ShowDropShadow; // note current old state ShowDropShadow = NewState; // Set up the required new state return OldState; // return old state to the caller #else //webster BOOL OldState = FALSE; ShowDropShadow = FALSE ; return OldState; // return old state to the caller #endif //Webster }

BOOL Spread::SetSizeOfAllPages (  const MILLIPOINT  Width, const MILLIPOINT  Height, const MILLIPOINT  Margin, const BOOL  Dps )  [protected]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: Width  New width of the page in millipoints [INPUTS] Height New height of the page in millipoints Margin New size of the margin area in millipoints (0 = none) Dps Whether another page is required or not. -  [OUTPUTS] Returns: Whether we completed the operation ok or not as True or False. Errors: - See also: - Definition at line 2506 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::SetSizeOfAllPages called on NULL pointer"); BOOL ok = TRUE; // Find the first page in the spread Page *pPage = FindFirstPageInSpread(); ERROR2IF(pPage == NULL,FALSE,"Spread::SetSizeOfAllPages(): Could not find first Page"); // Take note of where this first page is // Page* pFirstPage = pPage; // Get the size and position of the first page DocRect OldPageRect = pPage->GetPageRect(); // Get present low corner position, we will use this to calculate the gap around the pages DocCoord Low = OldPageRect.LowCorner(); // Set up the new starting position of the page Low.x = Margin; Low.y = Margin; // Construct a new position and size with the required params DocRect PageRect(Low, Width, Height); ok = pPage->SetPageRect(PageRect); if (!ok) return FALSE; // Find out if there is a next page in the spread. If there is, then we need to // change that as well, if we are in dps mode, or delete it if dps is off Page* pCurrentPage = pPage; pPage = pPage->FindNextPage(); if (pPage != NULL) { if (Dps) { // Move the current page across by one page worths and set this as the new // size/position for the next page PageRect.Translate(Width, 0); ok = pPage->SetPageRect(PageRect); if (!ok) return FALSE; // Now check to see if any more pages exist. If so then delete them. pPage = pPage->FindNextPage(); while (pPage != NULL) { ERROR3("Spread::SetSizeOfAllPages extra page found in double page spread"); } } else { // Delete any pages over the initial one. do { pPage->CascadeDelete(); // Of course, Cascade delete does not actually delete the page, so now do that delete pPage; // Check to see if any pages remain after the first required one pPage = pCurrentPage; pPage = pPage->FindNextPage(); } while (pPage != NULL); } } else { // If not double page spread then everything is correct // otherwise we will need to create a page of the correct size and position if (Dps) { // move first page across by one page worths PageRect.Translate(Width, 0); // Create a new last page based on this size/position Page* Page2 = new Page(this, LASTCHILD, PageRect); if (Page2 == NULL) { // We ran out of memory or something InformError(_R(IDE_NOMORE_MEMORY)); return FALSE; } } } return TRUE; }

void Spread::SetSpreadAnimPropertiesParam (  const AnimPropertiesParam &  Param  )

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 07/05/97 Parameters: pParam  - Sets the Animation Properties details for this spread. [INPUTS] Returns: TRUE if ok, FALSE otherwise. Definition at line 4131 of file spread.cpp. { m_AnimPropertiesParam = Param; }

BOOL Spread::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 )

Definition at line 4162 of file spread.cpp. { ERROR2IF(this==NULL,FALSE,"Spread::SetSpreadAnimProperties cslled on NULL pointer"); m_AnimPropertiesParam.SetAnimLoop(Loop); m_AnimPropertiesParam.SetGlobalanimDelay(GlobalDelay); m_AnimPropertiesParam.SetDither(Dither); m_AnimPropertiesParam.SetPalette(WebPalette); m_AnimPropertiesParam.SetPaletteCols(ColoursPalette); m_AnimPropertiesParam.SetNumColsInPalette(NumColsInPalette); m_AnimPropertiesParam.SetUseSystemCols(UseSystemColours); m_AnimPropertiesParam.SetIsBackGroundTransp(IsBackgroundTransparent); return TRUE; }

void Spread::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. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/96 Parameters: NewOrigin  - the new origin point for the spread coordinates within [INPUTS] this spread Notes: Moving the spread coord origin effectively moves all nodes on the spread (pages, layers, objects, etc) in the opposite direction. It may therefore result in objects and even pages moving off the pasteboard. Note also that you'll probably have to redraw some stuff! Use carefully - Talk to Jason about it first! See also: Spread::GetSpreadCoordOrigin Definition at line 3066 of file spread.cpp. { #if !NEW_PASTEBOARD ERROR3("You can't set the spread coord origin (unimplemented) - Talk to Jason/Phil"); #endif SpreadOrigin = NewOrigin; }

void Spread::SetUserOrigin (  DocCoord  origin  )  [inline]

Definition at line 219 of file spread.h. { UserOrigin=origin; }

Node * Spread::SimpleCopy (  void   )  [protected, virtual]

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. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 28/4/93 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A copy of the node, or NULL if memory runs out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected Reimplemented from NodeRenderablePaper. Definition at line 923 of file spread.cpp. { Spread* NodeCopy; NodeCopy = new Spread(); ERRORIF(NodeCopy == NULL, _R(IDE_NOMORE_MEMORY), NULL); CopyNodeContents(NodeCopy); return (NodeCopy); }

void Spread::SpreadCoordToDocCoord (  DocRect *  pSpreadCoord  )  const

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

void Spread::SpreadCoordToDocCoord (  DocCoord *  pSpreadCoord  )  const

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

BOOL Spread::SpreadCoordToPagesCoord (  DocCoord *  pPagesCoord, DocCoord  SpreadCoord )

Convert SpreadCoord to PagesCoord (relative to union of pages in spread). Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: SpreadCoord  [INPUTS] pPagesCoord  [OUTPUTS] Returns: FALSE if fails (PagesCoord unchanged) Definition at line 2802 of file spread.cpp. { ERROR2IF(pPagesCoord==NULL,FALSE,"Spread::SpreadCoordToPagesCoord() - pPagesCoord==NULL"); DocRect PagesRect; if (GetPagesRect(&PagesRect)==FALSE) return FALSE; *pPagesCoord=SpreadCoord-PagesRect.lo; return TRUE; }

BOOL Spread::SpreadCoordToText (  String_256 *  pxText, String_256 *  pyText, DocCoord  SpreadCoord, 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. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: SpreadCoord  [INPUTS] xUnitSpecifier (default TRUE) - append unit specifier to x text yUnitSpecifier (default TRUE) - append unit specifier to y text dp (default 2) - decimal places (-1 = use system default) pxText  - x UserCoord in text form [OUTPUTS] pyText - y UserCoord in text form Returns: FALSE if fails (xText,yText unchanged) Definition at line 2889 of file spread.cpp. { ERROR2IF(pxText==NULL,FALSE,"Spread::SpreadCoordToText() - pxText==NULL"); ERROR2IF(pyText==NULL,FALSE,"Spread::SpreadCoordToText() - pyText==NULL"); ERROR2IF( dp<-1 ,FALSE,"Spread::SpreadCoordToText() - dp<-1"); DimScale* pDimScale=DimScale::GetPtrDimScale(this); ERROR2IF(pDimScale==NULL,FALSE,"Spread::SpreadCoordToText() - pDimScale==NULL"); // if only Y unit specified, and units are prefix, force X unit specifier only if (xUnitSpecifier==FALSE && yUnitSpecifier==TRUE) { // Get the current unit list from the document and the the current scale units DocUnitList* pDocUnitList=DocUnitList::GetCurrentDocUnitList(); ERROR2IF(pDocUnitList==NULL,FALSE,"Spread::SpreadCoordToText() - DocUnitList::GetCurrentDocUnitList() returned NULL"); Unit* pUnit=pDocUnitList->FindUnit(pDimScale->GetUnits()); ERROR2IF(pUnit==NULL,FALSE,"Spread::SpreadCoordToText() - pDocUnitList->FindUnit() returned NULL"); if (pUnit->IsPrefix()) { xUnitSpecifier=TRUE; yUnitSpecifier=FALSE; } } UserCoord UserPos=SpreadCoord.ToUser(this); pDimScale->ConvertToUnits(UserPos.x, pxText, xUnitSpecifier, dp); pDimScale->ConvertToUnits(UserPos.y, pyText, yUnitSpecifier, dp); return TRUE; }

BOOL Spread::TextToSpreadCoord (  DocCoord *  pSpreadCoord, StringBase *  pxText, StringBase *  pyText )

Convert Coord in text form (relative to union of pages in spread) into SpreadCoord. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/1/95 Parameters: pxText  - x UserCoord in text form [INPUTS] pyText - y UserCoord in text form pSpreadCoord  [OUTPUTS] Returns: FALSE if fails (SpreadCoord unchanged) Definition at line 2851 of file spread.cpp. { ERROR2IF(pSpreadCoord==NULL,FALSE,"Spread::TextToSpreadCoord() - pSpreadCoord==NULL"); ERROR2IF( pxText==NULL,FALSE,"Spread::TextToSpreadCoord() - pxText==NULL"); ERROR2IF( pyText==NULL,FALSE,"Spread::TextToSpreadCoord() - pyText==NULL"); DimScale* pDimScale=DimScale::GetPtrDimScale(this); ERROR2IF(pDimScale==NULL,FALSE,"Spread::TextToSpreadCoord() - pDimScale==NULL"); UserCoord UserPos(0,0); if (pDimScale->ConvertToMillipoints(*pxText, &(UserPos.x))==FALSE) return FALSE; if (pDimScale->ConvertToMillipoints(*pyText, &(UserPos.y))==FALSE) return FALSE; *pSpreadCoord = UserPos.ToSpread(this); return TRUE; }

BOOL Spread::WriteBeginChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Begins the child record sequence for spread in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise The native format writes out all spreads and includes the spread details record as the spread's first child record See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 3676 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL RecordWritten = FALSE; // First thing to do is write out the Down record RecordWritten = (pFilter->WriteZeroSizedRecord(TAG_DOWN)); // Write out the page sizes etc for this spread if (RecordWritten) RecordWritten = WriteSpreadInformation(pFilter); if (RecordWritten) RecordWritten = WriteSpreadScaling(pFilter); // write out the Animtion Record. if (RecordWritten) RecordWritten = WriteSpreadAnimProperties(pFilter); return RecordWritten; #else return TRUE; #endif //DO_EXPORT }

BOOL Spread::WriteBeginChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Begins the child record sequence for spread in the web format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise Web export doesn't write out spread records, so this overrides the default behaviour in Node by ensuring the Down record does not get written See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 3744 of file spread.cpp. { return TRUE; }

BOOL Spread::WriteEndChildRecordsNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Ends the child record sequence for spreads in the native format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise The native format writes out all spreads. This func just writes out the Up record See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 3716 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); return pFilter->WriteZeroSizedRecord(TAG_UP); #else return FALSE; #endif }

BOOL Spread::WriteEndChildRecordsWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Ends the child record sequence for spread in the web format. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/8/96 Parameters: pFilter  = ptr to the filter to write to [INPUTS] -  [OUTPUTS] Returns: TRUE ok, FALSE otherwise Web export doesn't write out spread records, so this overrides the default behaviour in Node by ensuring the Up record does not get written See also: WritePreChildrenNative() Reimplemented from Node. Definition at line 3767 of file spread.cpp. { return TRUE; }

BOOL Spread::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes the spread record to the filter. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/6/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not Native files write out all spreads. See also: Node::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Reimplemented from Node. Definition at line 3638 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL RecordWritten = FALSE; // Always write out the spread record in native files CXaraFileRecord Rec(TAG_SPREAD,TAG_SPREAD_SIZE); if (pFilter->Write(&Rec) != 0) RecordWritten = TRUE; else pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); return RecordWritten; #else return FALSE; #endif }

BOOL Spread::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Web files do not write out spreads. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/6/96 Parameters: pFilter  = ptr to the filter [INPUTS] Returns: TRUE if record is written, FALSE if not This code assumes that the document only has one spread See also: Node::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Reimplemented from Node. Definition at line 3617 of file spread.cpp. { return FALSE; }

BOOL Spread::WriteSpreadAnimProperties (  BaseCamelotFilter *  pFilter  )  [virtual]

Definition at line 3785 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL RecordWritten = FALSE; BOOL ok = TRUE; // Add a description of the TAG_SPREAD_ANIMPROPS record, for older importers that don't understand this record pFilter->AddTagDescription(TAG_SPREAD_ANIMPROPS, _R(IDS_TAG_SPREAD_ANIMPROPS)); // Start a record to save our data in CXaraFileRecord Rec(TAG_SPREAD_ANIMPROPS, TAG_SPREAD_ANIMPROPS_SIZE); // Get our information... DWORD Loop = m_AnimPropertiesParam.GetAnimLoop(); DWORD GlobalDelay = m_AnimPropertiesParam.GetGlobalAnimDelay(); DWORD Dither = m_AnimPropertiesParam.GetDither(); DWORD WebPalette = m_AnimPropertiesParam.GetPalette(); DWORD ColoursPalette = m_AnimPropertiesParam.GetPaletteCols(); DWORD NumColsInPalette = m_AnimPropertiesParam.GetNumColsInPalette(); // We have a flags word so get the bits that affect it BOOL SystemCols = m_AnimPropertiesParam.GetUseSystemCols(); BOOL BgTransparent = m_AnimPropertiesParam.GetIsBackGroundTransp(); // And now fill in the bits in the flags word. // To be compatible with CX2, we set the flag if BgTransparent is FALSE, // as CX2 automatically did bg transparent GIFs all the time. BYTE FlagsWord = (SystemCols ? 1 : 0); FlagsWord |= (BgTransparent ? 0 : 2); ok = Rec.Init(); if (ok) ok = Rec.WriteUINT32(Loop); if (ok) ok = Rec.WriteUINT32(GlobalDelay); if (ok) ok = Rec.WriteUINT32(Dither); if (ok) ok = Rec.WriteUINT32(WebPalette); if (ok) ok = Rec.WriteUINT32(ColoursPalette); if (ok) ok = Rec.WriteUINT32(NumColsInPalette); if (ok) ok = Rec.WriteUINT32(FlagsWord); // Write out the record. if (pFilter->Write(&Rec) != 0) RecordWritten = TRUE; else pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); return RecordWritten; #else return FALSE; #endif }

BOOL Spread::WriteSpreadInformation (  BaseCamelotFilter *  pFilter  )  [protected, virtual]

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. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 6/8/96 Input: pFilter = ptr to the filter to export to Parameters: -  [OUTPUTS] Returns: TRUE if ok, FALSE otherwise See also: Spread::WritePreChildrenNative; Spread::WritePreChildrenWeb; Definition at line 3977 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); // BOOL RecordWritten = FALSE; // Now save out the information record MILLIPOINT Width = 0; MILLIPOINT Height = 0; MILLIPOINT Margin = 0; MILLIPOINT Bleed = 0; BOOL Dps = TRUE; BOOL ShowDropShadow = TRUE; BOOL ok = TRUE; // and go and get all the page info if (ok) ok = GetPageSize(&Width, &Height, &Margin, &Bleed, &Dps, &ShowDropShadow); // If it worked, we had better try and output some info if (ok) { CXaraFileRecord Rec(TAG_SPREADINFORMATION, TAG_SPREADINFORMATION_SIZE); ok = Rec.Init(); // Width, Height of page if (ok) ok = Rec.WriteINT32(Width); if (ok) ok = Rec.WriteINT32(Height); // <Margin : MILLIPOINT> The margin to add around all four sides of the pages in the spread to make up the pasteboard. if (ok) ok = Rec.WriteINT32(Margin); // <Bleed : MILLIPOINT> Bleed margin to add around all pages in this spread. (0 means none) if (ok) ok = Rec.WriteINT32(Bleed); // <SpreadFlags : BYTE> Flags for the current spread. // SpreadFlags ::= DoublePageSpread | ShowDropShadow // ShowDropShadow flag to say whether we apply a page shadow behind the page // DoublePageSpread flag to say whether one or two pages are present BYTE FlagsWord = (ShowDropShadow ? 2 : 0) | (Dps ? 1 : 0); if (ok) ok = Rec.WriteBYTE(FlagsWord); // Finally, write the record out to file if (ok) ok = (pFilter->Write(&Rec) != 0); } return ok; #else return FALSE; #endif }

BOOL Spread::WriteSpreadScaling (  BaseCamelotFilter *  pFilter  )  [protected, virtual]

Exports the scaling information for this spread to the filter. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 6/8/96 Input: pFilter = ptr to the filter to export to Parameters: -  [OUTPUTS] Returns: TRUE if ok, FALSE otherwise See also: Spread::WritePreChildrenNative; Spread::WritePreChildrenWeb; Definition at line 4043 of file spread.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); BOOL ok = FALSE; DimScale* pDimScale = GetPtrDimScale(); if (pDimScale != NULL) { // Find out if it is active BOOL Active = pDimScale->IsActive(); // Find out about the scale factor strings String_32 DrawingScale = pDimScale->GetDrawingScaleStr(); String_32 RealScale = pDimScale->GetRealScaleStr(); // If we just save the strings directly, we will named references to the units being used. // This is bad as if somebody saves out '10cm' and then loads this onto a Japanese version, // they will not get what they expected. If we strip the scaling factor and units from the strings // and save this instead, the units as a units reference, then everything will be happy. The units // will get loaded in and converted into the correct locale format. (Apart from user units of course). UnitType Default = pDimScale->GetUnits(); double DrawingScaleValue = 1.0; UnitType DrawingUnits = NOTYPE; ok = Convert::StringToComponents(DrawingScale, &DrawingScaleValue, &DrawingUnits); if (DrawingUnits == NOTYPE) DrawingUnits = Default; double RealScaleValue = 1.0; UnitType RealUnits = NOTYPE; ok = Convert::StringToComponents(RealScale, &RealScaleValue, &RealUnits); if (RealUnits == NOTYPE) RealUnits = Default; // Convert the unittype into a reference UnitListComponent * pUnitsComponent = pFilter->GetUnitDocComponent(); ERROR2IF(pUnitsComponent == NULL,FALSE,"WriteGridAndRulerSettings No units doc component present"); INT32 DrawingUnitsRef = pUnitsComponent->GetWriteUnitReference(DrawingUnits, pFilter); INT32 RealUnitsRef = pUnitsComponent->GetWriteUnitReference(RealUnits, pFilter); INT32 Tag = TAG_SPREADSCALING_INACTIVE; INT32 Size = TAG_SPREADSCALING_INACTIVE_SIZE; if (Active) { Tag = TAG_SPREADSCALING_ACTIVE; Size = TAG_SPREADSCALING_ACTIVE_SIZE; } CXaraFileRecord Rec(Tag, Size); ok = Rec.Init(); if (ok) ok = Rec.WriteDOUBLE(DrawingScaleValue); if (ok) ok = Rec.WriteINT32(DrawingUnitsRef); if (ok) ok = Rec.WriteDOUBLE(RealScaleValue); if (ok) ok = Rec.WriteINT32(RealUnitsRef); // Finally, write the record out to file // In the process get the record number that this was written out as INT32 RecordNumber = 0L; if (ok) RecordNumber = pFilter->Write(&Rec); // If we have had a problem at any of the stages then return that to the caller if (!ok || RecordNumber <= 0) ok = FALSE; } return ok; #else return TRUE; #endif //DO_EXPORT }

---

Member Data Documentation

MILLIPOINT Spread::BleedOffset [protected]

Definition at line 329 of file spread.h.

AnimPropertiesParam Spread::m_AnimPropertiesParam [protected]

Definition at line 334 of file spread.h.

BOOL Spread::RalphDontShowPaper [protected]

Definition at line 331 of file spread.h.

BOOL Spread::ShowDropShadow [protected]

Definition at line 330 of file spread.h.

DimScale Spread::SpreadDimScale [private]

Definition at line 383 of file spread.h.

DocCoord Spread::SpreadOrigin [protected]

Definition at line 332 of file spread.h.

DocCoord Spread::UserOrigin [protected]

Definition at line 333 of file spread.h.

---

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

• Kernel/spread.h (r1785/r1273)
• Kernel/spread.cpp (r1785/r1737)

---