NodeBitmap Class Reference

A class for including bitmap objects within the tree. More...

#include <nodebmp.h>

Inheritance diagram for NodeBitmap:

List of all members.

Public Member Functions
	NodeBitmap ()
	This constructor creates a NodeBitmap linked to no other with all status flags false and an uninitialized bounding rectangle.
	NodeBitmap (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated.
virtual Node *	SimpleCopy ()
	Makes a copy of all the data in the node.
void	CopyNodeContents (NodeBitmap *NodeCopy)
	Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the NodeBitmap object in either the singular or the plural. This method is called by the DescribeRange method. The description will always begin with a lower case letter.
virtual KernelBitmap *	EnumerateBitmaps (UINT32 Count)
	Find out what bitmaps, if any, are used by this node.
virtual double	GetEffectiveBitmapMinDPI (KernelBitmap *pBitmap)
virtual BOOL	ReplaceBitmap (KernelBitmap *pOrigBitmap, KernelBitmap *pNewBitmap)
virtual BOOL	SupportsClipboardFormat (InternalClipboardFormat *Format) const
	Determine if a node supports a given internal data type. This is used by the clipboard when exporting to other applications in order to determine if certain data types can be supplied.
UINT32	GetBitmapDPI ()
	Caculates the actual DPI of the bitmap on the page.
virtual void	Render (RenderRegion *pRender)
	Will render the bitmap contained within the object to the given render region.
virtual void	PreExportRender (RenderRegion *pRender)
	Prevent the base class NodeRect::PreExportRender() function from exporting anything to mark this as a rectangle object - because it's not; it's a bitmap object.
virtual BOOL	ExportRender (RenderRegion *pRender)
	Export a bitmap object to a file.
virtual INT32	GetSizeOfExport (Filter *)
	Determine how many 'nodes' this bitmap is equivalent to. We use the rough approximation that each scanline taks the same amount of space as a typical node. This gives us enough granularity for a reasonably accurate and smooth progress display update.
virtual BOOL	RequiresAttrib (NodeAttribute *pAttrib, BOOL Search=FALSE)
	Determine which attributes a bitmap object supports a particular type of attribute. A bitmap only supports transparent fill geometries, mappings, and effects - all other attributes are rejected.
virtual BOOL	ApplyDefaultBitmapAttrs (UndoableOperation *pOp, AttrBitmapTranspFill *pTranspBitmap=NULL)
	Apply the default attributes that a NodeBitmap needs. This is specific to Bitmap Nodes, which need the Start and End colours to be NONE initially, and also need to ensure the line width is 0. There is now an optional pointer to a transparent bitmap fill to be applied over the current bitmap node. This is used by the transparent GIF import code.
virtual BOOL	OnNodePopUp (Spread *pSpread, DocCoord PointerPos, ContextMenu *pMenu)
	Allows the Node to respond to pop up menu clicks on it (rather than its blobs).
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	IsABitmap () const
virtual BOOL	NeedsTransparency () const
	Called.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object. In the case of a node bitmap we must stop it from it having the make shapes applied as otherwise we will loose the bitmap from view. NodeSimpleShape overrides the baseclass function to return True.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Transforms the object into another type of object. Note: changed 7/10/94 by MarkN to take the pBecomeA param, so that more data could be passed to these functions in the future without causing massive rebuilds due to the editing of node.h.
BOOL	AllowOp (ObjChangeParam *, BOOL)
	This is the way to ask a node if you can do an op to it.
BOOL	MakeContoneBitmap (UndoableOperation *)
	Make this NodeBitmap into a grey level version of itself.
virtual KernelBitmapRef *	GetBitmapRef ()
virtual KernelBitmap *	GetBitmap ()
	Get the bitmap referenced by this node.
virtual BOOL	HidingNode ()
	This virtual function is called whenever the node is hidden. It allows the node do things like 'optimise' itself to use less memory or send a message to let others know it is being hidden etc.
virtual BOOL	ShowingNode ()
	This virtual function is called whenever the node is re-shown after being Hidden. It allows the node to reconstruct itself if it was optimised or send a message to let others know it is back etc.
virtual void	SetStartColour (DocColour *)
	Set the start colour of a bitmap palette.
virtual void	SetEndColour (DocColour *)
	Set the end colour of a bitmap palette.
virtual DocColour *	GetStartColour ()
	Gets the start colour of the bitmap palette.
virtual DocColour *	GetEndColour ()
	Gets the end colour of the bitmap palette.
virtual BOOL	GetApplyContoneColour ()
BOOL	HasSimpleOrientation (RenderRegion *)
	Determine if a bitmap is classified as a 'simple' bitmap, for use during the complex rendering of a view - if the render region can support simple bitmaps and this function returns TRUE, then we render the bitmap directly, otherwise it goes into the masked GDraw bitmap and is rendered that way.
virtual BOOL	OnClick (DocCoord PointerPos, ClickType Click, ClickModifiers ClickMods, Spread *pSpread)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs.
virtual TCHAR *	GetDefaultOpToken ()
virtual void	SetAspectRatio (double dExWidth, double dExHeight, BOOL bPathAndFill)
	To reset the stored path and Parallelogram to retain their shape and scale but to take on a new aspect ratio.
virtual BOOL	ReleaseCached (BOOL bAndParents=TRUE, BOOL bAndChildren=TRUE, BOOL bSelf=TRUE, BOOL bAndDerived=TRUE)
	Get rid of cached data held in the tree.
virtual DocRect	GetOriginalBitmapRect ()
	Find the starting point for the instance transform.
virtual Matrix	GetInstanceTransform ()
	Find the instance transform matrix Notes: Parallelogram format includes 4 coords and is stored in this format: 0-------1 | | 3-------2 (Why?).
virtual BOOL	CanSupplyDirectBitmap ()
virtual BOOL	GetDirectBitmap (RenderRegion *pRender, LPBITMAPINFO *plpInfo, LPBYTE *plpBits, DocRect *pRect, Matrix *pMat, double *pdRes)
	Return details of direct bitmap to caller (caller is usually a NodeBitmapEffect).
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	saves a NodeBitmap to the filter
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
Static Public Member Functions
static KernelBitmap *	CheckGreyscaleBitmap (KernelBitmap *pBitmap, UINT32 PromptID, UINT32 OkID)
	Checks a bitmap to see if can be applied as a texture, and gives the option to create a grey level version if not.
Public Attributes
KernelBitmapRef	BitmapRef
Protected Member Functions
virtual BOOL	HasBitmapAttrs ()
	Test whether we need to render this bitmap before we can return it from GetDirectBitmap.
Protected Attributes
DocColour	Colour
DocColour	EndColour
BOOL	ApplyContoneColour
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeBitmap)

---

Detailed Description

A class for including bitmap objects within the tree.

Author:

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

Date:

08/03/94

See also:

NodeRect, KernelBitmap

Definition at line 124 of file nodebmp.h.

---

Constructor & Destructor Documentation

NodeBitmap::NodeBitmap (   )

This constructor creates a NodeBitmap linked to no other with all status flags false and an uninitialized bounding rectangle. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/08/94 NB. SetUpPath() must be called before the NodeBitmap is in a state in which it can be used. See also: SetUpPath Definition at line 266 of file nodebmp.cpp. : NodeRect() { Colour = COLOUR_NONE; EndColour = COLOUR_NONE; ApplyContoneColour = FALSE; }

NodeBitmap::NodeBitmap (  Node *  ContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This constructor initialises the nodes flags and links it to ContextNode in the direction specified by Direction. All neccesary tree links are updated. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/08/94 Parameters: ContextNode,:  Pointer to a node which this node is to be attached to. [INPUTS] Direction: Specifies the direction in which the 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 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 ? Note: SetUpPath() must be called before the NodeBitmap is in a state in which it can be used. See also: SetUpPath Returns: Errors: An assertion error will occur if ContextNode is NULL Definition at line 235 of file nodebmp.cpp. :NodeRect(ContextNode, Direction, Locked, Mangled, Marked, Selected ) { Colour = COLOUR_NONE; EndColour = COLOUR_NONE; ApplyContoneColour = FALSE; }

---

Member Function Documentation

BOOL NodeBitmap::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState )

