OpBackground Class Reference

Allows the background layer to be set up and changed. More...

#include <backgrnd.h>

Inheritance diagram for OpBackground:

List of all members.

Public Member Functions
	OpBackground ()
	Default constructor.
	~OpBackground ()
	Default destructor.
virtual void	DoWithParam (OpDescriptor *pOpDesc, OpParam *pParam)
	This function is used to create a guideline in the selected spread. It calls DoAddNewGuideline() with pParam->Param1 specifying the guideline type.
void	GetOpName (String_256 *OpName)
	Returns a desc of the op. Mainly used to fill in the menu item for the undo/redo ops.
Static Public Member Functions
static BOOL	Init ()
	Called when the op is undone. This broadcasts a 'Guidelines changed' layer message Called when the op is redone. This broadcasts a 'Guidelines changed' layer message Registers an op desc for this op.
static OpState	GetState (String_256 *Description, OpDescriptor *)
	Func for determining the usability of this op.
static BOOL	FixBackgroundLayer (Layer *pLayer, const DocRect &NewPagesRect, const DocRect &OldPagesRect)
	This tries to fix up the special page background layer so that the rectangle on it is resized to the cover the newly resized pages on the spread.
static BOOL	MakePageBackground (UndoableOperation *pOp, Spread *pSpread, DocColour *pDocColour)
	Tries to apply the DocColour or bitmap as a new page background.
static BOOL	MakePageBackground (UndoableOperation *pOp, Spread *pSpread, KernelBitmap *pBitmap)
	Tries to apply the DocColour or bitmap as a new page background.
static BOOL	GetPageColour (Spread *pSpread, KernelBitmap **pOutBitmap, DocColour **pOutColour)
	Gets the page's fill attribute, which could only be either a colour, or a bitmap.
Static Protected Member Functions
static BOOL	DoMakePageBackground (UndoableOperation *pOp, Spread *pSpread, KernelBitmap *pBitmap, DocColour *pDocColour=NULL)
	Tries to apply the DocColour or bitmap as a new page background.
static Layer *	CreateBackgroundLayer ()
	This does everything required in creating a layer fit to be called the background layer.
static Layer *	DoCreateBackgroundLayer (UndoableOperation *pOp, Spread *pSpread)
	This returns a ptr to the background layer.
static NodeRegularShape *	DoFindPageRectangle (Spread *pSpread, Layer *pBackgroundLayer)
	Tries to find the page filling rectangle on the specified layer.
static NodeRegularShape *	DoCreateRectangle (Spread *pSpread)
	Returns a new rectangle the size of the current spread.
static NodeRegularShape *	FindPageRectangle (Layer *pBackgroundLayer, const DocRect &PagesRect)
	Tries to find the page filling rectangle on the specified layer.
static BOOL	ApplyDocColour (DocColour *pColourToApply, NodeRegularShape *pShape)
	Applies the specified colour to the specified NodeRegularShape.
static BOOL	ApplyBitmap (KernelBitmap *pBitmapToApply, NodeRegularShape *pShape)
	Applies the specified bitmap to the specified NodeRegularShape.
static BOOL	ApplyDefaultAttributes (NodeRegularShape *pShape)
	Applies some useful default attributes to the specified NodeRegularShape.
Private Member Functions
	CC_DECLARE_DYNCREATE (OpBackground)

---

Detailed Description

Allows the background layer to be set up and changed.

Author:

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

Date:

26/3/97

Definition at line 150 of file backgrnd.h.

---

Constructor & Destructor Documentation

OpBackground::OpBackground (   )

Default constructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 144 of file backgrnd.cpp. { // m_pDoc = NULL; // m_pSpread = NULL; // m_pDocColour = NULL; // m_pBitmap = NULL; // Versions of the parameters used in the drag and drop process // m_pDroppedBitmap = NULL; // m_pDroppedDocColour = NULL; }

OpBackground::~OpBackground (   )

Default destructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 171 of file backgrnd.cpp. { }

---

Member Function Documentation

BOOL OpBackground::ApplyBitmap (  KernelBitmap *  pBitmapToApply, NodeRegularShape *  pShape )  [static, protected]

Applies the specified bitmap to the specified NodeRegularShape. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/3/97 Parameters: The  bitmap to apply [INPUTS] The regular shape to apply the bitmap to -  [OUTPUTS] Returns: See also: - Definition at line 628 of file backgrnd.cpp. { ERROR2IF(pBitmapToApply == NULL || pShape == NULL,FALSE,"OpBackground::ApplyBitmap Bar params!"); // Set up a fill colour attribute AttrBitmapColourFill *pBitmapFillAttr = new AttrBitmapColourFill(); if (pBitmapFillAttr == NULL) { InformError(); return(FALSE); } // Set the coordinates of the fill end points // We want to start the fill at the top left of the regular shape // The bounding rect should be roughly what we want DocRect Rect = pShape->GetBoundingRect(TRUE, FALSE); // Get the size of the bitmap taking into account its DPI INT32 Width = pBitmapToApply->GetRecommendedWidth(); INT32 Height = pBitmapToApply->GetRecommendedHeight(); // You would think that the handles on the fill correspond to where you place them // but oh now the displayed handles are shown at different points. So instead of // positioning the start in the centre of the bitmap, you need to position it bottom left // The End should be centre and right but needs to be bottom right. // The End2 should be centre and top but needs to be top left. // We want the start point to be half the height of the bitmap below this //DocCoord Start(Rect.lo.x + Width/2, Rect.hi.y - Height/2); DocCoord Start(Rect.lo.x, Rect.hi.y - Height); // We want the other end point to be same height as the centre point // but on the far right of the rectangle i.e the full width across //DocCoord End(Rect.lo.x + Width, Rect.hi.y - Height/2); DocCoord End(Rect.lo.x + Width, Rect.hi.y - Height); // We want the end point to be middle and top of the rectangle //DocCoord End2(Rect.lo.x + Width/2, Rect.hi.y); DocCoord End2(Rect.lo.x, Rect.hi.y); ((AttrFillGeometry*)pBitmapFillAttr)->SetStartPoint(&Start); ((AttrFillGeometry*)pBitmapFillAttr)->SetEndPoint(&End); ((AttrFillGeometry*)pBitmapFillAttr)->SetEndPoint2(&End2); // Now attach the correct bitmap to the fill ((AttrFillGeometry*)pBitmapFillAttr)->AttachBitmap(pBitmapToApply); // And now insert it as a child of the regular shape // Factoring should be ok as the Regular Shape is assumed to be the child of // layer pBitmapFillAttr->AttachNode(pShape, FIRSTCHILD); return TRUE; }

BOOL OpBackground::ApplyDefaultAttributes (  NodeRegularShape *  pShape  )  [static, protected]

Applies some useful default attributes to the specified NodeRegularShape. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/4/97 Parameters: The  regular shape to apply the attributes to [INPUTS] -  [OUTPUTS] Returns: See also: - Definition at line 694 of file backgrnd.cpp. { ERROR2IF(pShape == NULL,FALSE,"OpBackground::ApplyDefaultAttributes Bar params!"); // ***** // Set up a no colour line colour AttrStrokeColour * pLineColAttr = new AttrStrokeColour(); if (pLineColAttr == NULL) { InformError(); return(FALSE); } DocColour ColNone(COLOUR_NONE); ((AttrFillGeometry*)pLineColAttr)->SetStartColour(&ColNone); // And now insert it as a child of the regular shape // Factoring should be ok as the Regular Shape is assumed to be the child of // layer pLineColAttr->AttachNode(pShape, LASTCHILD); // ***** // Set up a line width attribute AttrLineWidth *pLineWidthAttr = new AttrLineWidth(); if (pLineWidthAttr == NULL) { InformError(); return(FALSE); } ((AttrLineWidth*)pLineWidthAttr)->Value.LineWidth = 0; // And now insert it as a child of the regular shape // Factoring should be ok as the Regular Shape is assumed to be the child of // layer pLineWidthAttr->AttachNode(pShape, LASTCHILD); // ***** // Set up a join type attribute AttrJoinType * pJoinTypeAttr = new AttrJoinType(); if (pLineWidthAttr == NULL) { InformError(); return(FALSE); } // We will use a default constructed one as this should be vaguely correct // ((AttrLineWidth*)pJoinTypeAttr)->Value.LineWidth = 0; // And now insert it as a child of the regular shape // Factoring should be ok as the Regular Shape is assumed to be the child of // layer pJoinTypeAttr->AttachNode(pShape, LASTCHILD); return TRUE; }

BOOL OpBackground::ApplyDocColour (  DocColour *  pColourToApply, NodeRegularShape *  pShape )  [static, protected]

Applies the specified colour to the specified NodeRegularShape. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/3/97 Parameters: The  colour to apply [INPUTS] The regular shape to apply the colour to -  [OUTPUTS] Returns: See also: - Definition at line 591 of file backgrnd.cpp. { ERROR2IF(pColourToApply == NULL || pShape == NULL,FALSE,"OpBackground::ApplyDocColour Bar params!"); // Set up a fill colour attribute AttrFlatColourFill *pFillColAttr = new AttrFlatColourFill(); if (pFillColAttr == NULL) { InformError(); return(FALSE); } ((AttrFillGeometry*)pFillColAttr)->SetStartColour(pColourToApply); // And now insert it as a child of the regular shape // Factoring should be ok as the Regular Shape is assumed to be the child of // layer pFillColAttr->AttachNode(pShape, FIRSTCHILD); return TRUE; }

OpBackground::CC_DECLARE_DYNCREATE (  OpBackground   )  [private]

Layer * OpBackground::CreateBackgroundLayer (   )  [static, protected]

This does everything required in creating a layer fit to be called the background layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Ptr to a background layer that's ready to be inserted into the tree See also: - Definition at line 827 of file backgrnd.cpp. { Layer* pNewLayer = new Layer; if (pNewLayer != NULL) { String_256 LayerName(_R(IDS_BACKGROUNDLAYERNAME)); pNewLayer->SetVisible(TRUE); pNewLayer->SetLocked(TRUE); pNewLayer->SetPrintable(FALSE); pNewLayer->SetBackground(TRUE); pNewLayer->SetOutline(FALSE); pNewLayer->SetGuide(FALSE); pNewLayer->SetPageBackground(TRUE); // This is the special page background layer flag pNewLayer->SetLayerID(LayerName); /* // Ensure we are always rendered at maximum quality so that turning WYSIWYG // down does not remove the page background! Quality Qual; Qual.SetQuality(QUALITY_MAX); QualityAttribute QualAttr(Qual); NodeAttribute* pNodeAttr = QualAttr.MakeNode(); pNodeAttr->AttachNode(pNewLayer, FIRSTCHILD); */ } return pNewLayer; }

Layer * OpBackground::DoCreateBackgroundLayer (  UndoableOperation *  pOp, Spread *  pSpread )  [static, protected]

This returns a ptr to the background layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: pOp  - The operation to use [INPUTS] pSpread - the spread to apply the background to -  [OUTPUTS] Returns: Ptr to the background layer, or NULL one couldn't be created. If the background layer already exists, a ptr to it is returned. If there isn't a background layer, it is created and inserted into the doc tree. If this fails the func returns NULL See also: OpBackground::DoNewGuideline() Definition at line 775 of file backgrnd.cpp. { ERROR2IF(pOp == NULL || pSpread == NULL,FALSE,"OpBackground::DoCreateBackgroundLayer Bad params error!"); // Search for our special page background layer Layer* pFoundLayer = pSpread->FindFirstPageBackgroundLayer(); // If we have found it then return this to the caller as we don't want // more than one present! if (pFoundLayer != NULL) return pFoundLayer; // We didn't find a page background layer so go and create a new one Layer* pNewLayer = CreateBackgroundLayer(); if (pNewLayer != NULL) { // If we insert the new layer as the FIRSTCHILD then this will be like the guidelayer // and behind the page. If we insert as the last child then we will be at the front of // the stacking order. We need to insert ourselves as the node after the last page node Page *pLastPage = pSpread->FindLastPageInSpread(); // Insert the new layer as the next node after the last page. if (pLastPage && pOp->DoInsertNewNode(pNewLayer, pLastPage, NEXT, FALSE,FALSE,FALSE,FALSE)) { pNewLayer->EnsureUniqueLayerID(); BROADCAST_TO_ALL(SpreadMsg(pSpread, SpreadMsg::LAYERCHANGES)); } else { delete pNewLayer; pNewLayer = NULL; } } return pNewLayer; }

NodeRegularShape * OpBackground::DoCreateRectangle (  Spread *  pSpread  )  [static, protected]

Returns a new rectangle the size of the current spread. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/3/97 Parameters: pSpread  - the spread to apply the background to [INPUTS] -  [OUTPUTS] Returns: The regular shape See also: - Definition at line 524 of file backgrnd.cpp. { ERROR2IF(pSpread == NULL,FALSE,"OpBackground::DoCreateRectangle Bad params error!"); if (pSpread == NULL) return NULL; // This assumes that we have already checked to see if there is a page covering rectangle // already present on this layer. // Create a new rectangle node on the layer NodeRegularShape *pShape = new NodeRegularShape; if (pShape != NULL) { BOOL ok = pShape->SetUpShape(); if (!ok) { // Do something sensible in here delete pShape; return NULL; } // We want to make the rectangle the same size as the current union of // all the pages on the current spread DocRect Rect; pSpread->GetPagesRect(&Rect); /* // We must expand the rectangle by a single pixel as the page redraw // draws a single pixel line around the outside. const MILLIPOINT pixel = (MILLIPOINT)(72000.0/96.0); Rect.Inflate(pixel); */ const INT32 CornerRadius = 0; // No curvature if (pShape->MakeRectangle(Rect.Width(), Rect.Height(), CornerRadius)) { // Translate centre from 0,0 to required position relative to page INT32 XTrans = Rect.lo.x + (Rect.Width()/2); INT32 YTrans = Rect.lo.y + (Rect.Height()/2); Trans2DMatrix Trans(XTrans, YTrans); pShape->Transform(Trans); // finish off the shape pShape->InvalidateBoundingRect(); } } return pShape; }

NodeRegularShape * OpBackground::DoFindPageRectangle (  Spread *  pSpread, Layer *  pBackgroundLayer )  [static, protected]

Tries to find the page filling rectangle on the specified layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 27/3/97 Parameters: pSpread  - the spread to apply the background to [INPUTS] pBackgroundLayer - the layer to search for the shape on -  [OUTPUTS] Returns: The regular shape, if found See also: - Definition at line 443 of file backgrnd.cpp. { if (pSpread == NULL || pBackgroundLayer == NULL) return NULL; // We want to find the rectangle which should be the same size as the current union of // all the pages on the current spread DocRect PagesRect; pSpread->GetPagesRect(&PagesRect); return FindPageRectangle(pBackgroundLayer, PagesRect); }

BOOL OpBackground::DoMakePageBackground (  UndoableOperation *  pOp, Spread *  pSpread, KernelBitmap *  pBitmap, DocColour *  pDocColour = NULL )  [static, protected]

Tries to apply the DocColour or bitmap as a new page background. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/4/97 Parameters: pOp  - the operation to use [INPUTS] pSpread - the spread to apply the background to pBitmap - the bitmap to apply pDocColour - the doc colour to apply -  [OUTPUTS] Returns: True if worked ok, False otherwise. It is up to the caller to call End() on the operation. This is so that an outside op should be able to call this and everything should work ok. See also: - Definition at line 303 of file backgrnd.cpp. { TRACEUSER("Gerry", _T("OpBackground::DoMakePageBackground")); // Our inputs are actually set up in the class variables, so check them ERROR2IF(pSpread == NULL || pOp == NULL,FALSE,"DoMakePageBackground Bad params!"); ERROR2IF(pDocColour == NULL && pBitmap == NULL,FALSE,"DoMakePageBackground Bad params!"); BOOL ok = TRUE; Page *pPage = pSpread->FindFirstPageInSpread (); DocRect Bounds = pPage->GetPageRect (); // If there's a transparent background colour, just hide the existing node. if ( pDocColour != NULL && pDocColour->IsTransparent () ) { Layer* pOldLayer = pSpread->FindFirstPageBackgroundLayer (); // Attempt to remove the old background layer. if ( pOldLayer != NULL ) { TRACEUSER("Gerry", _T("Removing old background")); if ( !pOp->DoHideNode(pOldLayer, TRUE ) ) { // Something went wrong, so handle the error. ERROR3( "OpBackground failed to hide the old page background" ); pOp->FailAndExecute (); ok = FALSE; } } } // Otherwise create a new background layer. else { TRACEUSER("Gerry", _T("Creating new background")); Layer* pBackgroundLayer = DoCreateBackgroundLayer(pOp, pSpread); if (pBackgroundLayer == NULL) { ERROR3("Something went wrong with the layer creation"); pOp->FailAndExecute(); ok = FALSE; } else { // Try and find an existing page filling rectangle on this layer NodeRegularShape * pShape = DoFindPageRectangle(pSpread, pBackgroundLayer); // If not found then create a new one if (pShape != NULL) { // Hide the old version of the rectangle if (!pOp->DoHideNode(pShape, TRUE)) { ERROR3("OpBackground failed to hide the old node"); pOp->FailAndExecute(); ok = FALSE; } } if (ok) { // Make a new rectangle of the correct size pShape = DoCreateRectangle(pSpread); // Apply the bitmap or the colour to it before we insert it into the tree. if (pDocColour) { // Set the colour to be the background. ok = ApplyDocColour(pDocColour, pShape); } else if (pBitmap) { ok = ApplyBitmap(pBitmap, pShape); } else { ERROR3("OpBackground Haven't got anything to apply"); pOp->FailAndExecute(); ok = FALSE; } // Apply a useful set of default attibutes on top of the fill colour // or bitmap fill. if ( pShape != NULL ) { ApplyDefaultAttributes(pShape); } } // We must make the layer unlocked so that we don't get the stupid // inserting on locked layer message pBackgroundLayer->SetLocked(FALSE); // And now insert it into the background layer if (ok && !pOp->DoInsertNewNode(pShape, pBackgroundLayer, FIRSTCHILD,FALSE, FALSE,FALSE,FALSE)) { delete pShape; pShape = NULL; pOp->FailAndExecute(); ok = FALSE; } // Set the layer back to locked as we have finished inserting onto the layer pBackgroundLayer->SetLocked(TRUE); // Since we prevented DoInsertnewNode from invalidating, it won't have cleared // the cache appropriately so we will have to do that ourselves... if (ok) pBackgroundLayer->ReleaseCached(); } } // Force a redraw of the new background layer. if ( ok && !pOp->DoInvalidateRegion ( pSpread, Bounds ) ) { pOp->FailAndExecute(); ok = FALSE; } return ok; }

void OpBackground::DoWithParam (  OpDescriptor *  pOpDesc, OpParam *  pParam )  [virtual]

This function is used to create a guideline in the selected spread. It calls DoAddNewGuideline() with pParam->Param1 specifying the guideline type. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: pOpDesc  = ptr op desc [INPUTS] pOpParam = param block to use -  [OUTPUTS] Returns: - See also: DoAddNewGuideline(), OilRuler::OnLButtonDown() Reimplemented from Operation. Definition at line 191 of file backgrnd.cpp. { ERROR3IF(pParam == NULL,"pParam is NULL"); TRACEUSER("Gerry", _T("OpBackground::DoWithParam")); if (pParam != NULL) { BOOL ok = TRUE; OpBackgroundParam* pOpBackgroundParam = (OpBackgroundParam*)pParam; // Document * pDoc = pOpBackgroundParam->pDoc; Spread * pSpread = pOpBackgroundParam->pSpread; DocColour * pDocColour = pOpBackgroundParam->pDocColour; KernelBitmap * pBitmap = pOpBackgroundParam->pBitmap; // If no spread is given then use the selected one if (pSpread == NULL) { // We will work off the currently selected spread pSpread = Document::GetSelectedSpread(); } // Go and do the job of making the page background ok = DoMakePageBackground(this, pSpread, pBitmap, pDocColour); } End(); }

NodeRegularShape * OpBackground::FindPageRectangle (  Layer *  pBackgroundLayer, const DocRect &  PagesRect )  [static, protected]

Tries to find the page filling rectangle on the specified layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: The  layer to search for the shape on [INPUTS] The encompassing rectangle of the current pages -  [OUTPUTS] Returns: The regular shape, if found See also: - Definition at line 471 of file backgrnd.cpp. { ERROR2IF(pBackgroundLayer == NULL,FALSE,"OpBackground::FindPageRectangle Bad params error!"); NodeRegularShape *pShape = NULL; NodeRegularShape *pRegNode = NULL; Node * pNode = pBackgroundLayer->FindFirstChild(); DocRect rect; const MILLIPOINT delta = 1000; while (pNode != NULL) { // Only check regular shape nodes if (pNode->IS_KIND_OF(NodeRegularShape)) { // Only check rectangles pRegNode = (NodeRegularShape *)pNode; if (pRegNode->IsARectangle()) { //DocCoord MinorAxis NodeRegularShape::GetMinorAxes(); // The bounding rect should be roughly what we want rect = pRegNode->GetBoundingRect(TRUE, FALSE); if ( (PagesRect.lo.x > rect.lo.x - delta) && (PagesRect.lo.x < rect.lo.x + delta) && (PagesRect.hi.x > rect.hi.x - delta) && (PagesRect.hi.x < rect.hi.x + delta) && (PagesRect.lo.y > rect.lo.y - delta) && (PagesRect.lo.y < rect.lo.y + delta) && (PagesRect.hi.y > rect.hi.y - delta) && (PagesRect.hi.y < rect.hi.y + delta) ) { pShape = pRegNode; } } } pNode = pNode->FindNext(); } return pShape; }

BOOL OpBackground::FixBackgroundLayer (  Layer *  pBackgroundLayer, const DocRect &  NewPagesRect, const DocRect &  OldPagesRect )  [static]

This tries to fix up the special page background layer so that the rectangle on it is resized to the cover the newly resized pages on the spread. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/97 Parameters: The  background layer to fix [INPUTS] The encompassing size of the new pages in the spread The encompassing size of the old pages in the spread -  [OUTPUTS] Returns: Ptr to a background layer that's ready to be inserted into the tree See also: Spread::SetPageSize; Definition at line 873 of file backgrnd.cpp. { ERROR2IF(pBackgroundLayer == NULL,FALSE,"OpBackground::FixBackgroundLayer Bad params!"); //BOOL ok = TRUE; // There should be a rectangle on the page encompassing the old position of the pages // so go and try and find it NodeRegularShape * pShape = FindPageRectangle(pBackgroundLayer, OldPagesRect); // If no rectangle is found then something might be slightly wrong. Should we error? if (pShape) { const INT32 CornerRadius = 0; // No curvature if (pShape->MakeRectangle(NewPagesRect.Width(), NewPagesRect.Height(), CornerRadius)) { // Translate centre from 0,0 to required position relative to page INT32 XTrans = NewPagesRect.lo.x + (NewPagesRect.Width()/2); INT32 YTrans = NewPagesRect.lo.y + (NewPagesRect.Height()/2); Trans2DMatrix Trans(XTrans, YTrans); pShape->Transform(Trans); // finish off the shape pShape->InvalidateBoundingRect(); } // Find any bitmap fills and fix up the fill origin etc. Node * pNode = pShape->FindFirstChild(); while (pNode != NULL) { // Only check and fix bitmap colour fill attributes of the regular shape nodes if (pNode->IS_KIND_OF(AttrBitmapColourFill)) { // Convert the pointer to the correct type AttrBitmapColourFill * pBitmapFillAttr = (AttrBitmapColourFill*)pNode; // Set the coordinates of the fill end points // We want to start the fill at the top left of the regular shape // The bounding rect should be roughly what we want DocRect Rect = pShape->GetBoundingRect(TRUE, FALSE); KernelBitmap * pBitmap = ((AttrFillGeometry*)pBitmapFillAttr)->GetBitmap(); // Get the size of the bitmap taking into account its DPI INT32 Width = pBitmap->GetRecommendedWidth(); INT32 Height = pBitmap->GetRecommendedHeight(); // You would think that the handles on the fill correspond to where you place them // but oh now the displayed handles are shown at different points. So instead of // positioning the start in the centre of the bitmap, you need to position it bottom left // The End should be centre and right but needs to be bottom right. // The End2 should be centre and top but needs to be top left. // We want the start point to be half the height of the bitmap below this //DocCoord Start(Rect.lo.x + Width/2, Rect.hi.y - Height/2); DocCoord Start(Rect.lo.x, Rect.hi.y - Height); // We want the other end point to be same height as the centre point // but on the far right of the rectangle i.e the full width across //DocCoord End(Rect.lo.x + Width, Rect.hi.y - Height/2); DocCoord End(Rect.lo.x + Width, Rect.hi.y - Height); // We want the end point to be middle and top of the rectangle //DocCoord End2(Rect.lo.x + Width/2, Rect.hi.y); DocCoord End2(Rect.lo.x, Rect.hi.y); ((AttrFillGeometry*)pBitmapFillAttr)->SetStartPoint(&Start); ((AttrFillGeometry*)pBitmapFillAttr)->SetEndPoint(&End); ((AttrFillGeometry*)pBitmapFillAttr)->SetEndPoint2(&End2); } pNode = pNode->FindNext(); } } return TRUE; }

void OpBackground::GetOpName (  String_256 *  OpName  )  [virtual]

Returns a desc of the op. Mainly used to fill in the menu item for the undo/redo ops. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: OpName  = ptr to string [INPUTS] OpName  contains a description of the op [OUTPUTS] Returns: - See also: - Reimplemented from Operation. Definition at line 1131 of file backgrnd.cpp. { *OpName = String_256(_R(IDS_UNDO_SETBACKGROUND)); }

BOOL OpBackground::GetPageColour (  Spread *  pSpread, KernelBitmap **  ppOutBitmap, DocColour **  ppOutColour )  [static]

Gets the page's fill attribute, which could only be either a colour, or a bitmap. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/97 Parameters: pSpread  - a spread [INPUTS] ppOutBitmap  - receives the page bitmap, if a bitmap colour fill is applied to it [OUTPUTS] ppOutColour - receives the page colour, if a flat colour fill is applied to it Returns: TRUE, if succesful, FALSE otherwise Definition at line 964 of file backgrnd.cpp. { ERROR2IF(pSpread == NULL,FALSE,"OpBackground::GetPageColour Bad params error!"); ERROR2IF(ppOutBitmap == NULL || ppOutColour == NULL,FALSE,"OpBackground::GetPageColour Bad params error!"); // Search for our special page background layer Layer* pFoundLayer = pSpread->FindFirstPageBackgroundLayer(); if (pFoundLayer == NULL) return FALSE; // search for our page node NodeRegularShape *pNode = DoFindPageRectangle(pSpread, pFoundLayer); if (!pNode) return FALSE; // find the fill attribute applied to the page NodeAttribute *pAppliedAttr = NULL; pNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry),&pAppliedAttr); if (pAppliedAttr != NULL) { if (IS_A(pAppliedAttr, AttrFlatColourFill)) // flat colour fill? { // get the colour attribute ColourFillAttribute *pColAttr = (ColourFillAttribute *)(pAppliedAttr->GetAttributeValue()); // set the colour pointer to the doc colour, and the bitmap pointer to NULL *ppOutBitmap = NULL; *ppOutColour = pColAttr->GetStartColour(); } else if (IS_A(pAppliedAttr, AttrBitmapColourFill)) // bitmap fill { // set the colour pointer to NULL, and the bitmap pointer to the kernel bitmap *ppOutBitmap = ((AttrFillGeometry *)pAppliedAttr)->GetBitmap(); *ppOutColour = NULL; } else return FALSE; } else return FALSE; return TRUE; }

OpState OpBackground::GetState (  String_256 *  Description, OpDescriptor *  )  [static]

Func for determining the usability of this op. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: Description  = ptr to place description of why this op can't happen [INPUTS] pOpDesc = ptr to the Op Desc associated with this op -  [OUTPUTS] Returns: An OpState object See also: - Definition at line 1111 of file backgrnd.cpp. { OpState State; return State; }

BOOL OpBackground::Init (  void   )  [static]

Called when the op is undone. This broadcasts a 'Guidelines changed' layer message Called when the op is redone. This broadcasts a 'Guidelines changed' layer message Registers an op desc for this op. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if op successfully declared, FALSE otherwise See also: - Reimplemented from SimpleCCObject. Definition at line 1081 of file backgrnd.cpp. { BOOL ok = RegisterOpDescriptor( 0, 0, CC_RUNTIME_CLASS(OpBackground), OPTOKEN_BACKGROUND, OpBackground::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ); return ok; }

BOOL OpBackground::MakePageBackground (  UndoableOperation *  pOp, Spread *  pSpread, KernelBitmap *  pBitmap )  [static]

Tries to apply the DocColour or bitmap as a new page background. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/4/97 Parameters: pOp  - the operation to use [INPUTS] pSpread - the spread to apply the background to pBitmap - the bitmap to apply -  [OUTPUTS] Returns: True if worked ok, False otherwise. It is up to the caller to call End() on the operation. This is so that an outside op should be able to call this and everything should work ok. See also: - Definition at line 271 of file backgrnd.cpp. { ERROR2IF(pOp == NULL || pSpread == NULL || pBitmap == NULL,FALSE,"MakePageBackground Bad params!"); // Get the op to do its stuff BOOL ok = DoMakePageBackground(pOp, pSpread, pBitmap); return ok; }

BOOL OpBackground::MakePageBackground (  UndoableOperation *  pOp, Spread *  pSpread, DocColour *  pDocColour )  [static]

Tries to apply the DocColour or bitmap as a new page background. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 7/4/97 Parameters: pOp  - the operation to use [INPUTS] pSpread - the spread to apply the background to pDocColour - the doc colour to apply -  [OUTPUTS] Returns: True if worked ok, False otherwise. It is up to the caller to call End() on the operation. This is so that an outside op should be able to call this and everything should work ok. See also: - Definition at line 241 of file backgrnd.cpp. { ERROR2IF(pOp == NULL || pSpread == NULL || pDocColour == NULL,FALSE,"MakePageBackground Bad params!"); // Get the op to do its stuff BOOL ok = DoMakePageBackground(pOp, pSpread, NULL, pDocColour); return ok; }

---

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

• Kernel/backgrnd.h (r1785/r1282)
• Kernel/backgrnd.cpp (r1785/r1664)

---