This is the way to ask a node if you can do an op to it. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/02/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node will be set according to the outcome of the call -  [OUTPUTS] Returns: TRUE means the node and all its parents are happy with this op, FALSE means don't do it The ObjChangeParam class contains flags that describe how it will change the node For example, the op could change the node's appearence (e.g. attr application, editing a path), replace the node with another node (e.g. because it uses hidden nodes to hide the original and put another node in its place, or "make shapes"), delete the node (e.g. the delete and cut ops), etc. This function gives the node a chance to say NO. It also gives the parents a chance to say no too. E.g. a blend node will allow itself to be deleted, but it will NOT allow a child of itself to be deleted). This call should only be made on selected, or parents of selected, nodes. It makes a decision as a straight node if it is selected. It makes a decision as a parent if it has selected children. E.g. NodeBlend::AllowOp(...op delete...) if the node is selected, then it will return TRUE (parents permitting), i.e. I can be deleted if the node is a parent of selected it will return FALSE (i.e. can't delete children of blends). So when the node is selected, you are asking the node if you can do the op to it. When the node is a parent of a selected node, you are asking if you can do the op to one of its children. If the 'SetOpPermissionState' param is TRUE, the following indented lines applies: The node's op permission state is set according to the result of this function. If TRUE is returned, then the node's op permission state will be left unchanged. AND the parent's op permission state will be set to PERMISSION_ALLOWED if FALSE is returned, then the node's op permission state will be PERMISSION_DENIED, AND all it's parents (up to the layer) will be set to PERMISSION_DENIED Also, all parents of this node are called via their AllowOp() func with the same state as this node. This means that after this call, you can guarantee that all of its parents will have either a PERMISSION_DENIED or PERMISSION_ALLOWED state. Note: Even if this node tries to set all it's parents to have a PERMISSION_DENIED state, if any of its parents have previously been set to PERMISSION_ALLOWED they will remain in that state (see SetOpPermission()). Why? Well, it is possible for a parent node to have one child with a PERMISSION_DENIED and another child with a PERMISSION_ALLOWED. It this state the parent MUST be in state PERMISSION_ALLOWED, because at least one of its children will allow the op to happen to it. So, after this call: The op permission state for this node will be either left unchanged (and therefore remain PERMISSION_UNDEFINED), or PERMISSION_DENIED. The parent's op permission state will be either PERMISSION_ALLOWED, or PERMISSION_DENIED. This is so UndoableOperation::UpdateChangedNodes() will only call OnChildChange() on parent nodes, because it only calls that func for nodes that have an op permission state of PERMISSION_ALLOWED. See also: GetOpPermission(),SetOpPermission(); Definition at line 1479 of file nodebmp.cpp. { BOOL AnyAllowed=AllowOp_AccountForCompound(pParam, SetOpPermissionState); // if called by a parent, just pass this result back if (pParam->GetDirection()==OBJCHANGE_CALLEDBYPARENT) return AnyAllowed; } else { // clean out the calling-child ptr, so it doesn't get passed around unintentionally. pParam->SetCallingChild(NULL); } // at this point we must have been called directly by the op or via a child AllowOp() // decide if we allow it ... BOOL allowed=TRUE; ObjChangeFlags Flags = pParam->GetChangeFlags(); if (Flags.Attribute) { // Someone is applying an attribute ..... // We really need to check the actual attribute, so for // now we'll rely on the fact that the 'RequiresAttrib()' // function will have been called before this one. // If we are applying a contone colour, then make sure we // are a Grey level bitmap, and give the user the option // of making one if not. if (ApplyContoneColour) { // 'ApplyContoneColour' is set in the 'RequiresAttrib()' // function if a contone colour change attr is applied. allowed = MakeContoneBitmap(pParam->GetOpPointer()); } } // if we allowed it, see if our parents do ... if (allowed && Parent!=NULL) { ObjChangeDirection OldDirection=pParam->GetDirection(); pParam->SetCallingChild(this); pParam->SetDirection(OBJCHANGE_CALLEDBYCHILD); allowed=Parent->AllowOp(pParam,SetOpPermissionState); pParam->SetDirection(OldDirection); } // if setting permisions ... if (SetOpPermissionState) { // if allowed, mark parent accordingly, else mark child as denied and update parents if (allowed) Parent->SetOpPermission(PERMISSION_ALLOWED); else SetOpPermission(PERMISSION_DENIED,TRUE); } // return result (directly, or indirectly via a child AllowOp()) to op return allowed; } /******************************************************************************************** > BOOL NodeBitmap::MakeContoneBitmap(UndoableOperation* pOperation) Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::ApplyDefaultBitmapAttrs (  UndoableOperation *  pOp, AttrBitmapTranspFill *  pTranspBitmap = NULL )  [virtual]

Apply the default attributes that a NodeBitmap needs. This is specific to Bitmap Nodes, which need the Start and End colours to be NONE initially, and also need to ensure the line width is 0. There is now an optional pointer to a transparent bitmap fill to be applied over the current bitmap node. This is used by the transparent GIF import code. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/95 Parameters: pOp  - the undoable operation in which this Node has been created. [INPUTS] pTranspBitmap - optional bitmap to apply as transparency. (Default = NULL) Returns: TRUE => Default attribute where applied ok. FALSE => Apply failed. Definition at line 997 of file nodebmp.cpp. { if (pTranspBitmap != NULL) { pTranspBitmap->AttachNode(this, FIRSTCHILD); // Apply it as a single tiled fill. Otherwise in the GIF transparency case // the repeating can give ghost pixels along the edges. AttrTranspFillMappingLinear *pNoRepeatAttr = new AttrTranspFillMappingLinear; if (pNoRepeatAttr == NULL) return FALSE; pNoRepeatAttr->Value.Repeat = 1; pNoRepeatAttr->AttachNode(this, FIRSTCHILD); } Node* pLineColAttr = new AttrStrokeColour(); if (pLineColAttr == NULL) return FALSE; /* Node* pLineTranspAttr = new AttrStrokeTransp(); if (pLineTranspAttr == NULL) { delete pLineColAttr; return FALSE; } */ Node* pFillColAttr = new AttrFlatColourFill(); if (pFillColAttr == NULL) { delete pLineColAttr; // delete pLineTranspAttr; return FALSE; } Node* pLineWidthAttr = new AttrLineWidth(); if (pFillColAttr == NULL) { delete pLineColAttr; // delete pLineTranspAttr; delete pFillColAttr; return FALSE; } DocColour colorNull(COLOUR_NONE); ((AttrFillGeometry*)pLineColAttr)->SetStartColour( &colorNull ); ((AttrFillGeometry*)pFillColAttr)->SetStartColour( &colorNull ); ((AttrLineWidth*)pLineWidthAttr)->Value.LineWidth = 0; // UINT32 LineTransp = 255; // ((AttrFillGeometry*)pLineTranspAttr)->SetStartTransp(&LineTransp); // ((AttrFillGeometry*)pLineTranspAttr)->SetTranspType(1); pLineColAttr->AttachNode(this, FIRSTCHILD); // pLineTranspAttr->AttachNode(this, FIRSTCHILD); pFillColAttr->AttachNode(this, FIRSTCHILD); pLineWidthAttr->AttachNode(this, FIRSTCHILD); return TRUE; }

BOOL NodeBitmap::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object. In the case of a node bitmap we must stop it from it having the make shapes applied as otherwise we will loose the bitmap from view. NodeSimpleShape overrides the baseclass function to return True. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 13/1/95 Parameters: pClass,:  The class of object [INPUTS] pNumObjects = ptr to place number of objects of type pClass that will be created (Note: can be NULL). pNumObects in undefined on entry Returns: TRUE if the node, or any of its children can transmogrify themselves to become an InkClass object The number you put into pNumObjects (if it's not NULL) should exactly equal the total number of pClass objects you create. It should NOT contain any additional objects you may produce such as group objects for containing the pClass object, or attributes. Also, the entry value of *pNumObjects cannot be assumed to be 0. Reimplemented from NodeSimpleShape. Definition at line 1087 of file nodebmp.cpp. { // The NodeBitmap can become a NodePath (with a bitmap fill) if (pBecomeA->BAPath()) { pBecomeA->AddCount(1); return TRUE; } return FALSE; }

virtual BOOL NodeBitmap::CanSupplyDirectBitmap (   )  [inline, virtual]

Reimplemented from NodeRenderableInk. Definition at line 217 of file nodebmp.h. {return TRUE;}

NodeBitmap::CC_DECLARE_DYNCREATE (  NodeBitmap   )  [private]

KernelBitmap * NodeBitmap::CheckGreyscaleBitmap (  KernelBitmap *  pBitmap, UINT32  PromptID, UINT32  OkID )  [static]

Checks a bitmap to see if can be applied as a texture, and gives the option to create a grey level version if not. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/95 Definition at line 1578 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

void NodeBitmap::CopyNodeContents (  NodeBitmap *  NodeCopy  )

Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: NodeCopy  - The node to copy [INPUTS] See also: NodeRect::CopyNodeContents Definition at line 312 of file nodebmp.cpp. { NodeRect::CopyNodeContents(NodeCopy); // Copy contents specific to derived class here // Copy KernelBitmap reference NodeCopy->BitmapRef = BitmapRef; // We need to copy the cached bitmaps into the new node // But since this cached (option 2) bitmap is only ever used as an intermediate stage // in producing another cached bitmap, we probably don't need to copy it //CopyCached(pCopyOfNode, GetPixelWidth(), 2); // Copy cached bitmaps, options 0, 1 and 2 (original and processed) }

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

To return a description of the NodeBitmap object in either the singular or the plural. This method is called by the DescribeRange method. The description will always begin with a lower case letter. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/93 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. Returns: Description of the object Errors: A resource exception will be thrown if a problem occurs when loading the string resource. Reimplemented from NodeRect. Reimplemented in NodeAnimatingBitmap. Definition at line 370 of file nodebmp.cpp. { #if !defined(EXCLUDE_FROM_RALPH) if (Plural) { return(String(_R(IDS_BITMAP_DESCRP))); } else { if (GetBitmap() == NULL || GetBitmap()->ActualBitmap == NULL) return(String(_R(IDS_BITMAP_DESCRS))); // If we have a bitmap, then include it's name and actual dpi // in the desciption String_256 BmpName = GetBitmap()->ActualBitmap->GetName(); String_64 TrunkName; if (BmpName.Length() > 12) { BmpName.Left(&TrunkName, 9); TrunkName += _T("..."); } else { BmpName.Left(&TrunkName, 12); } String_256 DpiText; UINT32 dpi = GetBitmapDPI(); if (dpi > 0) { String_256 jcf(_R(IDS_NODEBMP_DPI_FORMAT)); camSnprintf(DpiText, 256, jcf, dpi); } String_64 TrunkDpi; DpiText.Left(&TrunkDpi, 11); String_256 Desc(_R(IDS_BITMAP_DESCRS)); String_64 TrunkDesc; Desc.Left(&TrunkDesc, 6); if (Verbose) { String_32 ret = TrunkDesc; ret += TEXT(" '"); ret += TrunkName; ret += TEXT("'"); ret += TrunkDpi; return ret; // return(String(TrunkDesc+TEXT(" '")+TrunkName+TEXT("'")+TrunkDpi)); } else { String_32 ret = TrunkDesc; ret += TEXT(" "); ret += TrunkName; return ret; // return(String(TrunkDesc+TEXT(" ")+TrunkName)); } } #else return(String(_R(IDS_BITMAP_DESCRP))); #endif }

BOOL NodeBitmap::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Transforms the object into another type of object. Note: changed 7/10/94 by MarkN to take the pBecomeA param, so that more data could be passed to these functions in the future without causing massive rebuilds due to the editing of node.h. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/95 Parameters: pBecomeA  = ptr to a class that contains all the info needed to become a new [INPUTS] type of node. -  [OUTPUTS] Returns: TRUE if the object has been transformed, FALSE if we run out of memory See also: NodeSimpleShape::CanBecomeA Reimplemented from NodeSimpleShape. Definition at line 1118 of file nodebmp.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("pBecomeA is NULL")); // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); // pBecomeA->Reason is one that we understand. UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); BOOL Success = TRUE; // Our success flag (Important that this defaults to TRUE) NodePath* pNewNodePath = NULL; // Ptr to a new NodePath, if we get to make one. if (pBecomeA->BAPath()) { // We need to create a new NodePath, no matter what the reason. // Allocate a new NodePath node ALLOC_WITH_FAIL(pNewNodePath, (new NodePath), pBecomeA->GetUndoOp()); Success = (pNewNodePath != NULL); // Initialise the path if (Success) CALL_WITH_FAIL(pNewNodePath->InkPath.Initialise(InkPath.GetNumCoords(),12), pBecomeA->GetUndoOp(), Success); if (Success) CALL_WITH_FAIL(pNewNodePath->InkPath.CopyPathDataFrom(&InkPath), pBecomeA->GetUndoOp(), Success); if (Success) pNewNodePath->InkPath.IsFilled = TRUE; // If Success is TRUE, then we now have a new NodePath object that contains this shape's path if (Success) { // Remember the contone colours before we go and hide the applied attributes DocColour* ContoneStart = GetStartColour(); DocColour* ContoneEnd = GetEndColour(); switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE : { // It's a BECOMEA_REPLACE, so replace this node with the new NodePath in an undoable way // Can't do it in an undoable way without an Undo Op // ERROR2IF_PF(pBecomeA->GetUndoOp() == NULL,FALSE,("GetUndoOp() returned NULL")); // The NodeBitmap uses the Fill and line colours to set it's // contone colours. // But the bitmap fill doesn't need them, so we will Hide // any of these attributes that we find applied Node* pChild = FindFirstChild(); while (pChild != NULL) { Node* pThisChild = pChild; pChild = pChild->FindNext(); // Find next before we hide this child if (pThisChild->IsAnAttribute()) { NodeAttribute* pAttr = (NodeAttribute*)pThisChild; if (pAttr->IsAColourFill() || pAttr->IsAStrokeColour() ) { if (pUndoOp) { // Hide and Fill or Line colour attributes NodeHidden* pNodeHidden; Success = pBecomeA->GetUndoOp()->DoHideNode(pAttr, TRUE, &pNodeHidden); } else { pAttr->CascadeDelete(); delete pAttr; } } } } // Now make a Bitmap Fill that is equivalent to this NodeBitmap AttrFillGeometry* pBitmapFill; ALLOC_WITH_FAIL(pBitmapFill , new AttrBitmapColourFill(), pBecomeA->GetUndoOp()); if (pBitmapFill) { pBitmapFill->AttachBitmap(GetBitmap()); // Set any contone colours that we have pBitmapFill->SetStartColour(ContoneStart); pBitmapFill->SetEndColour(ContoneEnd); // Set the control points from the NodeBitmap Parallelogram pBitmapFill->SetStartPoint(&Parallel[3]); pBitmapFill->SetEndPoint(&Parallel[2]); pBitmapFill->SetEndPoint2(&Parallel[0]); pBitmapFill->AttachNode(this, FIRSTCHILD); if (pUndoOp) { // Create a hide node action to hide the node when we undo HideNodeAction* UndoHideNodeAction; Success = (HideNodeAction::Init(pBecomeA->GetUndoOp(), pBecomeA->GetUndoOp()->GetUndoActionList(), pBitmapFill, TRUE, // Include subtree size ( Action**)(&UndoHideNodeAction)) != AC_FAIL); } } // We also need to make sure it has no line colour AttrFillGeometry* pStrokeColour; ALLOC_WITH_FAIL(pStrokeColour , new AttrStrokeColour(), pBecomeA->GetUndoOp()); if (pStrokeColour) { // Ensure the line colour is set to NONE DocColour NoCol = COLOUR_NONE; pStrokeColour->SetStartColour(&NoCol); pStrokeColour->AttachNode(this, FIRSTCHILD); if (pUndoOp) { // Create a hide node action to hide the node when we undo HideNodeAction* UndoHideNodeAction; Success = (HideNodeAction::Init(pBecomeA->GetUndoOp(), pBecomeA->GetUndoOp()->GetUndoActionList(), pStrokeColour, TRUE, // Include subtree size ( Action**)(&UndoHideNodeAction)) != AC_FAIL); } } // Copy the node's attributes CALL_WITH_FAIL(CopyChildrenTo(pNewNodePath), pBecomeA->GetUndoOp(), Success); // Insert the new NodePath into the tree, next to this node pNewNodePath->AttachNode(this,NEXT); if (Success) { // Set the bounds pNewNodePath->InvalidateBoundingRect(); pNewNodePath->SetSelected(IsSelected()); if (pUndoOp) { // Create a hide node action to hide the node when we undo HideNodeAction* UndoHideNodeAction; Success = (HideNodeAction::Init(pBecomeA->GetUndoOp(), pBecomeA->GetUndoOp()->GetUndoActionList(), pNewNodePath, TRUE, // Include subtree size ( Action**)(&UndoHideNodeAction)) != AC_FAIL); } } if (Success) { CCAttrMap AttrMap; CCAttrMap* pAttrMap = NULL; BOOL bFoundAttrs = pNewNodePath->FindAppliedAttributes(&AttrMap); if (bFoundAttrs) pAttrMap = AttrMap.Copy(); pBecomeA->PassBack(pNewNodePath, this, pAttrMap); } // Now hide this NodeBitmap if (pUndoOp) { NodeHidden* pNodeHidden; Success = pBecomeA->GetUndoOp()->DoHideNode(this, TRUE, &pNodeHidden); } else { CascadeDelete(); delete this; // Scary! } } break; case BECOMEA_PASSBACK : { // First find all attributes applied to this node... // 30 is a default value - this will grow if it needs more space CCAttrMap* pAttribMap = new CCAttrMap(30); CCAttrMap* pCopyOfAttrMap = NULL; // Now find any attributes that are applied to this node. /*BOOL FoundAttrs =*/ FindAppliedAttributes(pAttribMap); // size_t AttrCount = FoundAttrs ? pAttribMap->GetCount() : 30; // Now make a copy of the applied attributes map pCopyOfAttrMap = pAttribMap->Copy ();//new CCAttrMap(AttrCount); if (pCopyOfAttrMap != NULL) { // We've made a copy of the Attr map now, so we don't need // the old one anymore delete pAttribMap; // Replace the Fill and Line Colour attributes // in the Attr Map copy AttrFillGeometry* pBitmapFill = new AttrBitmapColourFill(); if (pBitmapFill) { // Make a Bitmap Fill that is equivalent to this // node bitmap pBitmapFill->AttachBitmap(GetBitmap()); // Set any contone colours that we have pBitmapFill->SetStartColour(ContoneStart); pBitmapFill->SetEndColour(ContoneEnd); // Set the control points from the NodeBitmap Parallelogram pBitmapFill->SetStartPoint(&Parallel[3]); pBitmapFill->SetEndPoint(&Parallel[2]); pBitmapFill->SetEndPoint2(&Parallel[0]); void* pOldFill; if( pCopyOfAttrMap->Lookup( CC_RUNTIME_CLASS(AttrFillGeometry), pOldFill ) ) { // We need to Remove and Delete the existing Fill Attr pCopyOfAttrMap->RemoveKey( CC_RUNTIME_CLASS(AttrFillGeometry) ); delete (AttrFillGeometry*)pOldFill; } // Add the Bitmap fill into the Attr Map pCopyOfAttrMap->SetAt( CC_RUNTIME_CLASS(AttrFillGeometry), (void*)pBitmapFill ); } AttrFillGeometry* pStrokeColour = new AttrStrokeColour(); if (pStrokeColour) { // Ensure the line colour is set to NONE DocColour NoCol = COLOUR_NONE; pStrokeColour->SetStartColour(&NoCol); void* pOldStroke; if( pCopyOfAttrMap->Lookup( CC_RUNTIME_CLASS(AttrStrokeColour), pOldStroke ) ) { // We need to Remove and Delete the existing Stroke Colour Attr pCopyOfAttrMap->RemoveKey( CC_RUNTIME_CLASS(AttrStrokeColour) ); delete (AttrFillGeometry*)pOldStroke; } // Add the new Stroke Colour into the Attr Map pCopyOfAttrMap->SetAt( CC_RUNTIME_CLASS(AttrStrokeColour), (void*)pStrokeColour ); } } Success = pBecomeA->PassBack(pNewNodePath, this, pCopyOfAttrMap); } break; case BECOMEA_TEST: // Do nothing break; default: { ERROR3("Unhandled BecomeA type in NodeBitmap::DoBecomeA"); } } } } if (!Success) { if (pNewNodePath != NULL) { // Delete all the NodePath's children (if it has any) and unlink it from the tree (if it's linked) // This is all done by CascadeDelete() pNewNodePath->CascadeDelete(); delete pNewNodePath; pNewNodePath = NULL; } } return Success; } /******************************************************************************************** > virtual BOOL NodeBitmap::AllowOp(ObjChangeParam* pParam,BOOL SetOpPermissionState = TRUE) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>

KernelBitmap * NodeBitmap::EnumerateBitmaps (  UINT32  Count  )  [virtual]

Find out what bitmaps, if any, are used by this node. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 02/17/95 Parameters: Count  - the bitmap to get (see Purpose). [INPUTS] Returns: The KernelBitmap in use by the node, or NULL if no more are used. The base class returns NULL always, so you over-ride this in any node classes that use bitmaps. This function supports nodes that use more than one bitmap - you call this function repeatedly and keep incrementing the Count parameter that you pass in each time by 1. You should stop calling it when it returns NULL, as this indicates that no more bitmaps are used by this node. Count should start off as 0 for the first call. Note that this function can (and often will) return NULL for the first call, as many nodes don't use bitmaps, obviously. See also: KernelBitmap Reimplemented from Node. Reimplemented in NodeAnimatingBitmap. Definition at line 2444 of file nodebmp.cpp. : Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Export a bitmap object to a file. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 01/09/94 Parameters: pRegion  - the export render region to export to. [INPUTS] Returns: TRUE if the bitmap was exported ok; FALSE if not. Errors: Usual disk/file errors. See also: Filter::ExportBitmap Reimplemented from NodeRenderableInk. Definition at line 625 of file nodebmp.cpp. { #ifdef DO_EXPORT if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CamelotEPSRenderRegion))) { // Get valid transparency fill for this object CamelotEPSRenderRegion *pCamelotRegion = (CamelotEPSRenderRegion *) pRegion; pCamelotRegion->GetValidPathAttributes(); // Output bitmap object position and keyword... EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); DocCoord *Coords = InkPath.GetCoordArray(); // Bodge Code // So this is some Bodge code to make Bitmaps in moulds, save themselves // correctly if a Line colour is applied to the Mould. // This line colour makes the Bitmap think it has been contoned, so we save out // a contoned version, which is looks incorrect when re-loaded. // To get around this problem, this code checks specifically for the situation, // and forces the bitmap to be saved as a non-contoned version. BOOL CanSaveAsContoned = TRUE; BOOL LineColourIsAppliedToMould = FALSE; if (GetBitmap() && GetBitmap()->GetBPP() <= 8) { // We only need to worry about this for < 8BPP NodeAttribute* pLineAttr; // So we find the applied Stroke Colour ... if (FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pLineAttr)) { Node* pParent = pLineAttr->FindParent(); // And if it has been applied to a Mould ... if (pParent && IS_A(pParent, NodeMould)) { LineColourIsAppliedToMould = TRUE; // and there is no Flat Colour Applied to the Bitmap, // then this flag will be FALSE, stopping the bitmap // from being saved as contone. CanSaveAsContoned = (GetEndColour() != NULL); } } } if (CanSaveAsContoned && (GetStartColour() || GetEndColour())) { // Must be a contone bitmap // If either the start or end colour is NULL, we need // to output a dummy colour, because 'No_Colour' doesn't // get saved if (LineColourIsAppliedToMould || GetStartColour() == NULL) { DocColour StartCol; AttributeManager::FindDefaultColour(ColourManager::GetCurrentColourList(), _R(IDS_BLACKNAME), &StartCol); if (*GetEndColour() == StartCol) { AttributeManager::FindDefaultColour(ColourManager::GetCurrentColourList(), _R(IDS_WHITENAME), &StartCol); } // Output dummy start colour here if (StartCol.FindParentIndexedColour() == NULL) { // Unnamed colour PColourCMYK CMYK; StartCol.GetCMYKValue(&CMYK); pDC->OutputColour(&CMYK); pDC->OutputToken(_T("K")); } else { // Named colour pDC->OutputNamedColour(&StartCol); pDC->OutputToken(_T("X")); } pDC->OutputNewLine(); } else if (GetEndColour() == NULL) { DocColour EndCol; AttributeManager::FindDefaultColour(ColourManager::GetCurrentColourList(), _R(IDS_WHITENAME), &EndCol); if (*GetStartColour() == EndCol) { AttributeManager::FindDefaultColour(ColourManager::GetCurrentColourList(), _R(IDS_BLACKNAME), &EndCol); } // Output dummy end colour here if (EndCol.FindParentIndexedColour() == NULL) { // Unnamed colour PColourCMYK CMYK; EndCol.GetCMYKValue(&CMYK); pDC->OutputColour(&CMYK); pDC->OutputToken(_T("k")); } else { // Named colour pDC->OutputNamedColour(&EndCol); pDC->OutputToken(_T("x")); } pDC->OutputNewLine(); } // Co-ords first, for (INT32 i = 0; i <= 3; i++) pDC->OutputCoord(Coords[i]); // ...then the bitmap object token. pDC->OutputToken(_T("cbm")); pDC->OutputNewLine(); // ...and then the bitmap data itself. pDC->GetParentFilter()->ExportBitmap(*GetBitmap()); } else { // It's not a contone bitmap. // Oh bum. We've made a bit of a bo-bo with these. // Since we don't save 'no-colour' we don't know that // the bitmap has no-colour when re-loaded, and so it // uses the 'current' fill colour, so sometimes the bitmaps // come out coloured, when they shouldn't be. // Solution .... We'll save this bitmap as a bitmap fill // (which already has a non-contone format), and save out // some extra stuff to tell the import routines that it's // not a bitmap fill, but really a bitmap object. // This means it will look correct in the Viewer (they'll // be loaded as bitmap filled paths), but will appear as // bitmaps when loaded into the main program. // So first we'll output a new eps object (which will be Ignored by // the viewer), telling the main program that the following // object is really a bitmap object pDC->OutputValue((INT32) EOTAG_BITMAPFLAGS); pDC->OutputToken(_T("cso")); // Start of new object type pDC->OutputToken(_T("cbot")); // Flag the next bitmap fill as an object pDC->OutputToken(_T("ceo")); // End of new object type pDC->OutputNewLine(); // Now output the Bitmap fill pDC->OutputCoord(Coords[3]); pDC->OutputCoord(Coords[2]); pDC->OutputCoord(Coords[0]); pDC->OutputValue((INT32) CAMEPS_FILL_BITMAP); pDC->OutputToken(_T("cax")); pDC->OutputNewLine(); // ...and then the bitmap data itself. pDC->GetParentFilter()->ExportBitmap(*GetBitmap()); // Now output a filled path for the Viewer to render // This will be skipped over by the new import code pDC->OutputCoord(Coords[0]); pDC->OutputToken(_T("m")); pDC->OutputNewLine(); pDC->OutputCoord(Coords[1]); pDC->OutputToken(_T("l")); pDC->OutputNewLine(); pDC->OutputCoord(Coords[2]); pDC->OutputToken(_T("l")); pDC->OutputNewLine(); pDC->OutputCoord(Coords[3]); pDC->OutputToken(_T("l")); pDC->OutputNewLine(); pDC->OutputCoord(Coords[0]); pDC->OutputToken(_T("l")); pDC->OutputNewLine(); pDC->OutputToken(_T("F")); // Filled path pDC->OutputNewLine(); } // Now force the Fill Colour, Line Colour, and Line Width // attribute to output themselves again, 'cus old versions // (including the Viewer) will corrupt these attributes for // any subsequent objects // Get rid of the current copies of the last output attrs delete pCamelotRegion->LastOutputAttrs[ATTR_FILLGEOMETRY].pAttr; delete pCamelotRegion->LastOutputAttrs[ATTR_STROKECOLOUR].pAttr; delete pCamelotRegion->LastOutputAttrs[ATTR_LINEWIDTH].pAttr; // NULL the pointers pCamelotRegion->LastOutputAttrs[ATTR_FILLGEOMETRY].pAttr = NULL; pCamelotRegion->LastOutputAttrs[ATTR_STROKECOLOUR].pAttr = NULL; pCamelotRegion->LastOutputAttrs[ATTR_LINEWIDTH].pAttr = NULL; // and clear the Temp flags so we don't try and delete them on exit pCamelotRegion->LastOutputAttrs[ATTR_FILLGEOMETRY].Temp = FALSE; pCamelotRegion->LastOutputAttrs[ATTR_STROKECOLOUR].Temp = FALSE; pCamelotRegion->LastOutputAttrs[ATTR_LINEWIDTH].Temp = FALSE; // Re-output the attributes we've just reset pCamelotRegion->GetValidPathAttributes(); // Tell caller we rendered ourselves ok return TRUE; } PORTNOTE("cmx", "Disabled CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if (pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *)pRegion->GetRenderDC(); ERROR2IF(pDC == NULL, FALSE, "no dc in CMXRenderRegion"); KernelBitmap *pBittyThingy = BitmapRef.GetBitmap(); ERROR2IF(pBittyThingy == NULL, FALSE, "no bitmap in the node"); pDC->WriteBitmap ( pBittyThingy, ( DocCoord * ) ( &Parallel ), CMXExportDC::CMXBITMAPCOLOURSOURCE_LINEANDFILL ); return TRUE; } #endif else if ( pRegion->IsKindOf ( CC_RUNTIME_CLASS ( AIEPSRenderRegion ) ) ) { // Grab a pointer to the AIEPS_RenderRegion. AIEPSRenderRegion *pAIEPSRR = static_cast<AIEPSRenderRegion*> ( pRegion ); // Write the bitmap using the render region's custom code. return pAIEPSRR->ExportBitmap ( this ); } #endif // Render this node in the normal way return FALSE; }

virtual BOOL NodeBitmap::GetApplyContoneColour (   )  [inline, virtual]

Definition at line 194 of file nodebmp.h. {return ApplyContoneColour;};

KernelBitmap * NodeBitmap::GetBitmap (  void   )  [virtual]

Get the bitmap referenced by this node. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Reimplemented in NodeAnimatingBitmap. Definition at line 1603 of file nodebmp.cpp. { ERROR2IF(pBitmap->GetParentBitmapList() == NULL, NULL, "Deleted bitmap has no parent list"); // Use the default bitmap instead pBitmap = pBitmap->GetParentBitmapList()->FindDefaultBitmap(); // There should always be a default bitmap in the list ERROR2IF(pBitmap == NULL, 0L, "Couldn't find the default bitmap"); } return pBitmap; } /*********************************************************************************************** > virtual BOOL NodeBitmap::HidingNode() Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

UINT32 NodeBitmap::GetBitmapDPI (   )

Caculates the actual DPI of the bitmap on the page. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 16/2/95 Returns: The actual DPI of the bitmap. Definition at line 448 of file nodebmp.cpp. { UINT32 Dpi = 0; if (GetBitmap() == NULL) return 0; // Do we have a valid bitmap ? OILBitmap *OilBM = GetBitmap()->ActualBitmap; if (OilBM != NULL) { BitmapInfo Info; OilBM->GetInfo(&Info); // Get the Width of the Bitmap in Pixels INT32 PixWidth = Info.PixelWidth; INT32 PixHeight = Info.PixelHeight; // Get the Width of the Bitmap in Millipoints INT32 Width = INT32(Parallel[0].Distance(Parallel[1])); INT32 Height = INT32(Parallel[1].Distance(Parallel[2])); // Use doubles so that we can round up as well as down. This improves // the dpi calculated. double HDpi = 0; double VDpi = 0; if (Width > 0) HDpi = ((double)PixWidth * 72000.0)/(double)Width; if (Height > 0) VDpi = ((double)PixHeight * 72000.0)/(double)Height; // Use the smaller of the two dpi values Dpi = (UINT32)(HDpi + 0.5); if (VDpi < Dpi) Dpi = (UINT32)(VDpi + 0.5); } return Dpi; }

virtual KernelBitmapRef* NodeBitmap::GetBitmapRef (   )  [inline, virtual]

Reimplemented in NodeAnimatingBitmap. Definition at line 182 of file nodebmp.h. { return &BitmapRef; }

virtual TCHAR* NodeBitmap::GetDefaultOpToken (   )  [inline, virtual]

Reimplemented from Node. Definition at line 206 of file nodebmp.h. {return _T("None");}

BOOL NodeBitmap::GetDirectBitmap (  RenderRegion *  pRender, LPBITMAPINFO *  plpInfo, LPBYTE *  plpBits, DocRect *  pRect, Matrix *  pMat, double *  pdRes )  [virtual]

Return details of direct bitmap to caller (caller is usually a NodeBitmapEffect). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28/07/2005 Parameters: pMat  - pointer to matrix awaiting update [INPUTS] plpInfo  - LPBITMAPINFO pointer describing bitmap [OUTPUTS] plpBits - LPBYTE pointer to bitmap data pRect - rect of Original bitmap data pMat - matrix describing transform from pRect to this instance on the page pdRes - resolution of this bitmap (dpi) Returns: TRUE if this node can supply direct bitmap data to the caller FALSE otherwise Reimplemented from NodeRenderableInk. Definition at line 1960 of file nodebmp.cpp. { // Lookup processed bitmap in cache CBitmapCache* pBitmapCache = Camelot.GetBitmapCache(); if (pBitmapCache==NULL) return FALSE; CBitmapCacheKey inky(this, 72000.0/pkBitmap->GetHorizontalDPI(), 2); // Option 2 is processed/rendered bitmap (see below) CCachedBitmap cbmp; BOOL bFound = pBitmapCache->Lookup(inky, cbmp); if (bFound) { if (plpInfo) *plpInfo = cbmp.pbmpInfo; if (plpBits) *plpBits = cbmp.pbmpBits; return TRUE; } // We need to create a new bitmap here that captures the effects of the attributes // // If we don't have a RenderRegion, we can't build it, so return NULLs to indicate // that we need to be called again with a RenderRegion (allows quick test) // (See EnsureLiveEffectOriginalBitmaps) if (pRender == NULL) { if (plpInfo) *plpInfo = NULL; if (plpBits) *plpBits = NULL; return TRUE; } // We must "render" this bitmap to capture the attributes that effect its appearance // By default, we can't do arbitrarily transformed bitmaps - use a bitmap fill. AttrFillGeometry* pTranspAttr = NULL; AttrFeather* pFeatherAttr = NULL; BitmapTranspFillAttribute* pFeatherTransp = NULL; KernelBitmap* pFeatherBitmap = NULL; MILLIPOINT mpScaledFeatherSize = 0; CProfileBiasGain profileFeather; DocRect CaptureRect = GetOriginalBitmapRect(); CaptureFlags caFlags = CaptureFlags(cfLOCKEDTRANSPARENT | cfFULLCOVERAGE); pRender->StartCapture(this, CaptureRect, CAPTUREINFO(ctNESTABLE, caFlags), TRUE, FALSE, pkBitmap->GetHorizontalDPI()); pRender->SaveContext(); { // ------------------------------------------------------ // Setup coords for rendering in DirectBitmap domain DocCoord coords[3]; coords[0] = CaptureRect.lo; coords[1] = DocCoord(CaptureRect.hi.x, CaptureRect.lo.y); coords[2] = DocCoord(CaptureRect.lo.x, CaptureRect.hi.y); // Create the path to be rendered in the DirectBitmap domain Path InkPath; InkPath.Initialise(); InkPath.AddMoveTo(coords[0]); InkPath.AddLineTo(coords[1]); InkPath.AddLineTo(DocCoord(coords[2].x+coords[1].x-coords[0].x, coords[2].y+coords[1].y-coords[0].y)); InkPath.AddLineTo(coords[2]); InkPath.AddLineTo(coords[0]); InkPath.CloseSubPath(); InkPath.IsFilled = TRUE; // Compute the inverse transform matrix - a matrix to get from "Screen space" to "Direct space" Matrix matInverse = GetInstanceTransform().Inverse(); // No lines on the rectangle pRender->SetLineColour(COLOUR_TRANS); pRender->SetLineWidth(0); // Render the transparency geometry using inverse Direct-Screen transform // (This bitmap is being rendered in "Direct space" whereas the transparency attribute // was applied in "Screen space") NodeAttribute* pAttr; if (FindAppliedAttribute(CC_RUNTIME_CLASS(AttrTranspFillGeometry), &pAttr)) { if (pAttr && !pAttr->IsADefaultAttr() && !pAttr->HasEquivalentDefaultValue(TRUE)) { pTranspAttr = (AttrFillGeometry*) ((AttrFillGeometry*)pAttr)->SimpleCopy(); if (pTranspAttr) { DocCoord tcoords[4]; DocCoord* pCoord = NULL; pCoord = pTranspAttr->GetStartPoint(); tcoords[0] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint(); tcoords[1] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint2(); tcoords[2] = pCoord ? *pCoord : DocCoord(0,0); pCoord = pTranspAttr->GetEndPoint3(); tcoords[3] = pCoord ? *pCoord : DocCoord(0,0); matInverse.transform(tcoords, 4); pTranspAttr->SetStartPoint(&tcoords[0]); pTranspAttr->SetEndPoint(&tcoords[1]); pTranspAttr->SetEndPoint2(&tcoords[2]); pTranspAttr->SetEndPoint3(&tcoords[3]); pTranspAttr->Render(pRender); } } } // Render the feather attribute with inverse scaled feather width // (This bitmap is being rendered in "Direct space" whereas the attribute // was applied in "Screen space") if (FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFeather), &pAttr)) { // currently, we only generate an offscreen bitmap for GRenderRegions, although we are // 'rendered' into all RR's. therefore we must quit quietly if pRender is not a GRR. if (pAttr && !pAttr->IsADefaultAttr() && !pAttr->HasEquivalentDefaultValue(TRUE) && pRender->IS_KIND_OF(GRenderRegion)) { // We can't render the feather attribute or a copy of it because the crappy // thing relies intimately on its connection to the tree to get geometric // information. GRenderRegion* pGRR = (GRenderRegion*)pRender; pFeatherAttr = (AttrFeather*) ((AttrFeather*)pAttr)->SimpleCopy(); if (pFeatherAttr) { mpScaledFeatherSize = pFeatherAttr->Value.GetFeatherSize(); FIXED16 f16Scale; matInverse.Decompose(&f16Scale); // Should take aspect into account as well??? mpScaledFeatherSize = (MILLIPOINT)((double)mpScaledFeatherSize * f16Scale.MakeDouble() + 0.5); pFeatherAttr->Value.SetFeatherSize(mpScaledFeatherSize); profileFeather = pFeatherAttr->Value.GetProfile(); // Don't let the feather render itself, but call it's core functions with // our special information to get it to create the crucial transparency bitmap fill pFeatherAttr->Value.CreateFeatherTransp(pGRR, &InkPath, 72000.0/((double)(pkBitmap->GetHorizontalDPI())), &pFeatherTransp, &pFeatherBitmap); if (pFeatherTransp) { TranspFillMappingLinearAttribute* pFeatherTranspMapping = new TranspFillMappingLinearAttribute; pFeatherTranspMapping->Repeat = 0; pRender->SetTranspFillMapping(pFeatherTranspMapping, TRUE); pRender->SetTranspFillGeometry(pFeatherTransp, TRUE); } } } } // Simple bitmap fill which fills the whole shape BitmapFillAttribute *pBitmapAttr = new BitmapFillAttribute; pBitmapAttr->GetBitmapRef()->SetBitmap(pkBitmap); if (GetStartColour()) pBitmapAttr->SetStartColour(GetStartColour()); if (GetEndColour()) pBitmapAttr->SetEndColour(GetEndColour()); // Set fill coords pBitmapAttr->StartPoint = coords[0]; pBitmapAttr->EndPoint = coords[1]; pBitmapAttr->EndPoint2 = coords[2]; // Set bitmap attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). pRender->SetFillGeometry(pBitmapAttr, TRUE); // Set the mapping to have no repeat, otherwise we get artifacts at the edges when // anti-aliasing is enabled (see bug 1391). FillMappingLinearAttribute *pNoRepeatAttr = new FillMappingLinearAttribute; // Prevent tesselation to get rid of possible edge effects pNoRepeatAttr->Repeat = 0; // Set mapping attribute, and get the render region to throw it away when it's finished // with (hence the TRUE parameter). pRender->SetFillMapping(pNoRepeatAttr, TRUE); // Draw the bitmap by rendering a bitmap filled path. pRender->DrawPath(&InkPath); } // ------------------------------------------------------ pRender->RestoreContext(); if (pTranspAttr) { delete pTranspAttr; pTranspAttr = NULL; } if (pFeatherAttr) { delete pFeatherAttr; pFeatherAttr = NULL; } // Don't need this because pFeatherTransp is rendered with "Temp=TRUE" so that the RenderRegion will delete it // if (pFeatherTransp) // { // delete pFeatherTransp; // pFeatherTransp = NULL; // } if (pFeatherBitmap != NULL) { delete pFeatherBitmap; pFeatherBitmap = NULL; } LPBITMAPINFO lpInfo = NULL; LPBYTE lpBits = NULL; pRender->StopCapture(this, FALSE, FALSE, &lpInfo, &lpBits, &CaptureRect); // We should now have a bitmap containing an upright version of the NodeBitmap // with transparency and contoning applied as per the attributes in the tree if (lpInfo && lpBits) { *plpInfo = lpInfo; *plpBits = lpBits; // Cache the PROCESSED/RENDERED bitmap as Option 2 CBitmapCacheKey inky(this, 72000.0/pkBitmap->GetHorizontalDPI(), 2); CCachedBitmap cbmp; cbmp.pbmpBits = lpBits; cbmp.pbmpInfo = lpInfo; cbmp.SetCachedRect(CaptureRect); cbmp.nPriority = CACHEPRIORITY_TEMPBITMAP_HIGH; if (cbmp.IsValid()) pBitmapCache->StoreBitmap(inky, cbmp); } } return TRUE; } /********************************************************************************************

double NodeBitmap::GetEffectiveBitmapMinDPI (  KernelBitmap *  pBitmap  )  [virtual]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/2006 Parameters: pBitmap  - pointer to a KernelBitmap [INPUTS] Returns: Reimplemented from Node. Definition at line 2465 of file nodebmp.cpp. { BitmapInfo Info; OilBM->GetInfo(&Info); // Get the Width of the Bitmap in Pixels INT32 PixWidth = Info.PixelWidth; INT32 PixHeight = Info.PixelHeight; // Get the Width of the Bitmap in Millipoints INT32 Width = INT32(Parallel[0].Distance(Parallel[1])); INT32 Height = INT32(Parallel[1].Distance(Parallel[2])); // Use doubles so that we can round up as well as down. This improves // the dpi calculated. double HDpi = 0; double VDpi = 0; if (Width > 0) HDpi = ((double)PixWidth * 72000.0)/(double)Width; if (Height > 0) VDpi = ((double)PixHeight * 72000.0)/(double)Height; // Use the smaller of the two dpi values if (HDpi < VDpi) return(HDpi); else return(VDpi); } } return(1e9); } /**************************************************************************** > BOOL NodeBitmap::ReplaceBitmap(KernelBitmap* pOrigBitmap, KernelBitmap* pNewBitmap)

DocColour * NodeBitmap::GetEndColour (   )  [virtual]

Gets the end colour of the bitmap palette. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Returns: NULL if there is no colour (> 8bpp), or a pointer to the End Colour. Definition at line 1757 of file nodebmp.cpp. { NodeAttribute* pFillAttr; if (!FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFillGeometry), &pFillAttr)) return NULL; DocColour* Col = ((AttrFillGeometry*)pFillAttr)->GetStartColour(); if (Col && *Col != COLOUR_NONE) return Col; // } return NULL; } /******************************************************************************************** > BOOL NodeBitmap::HasSimpleOrientation(RenderRegion *pRegion)

Matrix NodeBitmap::GetInstanceTransform (   )  [virtual]

Find the instance transform matrix Notes: Parallelogram format includes 4 coords and is stored in this format: 0-------1 | | 3-------2 (Why?). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/07/2005 Parameters: -  [INPUTS] Returns: Matrix containing the combined transformations that are required to get from the original bitmap size and position to that represented by the current NodeSimpleShape parallelogram. Definition at line 1869 of file nodebmp.cpp.

UINT32 NodeBitmap::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from NodeRect. Reimplemented in NodeAnimatingBitmap. Definition at line 503 of file nodebmp.cpp. { return (sizeof(NodeBitmap)); }

DocRect NodeBitmap::GetOriginalBitmapRect (   )  [virtual]

Find the starting point for the instance transform. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/07/2005 Parameters: -  [INPUTS] Returns: DocRect containing the size of the bitmap if it were placed on the page untransformed. Definition at line 1922 of file nodebmp.cpp. : Pixel width, ignoring bitmap's stated DPI // oRect.hi.y = 750.0 * pkBitmap->GetHeight(); // Note: Pixel height, ignoring bitmap's stated DPI oRect.hi.x = pkBitmap->GetRecommendedWidth(); oRect.hi.y = pkBitmap->GetRecommendedHeight(); return oRect; } /********************************************************************************************

INT32 NodeBitmap::GetSizeOfExport (  Filter *  pFilter  )  [virtual]

Determine how many 'nodes' this bitmap is equivalent to. We use the rough approximation that each scanline taks the same amount of space as a typical node. This gives us enough granularity for a reasonably accurate and smooth progress display update. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pFilter  - the filter that will be used to export this node. [INPUTS] Returns: The number of 'nodes' this bitmap is equivalent to (in size). See also: - Reimplemented from NodeRenderable. Definition at line 890 of file nodebmp.cpp. { #ifdef DO_EXPORT // Are we going to save the bitmap out as part of this object? if (pFilter->GetBitmapSupportLevel() != SimpleBitmapSupport) // No - just one node return 1; // Find out how many scanlines there are, and return as the result. KernelBitmap *pBitmap = GetBitmap(); BitmapInfo Info; if (!pBitmap->ActualBitmap->GetInfo(&Info)) // something has gone wrong! return 1; // Return number of scanlines. return Info.PixelHeight; #else return 0; #endif }

DocColour * NodeBitmap::GetStartColour (   )  [virtual]

Gets the start colour of the bitmap palette. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Returns: NULL if there is no colour (> 8bpp), or a pointer to the Start Colour. Definition at line 1722 of file nodebmp.cpp. { NodeAttribute* pLineAttr; if (!FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pLineAttr)) return NULL; DocColour* Col = ((AttrStrokeColour*)pLineAttr)->GetStartColour(); if (Col && *Col != COLOUR_NONE) return Col; // } return NULL; } /******************************************************************************************** > DocColour* NodeBitmap::GetEndColour() Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::HasBitmapAttrs (   )  [protected, virtual]

Test whether we need to render this bitmap before we can return it from GetDirectBitmap. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this node has attributes applied which affect the way it renders FALSE otherwise Definition at line 2218 of file nodebmp.cpp. { if (pAttr && !pAttr->IsADefaultAttr() && !pAttr->HasEquivalentDefaultValue(TRUE)) return TRUE; } if (FindAppliedAttribute(CC_RUNTIME_CLASS(AttrFeather), &pAttr)) { if (pAttr && !pAttr->IsADefaultAttr() && !pAttr->HasEquivalentDefaultValue(TRUE)) return TRUE; } return FALSE; } /********************************************************************************************

BOOL NodeBitmap::HasSimpleOrientation (  RenderRegion *  pRegion  )

Determine if a bitmap is classified as a 'simple' bitmap, for use during the complex rendering of a view - if the render region can support simple bitmaps and this function returns TRUE, then we render the bitmap directly, otherwise it goes into the masked GDraw bitmap and is rendered that way. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/95 Parameters: pRegion  - the region that the bitmap orientation should be tested in. [INPUTS] Returns: TRUE if the bitmap orientation is a simple rectangular stretch, perpendicular to the co-ordinate system; FALSE if not (e.g. rotation or shearing applied to bitmap). See also: DrawTransformedBitmap Definition at line 1800 of file nodebmp.cpp. { // Yes - simple rectangular orientation. return TRUE; } #endif // Complex bitmap orientation return FALSE; } /********************************************************************************************

BOOL NodeBitmap::HidingNode (   )  [virtual]

This virtual function is called whenever the node is hidden. It allows the node do things like 'optimise' itself to use less memory or send a message to let others know it is being hidden etc. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/1/94 Returns: TRUE if all was ok. FALSE if an error occured. ALWAYS CALL THE BASE CLASS' FUNCTION FROM YOUR OVERRIDDEN FUNCTION. Reimplemented from Node. Definition at line 1637 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::IsABitmap (   )  const [virtual]

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 02/17/95 Returns: TRUE See also: Node::IsABitmap Reimplemented from Node. Definition at line 2543 of file nodebmp.cpp. : Phil_Martin (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::MakeContoneBitmap (  UndoableOperation *  pOperation  )

Make this NodeBitmap into a grey level version of itself. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/95 Definition at line 1555 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::NeedsTransparency (  void   )  const [virtual]

Called. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 5/6/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this node requires transparency mode to render properly. Errors: - See also: Node::AttachNode Reimplemented from Node. Definition at line 2352 of file nodebmp.cpp. { // If the bitmap is 8 bpp or less then check for a transparent colour if(pNonConst->GetBitmap()->GetBPP() <= 8) { INT32 TranspIndex; // If the bitmap has a transparency index then we'll need to force transparency on if (pNonConst->GetBitmap()->GetTransparencyIndex(&TranspIndex)) return TRUE; } if(pNonConst->GetBitmap()->GetBPP() == 32) { // Mark H - If we`ve got a 32 bit bitmap then we must make sure we render into a 32bit // render region to get the correct output! return TRUE; } } return FALSE; */ } /******************************************************************************************** > BOOL WritePreChildrenWeb(BaseCamelotFilter* pFilter); BOOL WritePreChildrenNative(BaseCamelotFilter* pFilter);

BOOL NodeBitmap::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 21/01/2004 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeSimpleShape. Definition at line 2572 of file nodebmp.cpp. { // We're going to start up a new dialog so we want to clear out any click // processing logic that may be in process... DocView* pDocView = DocView::GetCurrent(); if (pDocView) pDocView->ClearClickState(); // Invoke and XPE Edit operation OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_XPE_EDIT); if (pOpDesc) { pOpDesc->Invoke(); return TRUE; } } #endif // did not use the click return FALSE; } /********************************************************************************************

BOOL NodeBitmap::OnNodePopUp (  Spread *  pSpread, DocCoord  PointerPos, ContextMenu *  pMenu )  [virtual]

Allows the Node to respond to pop up menu clicks on it (rather than its blobs). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Parameters: pSpread  The spread in which things are happening [INPUTS] PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Definition at line 524 of file nodebmp.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL ok = TRUE; PORTNOTE("liveeffects", "XPE menu option disabled") #ifndef EXCLUDE_FROM_XARALX ok = ok && pMenu->BuildCommand(OPTOKEN_XPE_EDIT, FALSE); #endif //ok = ok && pMenu->BuildCommand(OPTOKEN_BFXDLG, FALSE); #ifdef PHOTOSHOPPLUGINS // Only add in if required - general plug-in removal at present // Add a sub-menu tacked onto this which is the main PhotoShopContextMenu // we have real OpTokens and so can do it properly // Well, in fact we will ask the PhotoShopContextMenu to do it for us! // ok = ok && pMenu->BuildCommand(OPTOKEN_PLUGINS_UNDO_MENU, FALSE); // MenuItem* pMainRoot = pMenu->GetLastItem(); MenuItem* pMainRoot = NULL; // Add a submenu which is the list of bitmap based plug-ins. // We have no need for specifying a document and a bitmap as this will be read // by the undoable op. // There should not be a separator and we should use the undoable versions // of the operations (hence FALSE, TRUE). ok = ok && PlugInsContextMenu::BuildMenu(NULL, NULL, pMenu, pMainRoot, FALSE, TRUE); #endif // PHOTOSHOPPLUGINS ok = ok && pMenu->BuildCommand(OPTOKEN_TRACEDLG, TRUE); return ok; #else // !defined(EXCLUDE_FROM_RALPH) return FALSE; #endif // !defined(EXCLUDE_FROM_RALPH) }

void NodeBitmap::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 NodeSimpleShape. Reimplemented in NodeAnimatingBitmap. Definition at line 342 of file nodebmp.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeBitmap), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeBitmap)) CopyNodeContents((NodeBitmap*)pNodeCopy); }

void NodeBitmap::PreExportRender (  RenderRegion *  pRender  )  [virtual]

Prevent the base class NodeRect::PreExportRender() function from exporting anything to mark this as a rectangle object - because it's not; it's a bitmap object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: Ignored  [INPUTS] Reimplemented from NodeRect. Definition at line 603 of file nodebmp.cpp. { // No action, and we want to stop the base class from exporting any 'rectangly' // information that might confuse us. }

BOOL NodeBitmap::ReleaseCached (  BOOL  bAndParents = TRUE, BOOL  bAndChildren = TRUE, BOOL  bSelf = TRUE, BOOL  bAndDerived = TRUE )  [virtual]

Get rid of cached data held in the tree. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 30/07/2005 Parameters: bAndParents  - TRUE if should release parent objects [INPUTS] bAndChildren - TRUE if should release child objects bSelf - TRUE if should release own cached data bAndDerived - TRUE if should release cached data derived from this object -  [OUTPUTS] Returns: TRUE Reimplemented from NodeRenderableBounded. Definition at line 2261 of file nodebmp.cpp. { Node* pChild = FindFirstChild(); while (pChild) { if (pChild->IsBounded()) ((NodeRenderableBounded*)pChild)->ReleaseCached(FALSE, TRUE, TRUE, TRUE); pChild = pChild->FindNext(); } } // If I can't be cached, neither can my parent... if (bAndParents && FindParent() && FindParent()->IsBounded()) ((NodeRenderableBounded*)FindParent())->ReleaseCached(TRUE, FALSE, TRUE, TRUE); return TRUE; } /********************************************************************************************

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

Will render the bitmap contained within the object to the given render region. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Parameters: Pointer  to a render region [INPUTS] Reimplemented from NodeSimpleShape. Definition at line 578 of file nodebmp.cpp. { // No need to render if we are going to supply directly to a capture Capture* pCapture = pRender->GetTopCapture(); if (!(pCapture && pCapture->ConsumeDirectBitmap(this))) { // Render the transformed bitmap pRender->DrawTransformedBitmap(this); } }

BOOL NodeBitmap::ReplaceBitmap (  KernelBitmap *  pOrigBitmap, KernelBitmap *  pNewBitmap )  [virtual]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 07/08/2006 Parameters: pOrigBitmap  - pointer to a KernelBitmap [INPUTS] pNewBitmap - pointer to a KernelBitmap Returns: TRUE if ok, FALSE if bother Reimplemented from Node. Definition at line 2522 of file nodebmp.cpp. : Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::RequiresAttrib (  NodeAttribute *  pAttrib, BOOL  Search = FALSE )  [virtual]

Determine which attributes a bitmap object supports a particular type of attribute. A bitmap only supports transparent fill geometries, mappings, and effects - all other attributes are rejected. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/4/95 Parameters: pAttrib  - specifies the attribute being enquired about. [INPUTS] Search - See NodeRenderableInk::RequiresAttrib (Has no effect in this fn) Returns: TRUE => object supports this kind of attribute. FALSE => object does not support this kind of attribute, and so it should not be applied. See also: NodeRenderableInk::RequiresAttrib Reimplemented from NodeRenderableInk. Definition at line 931 of file nodebmp.cpp. { // Sanity checks ERROR2IF(pAttrib == NULL, FALSE, "Pointer is null in NodeBitmap::RequiresAttrib"); if ((pAttrib->IS_KIND_OF(AttrColourChange) || pAttrib->IS_KIND_OF(AttrStrokeColourChange))) { // Someone's trying to apply a contone colour // Remember this, so we can do a conversion in the // AllowOp routine. ApplyContoneColour = TRUE; // Just say yes return TRUE; } ApplyContoneColour = FALSE; // Is it one we want? return ((pAttrib->IsAColourFill() && pAttrib->IsAFlatFill()) || pAttrib->IsAStrokeColour() || pAttrib->IsATranspFill() || pAttrib->IS_KIND_OF(AttrValueChange) || pAttrib->IS_KIND_OF(AttrColourDrop) || pAttrib->IS_KIND_OF(AttrTranspFillMapping) || pAttrib->IS_KIND_OF(AttrFillEffect) || pAttrib->IS_KIND_OF(AttrFillMapping) || PORTNOTE("other","Removed AttrWebAddress") #ifndef EXCLUDE_FROM_XARALX pAttrib->IS_KIND_OF(AttrWebAddress) || //Added by Graham 1/9/96, so bitmaps can have HotLinks #endif pAttrib->IS_KIND_OF(AttrUser) ); }

void NodeBitmap::SetAspectRatio (  double  dExWidth, double  dExHeight, BOOL  bPathAndFill )  [virtual]

To reset the stored path and Parallelogram to retain their shape and scale but to take on a new aspect ratio. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/2004 Parameters: dExWidth  - Sample width (numerator) [INPUTS] dExHeight - Sample height (denominator) bPathAndFill - Apply this logic to both the path and the bitmap fill??? Returns: - Definition at line 2618 of file nodebmp.cpp. : P3 = P2+P1-P0 If you dont want the centre to move then: C = (P1+P2)*0.5 Dxx = (P1x-P0x)*NW/W Dxy = (P1y-P0y)*NW/W Dyx = (P2x-P0x)*NH/H Dyy = (P2y-P0y)*NH/H NP0x = (P1x+P2x-Dxx -Dyx)*0.5 NP0y = (P1y+P2y-Dxy -Dyy)*0.5 NP1x = NP0x+Dxx NP1y = NP0y+Dxy NP2x = NP0x+Dyx NP2y = NP0y+Dyy NP3x = NP0x+Dxx+Dyx NP3y = NP0y+Dxy+Dyy Phil says: Parallelogram points are stored in this order: 3 <- 2 v ^ 0 -> 1 */ DocCoord p0 = Parallel[0]; DocCoord p1 = Parallel[1]; DocCoord p2 = Parallel[3]; double w = double(GetBitmap()->GetWidth()); double h = double(GetBitmap()->GetHeight()); DocCoord C = DocCoord::OneHalf( p1, p2 ); INT32 dxx = INT32(( p1.x - p0.x ) * dExWidth / w); INT32 dxy = INT32(( p1.y - p0.y ) * dExWidth / w); INT32 dyx = INT32(( p2.x - p0.x ) * dExHeight / h); INT32 dyy = INT32(( p2.y - p0.y ) * dExHeight / h); INT32 ox = INT32(( p1.x + p2.x - dxx - dyx ) * 0.5); INT32 oy = INT32(( p1.y + p2.y - dxy - dyy ) * 0.5); Parallel[0].x = ox; Parallel[0].y = oy; Parallel[1].x = ox+dxx; Parallel[1].y = oy+dxy; Parallel[3].x = ox+dyx; Parallel[3].y = oy+dyy; Parallel[2].x = ox+dxx+dyx; Parallel[2].y = oy+dxy+dyy; UpdateShape(); InvalidateBoundingRect(); } #if !defined(EXCLUDE_FROM_RALPH) //-----------------------------------------------------------------------------------------------

void NodeBitmap::SetEndColour (  DocColour *  NewCol  )  [virtual]

Set the end colour of a bitmap palette. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Definition at line 1703 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

void NodeBitmap::SetStartColour (  DocColour *  NewCol  )  [virtual]

Set the start colour of a bitmap palette. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Definition at line 1685 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

BOOL NodeBitmap::ShowingNode (   )  [virtual]

This virtual function is called whenever the node is re-shown after being Hidden. It allows the node to reconstruct itself if it was optimised or send a message to let others know it is back etc. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 11/1/94 Returns: TRUE if all was ok. FALSE if an error occured (eg Out of memory). ALWAYS CALL THE BASE CLASS' FUNCTION FROM YOUR OVERRIDDEN FUNCTION. Reimplemented from Node. Definition at line 1664 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

Node * NodeBitmap::SimpleCopy (  void   )  [virtual]

Makes a copy of all the data in the node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Returns: Pointer to a Node Reimplemented from NodeRect. Reimplemented in NodeAnimatingBitmap. Definition at line 287 of file nodebmp.cpp. { // Make a new NodeBitmap and then copy things into it NodeBitmap* NodeCopy = new NodeBitmap(); if (NodeCopy) CopyNodeContents(NodeCopy); return NodeCopy; }

BOOL NodeBitmap::SupportsClipboardFormat (  InternalClipboardFormat *  Format  )  const [virtual]

Determine if a node supports a given internal data type. This is used by the clipboard when exporting to other applications in order to determine if certain data types can be supplied. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/95 Returns: TRUE = This node supports the given format FALSE = This node does not support the format (or the format is unknown) e.g. The basic formats include: Vector - this is ALWAYS assumed to be available (Vector format includes every Node, e.g. export in Camelot .art format) Text - As well as paths, some objects can provide text chars Bitmap - Bitmap fills can render a filled object or supply the bitmap used for filling with. See InternalClipboardFormat (kernel.h) for more details Notes: TextChars can be exported as either "vector" or "text" data See also: InternalClipboardFormat; Node::SupportsClipboardFormat Reimplemented from Node. Definition at line 2325 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

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

Reimplemented from Node. Definition at line 2408 of file nodebmp.cpp. : Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

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

saves a NodeBitmap to the filter Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 14/06/96 Parameters: pFilter  - file filter to save to [INPUTS] Returns: TRUE if successful, false otherwise Reimplemented from Node. Definition at line 2397 of file nodebmp.cpp. { #ifdef DO_EXPORT ERROR2IF(pFilter==NULL, FALSE, "Parameter pFilter == NULL");

---

Member Data Documentation

BOOL NodeBitmap::ApplyContoneColour [protected]

Definition at line 232 of file nodebmp.h.

KernelBitmapRef NodeBitmap::BitmapRef

Definition at line 180 of file nodebmp.h.

DocColour NodeBitmap::Colour [protected]

Definition at line 229 of file nodebmp.h.

DocColour NodeBitmap::EndColour [protected]

Definition at line 230 of file nodebmp.h.

---

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

• Kernel/nodebmp.h (r1785/r1708)
• Kernel/nodebmp.cpp (r1785/r1771)

---