OpEditFill Class Reference

This operation edits an AttrLinearFill already in the tree. It is normally started when the Tool detects a drag on one of its selected blobs. More...

#include <opgrad.h>

Inheritance diagram for OpEditFill:

List of all members.

Public Member Functions
	OpEditFill ()
	Dummy Contrustor.
void	DoCreate (DocCoord &, Spread *, AttrFillGeometry *)
void	DoDrag (DocCoord &, Spread *, AttrFillGeometry *, FillControl ControlHit)
	Notes: Phil, 16-09-2005 This code relies on the attributea pplication code using DoHideNode and DoShowNode to record changes to the attributes. By recording the attributes in this way when they are first applied, the undo history contains pointers to them and the dragging code can then modify those attributes in the knowledge that the op history is now pointing at the modified attributes. It should really be changed to use OpApplyAttrInteractive. That would reduce the complexity of the following functions enormously and would be more consistent, smaller and possibly faster. There are too many different ways of "solid dragging" things and they should all: Record current tree state at start of drag Modify tree during drag Produce permanent Undo information at the end, using the same logic as would be used in the simple, parametric or outline drag case
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Recalculates the GradFill according to the new position of the corner that is being dragged, EORs it to the screen and keeps the Parallelogram up to date.
virtual void	DragPointerIdle (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Recalculates the GradFill according to the new position of the corner that is being dragged, EORs it to the screen and keeps the Parallelogram up to date.
virtual void	DragFinished (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL Success, BOOL bSolidDrag)
	If the drag was a success then a copy of the original node in the tree is created and updated GradFill built. The original NodeGradFill is hidden and the new one if inserted into the tree. If any of these things fail then the operation will fail.
virtual BOOL	DragKeyPress (KeyPress *pKeyPress, BOOL bSolidDrag)
	Allows the Fill Edit operation to respond to key presses.
virtual void	DragModeChanged (BOOL bSolidDrag)
	Find out if any of the key modifiers are being pressed when the mouse is not moving.
void	RenderDragBlobs (DocRect, Spread *, BOOL bSolidDrag)
	Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect.
BOOL	GetStatusLineText (String_256 *pText, Spread *pSpread, DocCoord DocPos, ClickModifiers ClickMods)
	Gets the status text during the editing of a fill.
AttrFillGeometry *	GetGradFill ()
Static Public Member Functions
static BOOL	Init ()
	Register this operation into the list of all operations.
static OpState	GetState (String_256 *Description, OpDescriptor *)
	Used for greying etc of an operation.
Static Public Attributes
static BOOL	InteractiveDragUpdate = TRUE
static BOOL	ContinuousEOR = TRUE
static BOOL	CreateFill = FALSE
static UINT32	IdleFillDelay = 200
Protected Member Functions
DocRect	GetDragBlobRect ()
	This function finds the bounding rect that the parallelogram of the NodeGradFill we are using for EOR renderings parallelogram fits in.
void	RedrawFills (ClickModifiers &ClickMods)
	Forces a redraw on the edited fills.
void	CheckForCompoundRedraw ()
	Check to see if the redraw needs to invalidate a compound parent. (eg. a blend).
BOOL	ApplyNewFill ()
	Applies the newly created fill to the selection.
BOOL	ApplyEditedFill ()
	Applies the edited fill, back to the editing objects.
void	SelectAllBlobs ()
	Selects all the Start or End fill blobs.
void	RenderFinalBlobs (DocRect, Spread *, BOOL bSolidDrag)
	Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect.
void	RenderSelectionFillBlobs (SelRange *, DocRect, Spread *)
	Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect.
void	RenderInitSelectionBlobs (SelRange *, DocRect, Spread *)
	Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect.
void	RenderInitBlobs (DocRect, Spread *, BOOL bSolidDrag)
	Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect.
double	FindAspectRatio ()
	Find the aspect ratio of the bitmap we are creating.
Protected Attributes
AttrFillGeometry *	GradFill
AttrFillGeometry *	FillClone
Spread *	StartSpread
FillControl	DragControl
BaseDocument *	pFillsDoc
DocRect	LastDragRect
BOOL	InvalidateAll
BOOL	InvalidateCompound
Node *	pCompound
BOOL	DragIsIdle
BOOL	DoneIdleRedraw
MonotonicTime	Time
BOOL	ShowDragBlobs
BOOL	DontDrawBlobs
BOOL	AlwaysFail
BOOL	ApplyAtEnd
BOOL	ShouldApplyNewFill
BOOL	ForceAspectLock
BOOL	IsRequired
BOOL	CheckForCompound
BOOL	CallAllowOp
FlagState	TranspState
List	AttrGroups
double	AspectRatio
DocCoord	AnchorPos
DocCoord	LastMousePosition
Private Member Functions
	CC_DECLARE_DYNCREATE (OpEditFill)

---

Detailed Description

This operation edits an AttrLinearFill already in the tree. It is normally started when the Tool detects a drag on one of its selected blobs.

Author:

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

Date:

22/7/94

Definition at line 215 of file opgrad.h.

---

Constructor & Destructor Documentation

OpEditFill::OpEditFill (   )

Dummy Contrustor. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 1/6/94 Definition at line 183 of file opgrad.cpp. { // Initialise everything AlwaysFail = TRUE; ApplyAtEnd = TRUE; ForceAspectLock = FALSE; CreateFill = FALSE; IsRequired = TRUE; ShouldApplyNewFill = FALSE; CheckForCompound = TRUE; CallAllowOp = FALSE; InvalidateAll = TRUE; InvalidateCompound = FALSE; DragIsIdle = FALSE; DoneIdleRedraw = FALSE; ShowDragBlobs = TRUE; DontDrawBlobs = FALSE; EditFinished = FALSE; AspectRatio = 1; }

---

Member Function Documentation

BOOL OpEditFill::ApplyEditedFill (   )  [protected]

Applies the edited fill, back to the editing objects. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/95 Returns: TRUE if fill was applied ok. Definition at line 1447 of file opgrad.cpp. { // Put all the fills back like they were so undo will work ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); while (pAttrPtr != NULL) { AttrFillGeometry* pAttr = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; if (pAttr != GradFill) { pAttr->SetStartPoint(FillClone->GetStartPoint()); pAttr->SetEndPoint(FillClone->GetEndPoint()); pAttr->SetEndPoint2(FillClone->GetEndPoint2()); pAttr->SetColourRamp(FillClone->GetColourRamp()); } pAttrPtr = AttrFillGeometry::HitList.GetNext(pAttrPtr); } SelRange *Selection = Camelot.FindSelection(); DocRect Bounds; if (Selection != NULL && Selection->Count()>0) Bounds = Selection->GetBoundingRect(); else Bounds = GetDragBlobRect(); // Give the attribute a bounding rect GradFill->SetBoundingRect(Bounds); BeginSlowJob(-1, FALSE); AttributeManager::SendMessages = FALSE; // Now replace all the edited attributes with the new one AttributeManager::ReplaceAttributes(GradFill, &AttrFillGeometry::HitList); AttrFillGeometry::HitList.DeleteAll(); // BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::COLOURATTCHANGED)); // BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED)); AttributeManager::SendMessages = TRUE; EndSlowJob(); return TRUE; }

BOOL OpEditFill::ApplyNewFill (   )  [protected]

Applies the newly created fill to the selection. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/95 Returns: TRUE if fill was applied ok. Definition at line 1278 of file opgrad.cpp. { ShouldApplyNewFill = FALSE; SelRange* pSel = GetApplication()->FindSelection(); Range SelRng(*pSel); // >>Webster BOOL bShowProgress = TRUE; #ifndef EXCLUDE_FROM_XARALX if (GetKeyState(CAMKEY(LBUTTON)) & 0x80) bShowProgress = FALSE; #endif // << Webster if (bShowProgress) BeginSlowJob(-1, FALSE); ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); ObjChange.SetRetainCachedData(TRUE); if (!pSel->AllowOp(&ObjChange)) { if (bShowProgress) EndSlowJob(); return FALSE; } DoStartSelOp(FALSE,FALSE, TRUE,TRUE); // Before we apply the attribute to the selection we must localise all attributes // with the same type that we are going to apply. If we don't do this then the // tree will be left in an invalid state. AttrTypeSet AttrTypes; AttrTypes.AddToSet((GradFill->GetAttributeType())); // Invalidate before if (!DoInvalidateRegions(&SelRng, GradFill, TRUE, NULL, FALSE)) //Mutators have to include bounds { if (bShowProgress) EndSlowJob(); return FALSE; } if (!DoLocaliseForAttrChange(&SelRng, &AttrTypes)) { if (bShowProgress) EndSlowJob(); return FALSE; } // Apply the new fill to the selection //GradFill->SetColourRamp ( //pAttr->SetColourRamp ((ColourRamp*) GradFill->GetFillRamp ()); ApplyToSelection(GradFill, TRUE); // Having applied the attributes, we must now try and factor out the newly // applied attributes if (!DoFactorOutAfterAttrChange(&SelRng, &AttrTypes)) { if (bShowProgress) EndSlowJob(); return FALSE; } // Invalidate after if (!DoInvalidateRegions(&SelRng, GradFill, TRUE, NULL, FALSE)) //Mutators have to include bounds { if (bShowProgress) EndSlowJob(); return FALSE; } AttrTypes.DeleteAll(); if (Document::GetSelected()) Document::GetSelected()->SetModified(TRUE); ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL,this); ObjChange.SetRetainCachedData(TRUE); // Tell TextStory not to invalidate everything in OnChildChange if (!UpdateChangedNodes(&ObjChange)) { if (bShowProgress) EndSlowJob(); return FALSE; } // Get the 'actual' fills back, so we can continue to drag them AttrFillGeometry* pFill = AttrFillGeometry::FindFirstSelectedAttr(GradFill->GetAttributeType()); // AttrFillGeometry* pFillToEdit = pFill; // Build a list of them while (pFill) { BOOL InList = FALSE; // We may have already hit this attribute if the selection is // inside a parent and have common attributes, so we need to // check and make sure this attribute is NOT in the list // already. if (!AttrFillGeometry::HitList.IsEmpty()) { ListItem* pItem = AttrFillGeometry::HitList.GetHead(); while (pItem) { NodeAttributePtrItem* NodePtr = (NodeAttributePtrItem*)pItem; if (NodePtr->NodeAttribPtr == pFill) { // Ignore this one, we've hit it already InList = TRUE; break; } pItem = AttrFillGeometry::HitList.GetNext(pItem); } } if (!InList) { // Add this to the list of fills to edit ListItem* pAttr = new NodeAttributePtrItem; if (pAttr == NULL) { if (bShowProgress) EndSlowJob(); return FALSE; } ERROR3IF(pFill->IsADefaultAttr(), "Default attr in hit list"); ((NodeAttributePtrItem*)pAttr)->NodeAttribPtr = pFill; AttrFillGeometry::HitList.AddTail(pAttr); } pFill = AttrFillGeometry::FindNextSelectedAttr(GradFill->GetAttributeType()); } if (bShowProgress) EndSlowJob(); return TRUE; }

OpEditFill::CC_DECLARE_DYNCREATE (  OpEditFill   )  [private]

void OpEditFill::CheckForCompoundRedraw (   )  [protected]

Check to see if the redraw needs to invalidate a compound parent. (eg. a blend). Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/95 Definition at line 801 of file opgrad.cpp. { CheckForCompound = FALSE; pFillsDoc = StartSpread->FindOwnerDoc(); if (AttrFillGeometry::HitList.GetCount() == GetApplication()->FindSelection()->Count() || AttrFillGeometry::HitList.GetCount() > 10) { // If we are dragging all selected fills, or if there are // more than 10 of them, then we'll just invalidate the // whole selection, 'cus it's much quicker InvalidateAll = TRUE; } else { // We will invalidate just the edited fills InvalidateAll = FALSE; } InvalidateCompound = FALSE; if (AttrFillGeometry::HitList.GetCount() == 1) { // If just one Fill is being dragged, then check to see if // it's a 'Select Inside' of a Compound object. // If it is, then we'll need to update the whole compound parent. ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); AttrFillGeometry* pGrad = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; Node* pParent = pGrad->FindParent(); if (pParent == NULL) { InvalidateAll = TRUE; return; } if (pParent->IsCompound()) { // The parent is compound, so we'll just update that InvalidateAll = TRUE; InvalidateCompound = TRUE; pCompound = pParent; } // Is the parent a blend object, or is there one // further up the tree ? while (pParent != NULL && !pParent->IsLayer()) { if (pParent->IS_KIND_OF(NodeBlend) || pParent->ShouldITransformWithChildren()) { // Found a blend, so we'll have to invalidate it // each time we want to re-draw InvalidateAll = TRUE; InvalidateCompound = TRUE; pCompound = pParent; // We will call allowop, to invalidate the blend CallAllowOp = TRUE; // Don't break out yet, 'cus we need to invalidate // the highest blend in the tree } pParent = pParent->FindParent(); } } }

void OpEditFill::DoCreate (  DocCoord &  Start, Spread *  pSpread, AttrFillGeometry *  pGrad )

Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: Start  - The starting position of the drag [INPUTS] pSpread - The spread that the drag started over pElip - The NodeGradFill that is being edited Definition at line 222 of file opgrad.cpp. { ERROR3IF(pGrad == NULL, "Fill pointer is NULL in OpEditFill::DoCreate()"); if (pGrad == NULL) { // Nothing to create !! FailAndExecute(); End(); return; } // DMc - do the attribute to change m_pAttr = (NodeAttribute *)pGrad; AlwaysFail = FALSE; // DMc - set this to TRUE ApplyAtEnd = FALSE; ForceAspectLock = TRUE; CreateFill = TRUE; // Get a description of the attribute being applied so that we can use it to create the // undo string. UndoAttribStrID = pGrad->GetAttrNameID(); AttrFillGeometry::HitList.DeleteAll(); SelRange* pSel = GetApplication()->FindSelection(); if (pSel && pSel->Count() > 0) { // Check it's ok to apply to this object ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); ObjChange.SetRetainCachedData(TRUE); // Don't let nodes releasecached data - we will handle that! if (!pSel->AllowOp(&ObjChange)) { delete pGrad; FailAndExecute(); End(); return; } } AttrFillGeometry* pFillToEdit = pGrad; // Now check to make sure someone in the selection will accept this attribute if (AttributeManager::CanBeAppliedToSelection(pGrad, &AttrGroups)) { // We're gunna apply to at least one object IsRequired = TRUE; // Flag that we need to apply the fill, either when we try // and do an interective redraw, or at the end ShouldApplyNewFill = TRUE; // Remove all the existing selection fill blobs DocRect SelBounds = pSel->GetBlobBoundingRect(); RenderInitSelectionBlobs(pSel, SelBounds, pSpread); } else { // This attribute is not required by any of the selection, // but we will continue, without actually applying anything, // and set the 'current' attribute instead IsRequired = FALSE; AttributeManager::pLastNodeAppliedTo = NULL; } // Snap the actual mouse position to the grid if needed DocView::SnapSelected(pSpread, &Start); // Initialise the Control Points pFillToEdit->SetStartPoint(&Start); pFillToEdit->SetEndPoint(&Start); pFillToEdit->SetEndPoint2(&Start); // Call the edit code DoDrag(Start, pSpread, pFillToEdit, FILLCONTROL_ENDPOINT); }

void OpEditFill::DoDrag (  DocCoord &  Start, Spread *  pSpread, AttrFillGeometry *  pGrad, FillControl  ControlHit )

Notes: Phil, 16-09-2005 This code relies on the attributea pplication code using DoHideNode and DoShowNode to record changes to the attributes. By recording the attributes in this way when they are first applied, the undo history contains pointers to them and the dragging code can then modify those attributes in the knowledge that the op history is now pointing at the modified attributes. It should really be changed to use OpApplyAttrInteractive. That would reduce the complexity of the following functions enormously and would be more consistent, smaller and possibly faster. There are too many different ways of "solid dragging" things and they should all: Record current tree state at start of drag Modify tree during drag Produce permanent Undo information at the end, using the same logic as would be used in the simple, parametric or outline drag case Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: Start  - The starting position of the drag [INPUTS] pSpread - The spread that the drag started over pElip - The NodeGradFill that is being edited Definition at line 330 of file opgrad.cpp. { ERROR3IF(ControlHit > NUMCONTROLPOINTS && !ISA_RAMPINDEX(ControlHit), "Invalid control point in OpEditFill::DoDrag()"); ERROR3IF(pGrad == NULL, "Fill pointer is NULL in OpEditFill::DoDrag()"); if (pGrad == NULL) { // Nothing to edit !! FailAndExecute(); End(); return; } // Various starting positions StartSpread = pSpread; DragControl = ControlHit; // Keep a copy of the old fill, so we can put it back later if necessary CCRuntimeClass* ObjectType = pGrad->GetRuntimeClass(); FillClone = (AttrFillGeometry*)ObjectType->CreateObject(); *FillClone = *pGrad; // and make another copy to actually edit ObjectType = pGrad->GetRuntimeClass(); GradFill = (AttrFillGeometry*)ObjectType->CreateObject(); *GradFill = *pGrad; pParentOfFill = (NodeRenderableInk*) pGrad->FindParent (); pTheFill = pGrad; if (CreateFill) delete pGrad; // Not needed any more AspectRatio = FindAspectRatio(); AnchorPos = Start; LastMousePosition = Start; DontDrawBlobs = FALSE; DragIsIdle = FALSE; DoneIdleRedraw = FALSE; // ShowDragBlobs = ContinuousEOR; ShowDragBlobs = !DocView::SolidDragging; if (!IsRequired) // Always show blobs if we're gunna ShowDragBlobs = TRUE; // set the current attribute AttrFillGeometry::DraggedFill = NULL; AttrFillGeometry::EditedFill = GradFill; // And tell the Dragging system that we need drags to happen StartDrag(DRAGTYPE_AUTOSCROLL, NULL, NULL, TRUE, TRUE); // We support solid dragging }

void OpEditFill::DragFinished (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  , BOOL  Success, BOOL  bSolidDrag )  [virtual]

If the drag was a success then a copy of the original node in the tree is created and updated GradFill built. The original NodeGradFill is hidden and the new one if inserted into the tree. If any of these things fail then the operation will fail. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which buttons and modifiers are held down pSpread - The Spread that the mouse is over now. Success - TRUE if the drag was completed sucessfully. Reimplemented from Operation. Definition at line 1014 of file opgrad.cpp. { EditFinished = TRUE; double APixel; // Flag to say if everything has worked BOOL IsOk = FALSE; // First Rub out the old Drag blobs if (!DontDrawBlobs && AttrFillGeometry::DraggedFill != NULL) { if (!(ISA_RAMPINDEX(DragControl))) { RenderDragBlobs(GradFill->GetBlobBoundingRect(), StartSpread, bSolidDrag); } else { if (ISA_RAMPINDEX (DragControl)) { GradFill->DisableBoundsRedraw (); } RenderDragBlobs(GradFill->GetBlobBoundingRect(), StartSpread, bSolidDrag); if (ISA_RAMPINDEX (DragControl)) { GradFill->EnableBoundsRedraw (); } } } DontDrawBlobs = FALSE; BOOL HaveFailed = FALSE; Document* pDoc = Document::GetSelected(); // check for a fill ramp drag if (ISA_RAMPINDEX(DragControl)) { if (Success) { if (GradFill->GetColourRamp()) { GradFill->GetColourRamp()->SortRamp(); } } } // End the Drag if (!EndDrag()) { delete FillClone; delete GradFill; goto EndOperation; } if (*GradFill->GetStartPoint() == *GradFill->GetEndPoint()) Success = FALSE; APixel = (DocView::GetSelected()->GetScaledPixelWidth()).MakeDouble(); // If the pointer has moved less than a few pixels, then just do a click if (PointerPos.Distance(AnchorPos) <= APixel*2) Success = FALSE; // If PointerPos is equal to AnchorPos, then it must have just been a click if (!Success || (PointerPos == AnchorPos)) { if (AttrFillGeometry::DraggedFill) { // We must have actually dragged a bit, // so make sure we tidy everying, and then render // the old fill blobs back on AttrFillGeometry::DraggedFill = NULL; AttrFillGeometry::EditedFill = NULL; // Failed, so put all the fills back like they were, // if we have changed them. if (!(*GradFill == *FillClone)) { *GradFill = *FillClone; ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); while (pAttrPtr != NULL) { AttrFillGeometry* pAttr = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; ERROR3IF(pAttr->IsADefaultAttr(), "Default attr in hit list"); pAttr->SetStartPoint(FillClone->GetStartPoint()); pAttr->SetEndPoint(FillClone->GetEndPoint()); pAttr->SetEndPoint2(FillClone->GetEndPoint2()); NodeRenderableInk* pParent = (NodeRenderableInk*)pAttr->FindParent(); ERROR3IF(pParent==NULL, "Can't find parent of edited attribute"); if (pParent && pAttr->IsEffectAttribute()) // IsValidEffectAttr? { // Node* pGrandParent = pParent->FindParent(); // if (pGrandParent && pGrandParent->IsBounded()) // ((NodeRenderableBounded*)pGrandParent)->ReleaseCached(TRUE, FALSE); // Parents only pParent->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and derived data only } else pParent->ReleaseCached(); pAttrPtr = AttrFillGeometry::HitList.GetNext(pAttrPtr); } // Redraw the old fills back DocRect SelBounds = GetApplication()->FindSelection()->GetBlobBoundingRect(); DocView::GetSelected()->ForceRedraw(StartSpread, SelBounds); } } else { // We didn't drag anything, so it must have just been a click if (ClickMods.Adjust && ClickMods.Constrain) { // Cntrl/Shift/Click will select all Start or End blobs SelectAllBlobs(); } // Tell the world that a fill blob has been selected BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::COLOURATTCHANGED)); } AttrFillGeometry::LastRenderedMesh = NULL; AttrFillGeometry::HitList.DeleteAll(); delete FillClone; delete GradFill; goto EndOperation; // This will fail the op } // We have edited the fill ok, so we'll draw the blobs back on AttrFillGeometry::DraggedFill = NULL; if (IsRequired) RenderFinalBlobs(GetDragBlobRect(), StartSpread, bSolidDrag); if (AlwaysFail) { // If we just edited a fill, then we don't want any undo info, // so we'll fail the op now (and discard the Actions), before we // apply the edited fill FailAndExecute(); HaveFailed = TRUE; // no need to fail at the end } // if the drag was a sucess then make a grad fill if (Success && (!GetDragBlobRect().IsEmpty())) { AttrFillGeometry::EditedFill = NULL; AttrFillGeometry::DraggedFill = NULL; if (ApplyAtEnd) { // Update all the edited fills ApplyEditedFill(); delete FillClone; delete GradFill; } else { if (ShouldApplyNewFill) { ApplyNewFill(); } BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::COLOURATTCHANGED)); BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED)); SelRange *Selection = Camelot.FindSelection(); DocRect Bounds; if (Selection != NULL && Selection->Count()>0) Bounds = Selection->GetBoundingRect(); else Bounds = GetDragBlobRect(); GradFill->SetBoundingRect(Bounds); // Ensure we update all the fills if (!AttrFillGeometry::HitList.IsEmpty()) { ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); while (pAttrPtr != NULL) { AttrFillGeometry* pAttr = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; ERROR3IF(pAttr->IsADefaultAttr(), "Default attr in hit list"); // Update the control points on the other fills pAttr->SetStartPoint(GradFill->GetStartPoint()); pAttr->SetEndPoint(GradFill->GetEndPoint()); pAttr->SetEndPoint2(GradFill->GetEndPoint2()); // Give the attribute a bounding rect pAttr->SetBoundingRect(Bounds); // We need to ensure that we force a redraw at the end of the drag // because redraws during the drag will have been done with QuickRender turned // on and so some slow objects may not have rendered themselves // fully. if (bSolidDrag) { Node* pParent = pAttr->FindParent(); if (pParent && pParent->IsBounded()) { ((NodeRenderableBounded*)pParent)->ReleaseCached(TRUE, FALSE, !pAttr->IsEffectAttribute(), TRUE); DoInvalidateNodeRegion((NodeRenderableBounded*)pParent, FALSE, TRUE, FALSE, FALSE); // Do not recache // (SelOperation::DoApply will have called ReleaseCached as needed) } } pAttrPtr = AttrFillGeometry::HitList.GetNext(pAttrPtr); } } AttributeManager& AttrMgr = pDoc->GetAttributeMgr(); if (AttrMgr.WeShouldMakeAttrCurrent(IsRequired,GradFill,&AttrGroups)) { AttributeManager::UpdateCurrentAttr(GradFill, TRUE, &AttrGroups); } delete FillClone; delete GradFill; } IsOk = TRUE; } EndOperation: // DMc - should inform all nodes at the end of a drag too AttrFillGeometry::EditedFill = NULL; AttrFillGeometry::DraggedFill = NULL; AttrFillGeometry::HitList.DeleteAll(); CreateFill = FALSE; // Don't forget the AttrGroups List AttrGroups.DeleteAll(); // If something went wrong, then fail (if we haven't already) if (!IsOk && !HaveFailed) { FailAndExecute(); } // always call end End(); }

BOOL OpEditFill::DragKeyPress (  KeyPress *  pKeyPress, BOOL  bSolidDrag )  [virtual]

Allows the Fill Edit operation to respond to key presses. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 4/5/95 Parameters: pKeyPress  - Object describing the nature of the keypress. [INPUTS] Reimplemented from Operation. Definition at line 936 of file opgrad.cpp. { if (pKeyPress->GetVirtKey() == CAMKEY(TAB) && pKeyPress->IsPress() && !pKeyPress->IsRepeat()) { // Toggle the continuous EOR flag ContinuousEOR = !ContinuousEOR; ShowDragBlobs = ContinuousEOR; String_256 DragText; ClickModifiers ClickMods; // Now update the Status line to show the mode change GetStatusLineText(&DragText, StartSpread, LastMousePosition, ClickMods); GetApplication()->UpdateStatusBarText(&DragText); return TRUE; } return FALSE; }

void OpEditFill::DragModeChanged (  BOOL  bSolidDrag  )  [virtual]

Find out if any of the key modifiers are being pressed when the mouse is not moving. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/2003 Parameters: pKeyPress  - pointer to a keypress object [INPUTS] Returns: TRUE if it handled the keypress, FALSE otherwise Reimplemented from Operation. Definition at line 974 of file opgrad.cpp. { /* DocView* pDocView = DocView::GetSelected(); BlobManager* pBlobManager = Camelot.GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); // Toggle the continuous EOR flag ContinuousEOR = !bSolidDrag; ShowDragBlobs = ContinuousEOR; String_256 DragText; ClickModifiers ClickMods; // Now update the Status line to show the mode change GetStatusLineText(&DragText, StartSpread, LastMousePosition, ClickMods); GetApplication()->UpdateStatusBarText(&DragText); */ }

void OpEditFill::DragPointerIdle (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Recalculates the GradFill according to the new position of the corner that is being dragged, EORs it to the screen and keeps the Parallelogram up to date. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which buttons and modifiers are held down pSpread - The Spread that the mouse is over now. Reimplemented from Operation. Definition at line 888 of file opgrad.cpp. { if (!DragIsIdle) { // The Mouse has just become idle, so we'll reset the timer. DragIsIdle = TRUE; DoneIdleRedraw = FALSE; Time.Sample(); } else { // Has the Mouse been idle for long enough ? if (Time.Elapsed(IdleFillDelay)) { if (DontDrawBlobs) { // If we are not redrawing the EOR blobs constantly, // then we will stick them back on when the mouse // has been idle for a while. DontDrawBlobs = FALSE; DragIsIdle = FALSE; RenderDragBlobs(LastDragRect, StartSpread, bSolidDrag); } else { // If we ARE redrawing the blobs, then we'll try and redraw // the fills when the mouse has been idle for a while. if (InteractiveDragUpdate && !DoneIdleRedraw) { RedrawFills(ClickMods); DoneIdleRedraw = TRUE; } } } } }

void OpEditFill::DragPointerMove (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Recalculates the GradFill according to the new position of the corner that is being dragged, EORs it to the screen and keeps the Parallelogram up to date. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which buttons and modifiers are held down pSpread - The Spread that the mouse is over now. Reimplemented from Operation. Definition at line 402 of file opgrad.cpp. { if (ISA_RAMPINDEX(DragControl) && !bSolidDrag) { GradFill->DisableRampRedraw(); } if (EditFinished) return; if (ForceAspectLock) ClickMods.Adjust = TRUE; DragIsIdle = FALSE; DoneIdleRedraw = FALSE; // Snap the actual mouse position to the grid if needed DocView::SnapSelected(pSpread, &PointerPos); if (AttrFillGeometry::DraggedFill == NULL) { double APixel = (DocView::GetSelected()->GetScaledPixelWidth()).MakeDouble(); // If the pointer has moved less than a few pixels, then do nothing if (PointerPos.Distance(AnchorPos) <= APixel*2) { if (!(ISA_RAMPINDEX(DragControl))) { return; } } // This is the first time the pointer has moved .... if (!CreateFill) { // If we are editing a fill, the check with it's parent // to make sure it's ok (Mould's will say 'no'). ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); AttrFillGeometry* pGrad = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; if (pGrad != NULL) { Node* pParent = pGrad->FindParent(); if (pParent != NULL) { // Check it's ok to edit this fill ObjChangeFlags cFlags; cFlags.Attribute = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); ObjChange.SetRetainCachedData(TRUE); if (!pParent->AllowOp(&ObjChange)) { // Parent said 'no', so abort the edit EndDrag(); delete FillClone; delete GradFill; FailAndExecute(); End(); return; } } } } AttrFillGeometry::EditedFill = GradFill; AttrFillGeometry::LastRenderedStartBlob = DocCoord(0,0); AttrFillGeometry::LastRenderedEndBlob = DocCoord(0,0); AttrFillGeometry::LastRenderedEnd2Blob = DocCoord(0,0); AttrFillGeometry::LastRenderedEnd3Blob = DocCoord(0,0); // First Rub out the old Fill blobs RenderInitBlobs(GradFill->GetBlobBoundingRect(), StartSpread, bSolidDrag); GradFill->SetBlobState(DragControl, TRUE); // And stop any more from being drawn for now AttrFillGeometry::DraggedFill = GradFill; LastDragRect = GradFill->GetBlobBoundingRect(); DontDrawBlobs = !ShowDragBlobs; // Now draw in the new 'Drag' blobs RenderDragBlobs(LastDragRect, StartSpread, bSolidDrag); // Update the status line to show we are dragging a fill String_256 DragText; GetStatusLineText(&DragText, pSpread, PointerPos, ClickMods); GetApplication()->UpdateStatusBarText(&DragText); } // If the mouse is in a different position then do something if (PointerPos != LastMousePosition) { // First Rub out the old Drag blobs RenderDragBlobs(LastDragRect, StartSpread, bSolidDrag); // Make sure that the coords are relative to the correct spread if (pSpread != StartSpread) PointerPos = MakeRelativeToSpread(StartSpread, pSpread, PointerPos); // Update the last mouse position and re-calc the bounding rect GradFill->OnControlDrag(PointerPos, DragControl, ClickMods); LastMousePosition = PointerPos; // If we are creating a fill, then we'll try and create it with the // correct aspect ratio if (ForceAspectLock) GradFill->SetAspectRatio(AspectRatio); LastDragRect = GradFill->GetBlobBoundingRect(); DontDrawBlobs = !ShowDragBlobs; // Render 'On' the blobs in the new position RenderDragBlobs(LastDragRect, StartSpread, bSolidDrag); if (DontDrawBlobs) RedrawFills(ClickMods); // We're in 'Solid update' mode } if (ISA_RAMPINDEX(DragControl)) { GradFill->EnableRampRedraw (); } }

double OpEditFill::FindAspectRatio (   )  [protected]

Find the aspect ratio of the bitmap we are creating. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/95 Definition at line 544 of file opgrad.cpp. { // Are we creating a Bitmap fill ? if (!GradFill->IsABitmapFill()) return 1; SelRange* pSel = GetApplication()->FindSelection(); NodeAttribute* pCommonAttr; SelRange::CommonAttribResult Result; // Find the common attr in the selection Result = pSel->FindCommonAttribute(GradFill->GetAttributeType(), &pCommonAttr); KernelBitmap* Bmp = NULL; if (Result == SelRange::ATTR_COMMON) { // There is a common attr, so if it's a Bitmap Fill, // then use that bitmaps aspect ratio AttrFillGeometry* pFill = (AttrFillGeometry*)pCommonAttr; if (pFill->IsABitmapFill()) Bmp = pFill->GetBitmap(); GradFill->AttachBitmap(Bmp); } else { // Otherwise just use the default Bmp = GradFill->GetBitmap(); } if (Bmp == NULL) return 1; BitmapInfo Info; if (Bmp->ActualBitmap && Bmp->ActualBitmap->GetInfo( &Info )) { INT32 BitmapWidth = Info.RecommendedWidth; INT32 BitmapHeight = Info.RecommendedHeight; // Calculate the aspect ratio of the bitmap return double(BitmapHeight)/double(BitmapWidth); } // Default to square return 1; }

DocRect OpEditFill::GetDragBlobRect (   )  [protected]

This function finds the bounding rect that the parallelogram of the NodeGradFill we are using for EOR renderings parallelogram fits in. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Returns: The bounding rect of the NodeGradFill parallelogram Definition at line 1536 of file opgrad.cpp. { return GradFill->GetBlobBoundingRect(); }

AttrFillGeometry* OpEditFill::GetGradFill (   )  [inline]

Definition at line 244 of file opgrad.h. { return GradFill; }

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

Used for greying etc of an operation. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: Description  - the description of the operation [INPUTS] Returns: The State of the operation Reimplemented from OpApplyAttribToSelected. Definition at line 1854 of file opgrad.cpp. { OpState Blobby; return Blobby; }

BOOL OpEditFill::GetStatusLineText (  String_256 *  pText, Spread *  pSpread, DocCoord  DocPos, ClickModifiers  ClickMods )  [virtual]

Gets the status text during the editing of a fill. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 29/1/95 Parameters: pSpread  - pioter to spread mouse is over [INPUTS] DocPos - position of mouse in doc Mods - click modifiers pText  - buffer for StatusLine text [OUTPUTS] Returns: FALSE if fails Reimplemented from Operation. Definition at line 1780 of file opgrad.cpp. { if (GradFill == NULL) { *pText=""; // We don't seem to be doing anything at the moment ! return TRUE; } pText->Load(_R(IDS_K_OPGRAD_EDITING)); String_256 FillName; if (FillName.Load(GradFill->GetAttrNameID())) { // Add the description of the attribute onto the base string *pText += FillName; if (ContinuousEOR) { *pText += String_256(_R(IDS_K_OPGRAD_IMMEDIATE)); } else { if (InteractiveDragUpdate) { *pText += String_256(_R(IDS_K_OPGRAD_BACKGROUND)); } else { *pText += String_256(_R(IDS_K_OPGRAD_NOUPDATE)); } } return TRUE; } return FALSE; }

BOOL OpEditFill::Init (  void   )  [static]

Register this operation into the list of all operations. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Returns: TRUE if it works, FALSE if not Reimplemented from OpApplyAttribToSelected. Definition at line 1830 of file opgrad.cpp. { return (RegisterOpDescriptor( 0, _R(IDS_EDITFILLOP), CC_RUNTIME_CLASS(OpEditFill), OPTOKEN_EDITFILL, OpEditFill::GetState, 0, /* help ID */ 0, 0 /* bitmap ID */)); }

void OpEditFill::RedrawFills (  ClickModifiers &  ClickMods  )  [protected]

Forces a redraw on the edited fills. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/95 Definition at line 606 of file opgrad.cpp. { if (ClickMods.Alternative1) return; // Alt key stops interactive updates // Prevent slow renderers from doing their stuff while we try to // show the results of the feather op interactively. Operation::SetQuickRender(TRUE); if (ShouldApplyNewFill) { // If we haven't applied the new fill yet, then we should // do so now. ApplyNewFill(); } if (CheckForCompound) { // If we haven't already done so, we check to see if we need // to invalidate any compound parents. CheckForCompoundRedraw(); } if (!AttrFillGeometry::HitList.IsEmpty()) { DocView* pSelView = DocView::GetSelected(); // Scan the List of Fills ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); DocRect SelBounds = GetApplication()->FindSelection()->GetBoundingRect(); while (pAttrPtr != NULL) { AttrFillGeometry* pAttr = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; ERROR3IF(pAttr->IsADefaultAttr(), "Default attr in hit list"); if (pAttr != GradFill) { if (ISA_RAMPINDEX(DragControl)) { AttrFillGeometry* CurrentFill = AttrFillGeometry::DraggedFill; AttrFillGeometry::DraggedFill = pAttr; DocRect Current = pAttr->GetBlobBoundingRect (); SelBounds = SelBounds.Union (Current); AttrFillGeometry::DraggedFill = CurrentFill; } // Update the control points on the other fills pAttr->SetStartPoint(GradFill->GetStartPoint()); pAttr->SetEndPoint(GradFill->GetEndPoint()); pAttr->SetEndPoint2(GradFill->GetEndPoint2()); pAttr->SetColourRamp(GradFill->GetColourRamp()); //pAttr->DisableRampRedraw (); pAttr->RecalcFractal(); } if (!InvalidateAll) { // Force the fills parent object to redraw NodeRenderableInk* pParent = (NodeRenderableInk*)pAttr->FindParent(); ERROR3IF(pParent==NULL, "Can't find parent of edited attribute"); if (pParent && pAttr->IsEffectAttribute()) // IsValidEffectAttr? { // Node* pGrandParent = pParent->FindParent(); // if (pGrandParent && pGrandParent->IsBounded()) // ((NodeRenderableBounded*)pGrandParent)->ReleaseCached(TRUE, FALSE); // Parents only pParent->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and derived data only } else pParent->ReleaseCached(); pSelView->ForceRedraw(StartSpread, pParent->GetBoundingRect(), FALSE, pAttr); GetApplication ()->ServiceRendering (); } pAttrPtr = AttrFillGeometry::HitList.GetNext(pAttrPtr); } if (InvalidateAll) { // Either there were too many objects to invalidate individually, // or there is a Compound Parent to invalidate if (InvalidateCompound) { pAttrPtr = AttrFillGeometry::HitList.GetHead(); AttrFillGeometry* pGrad = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; if (CallAllowOp && !pGrad->IsEffectAttribute()) { // For a blend, we need to make sure it re-blends itself, // so we need to call AllowOp on it ... ObjChangeFlags cFlags; cFlags.Attribute = TRUE; // Needed to make Blends re-calc themselves ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL, this); pGrad->AllowOp(&ObjChange); ObjChange.Define(OBJCHANGE_FINISHED,cFlags,NULL, this); UpdateAllChangedNodes(&ObjChange); } if (ISA_RAMPINDEX (DragControl)) { GradFill->DisableBoundsRedraw(); } NodeRenderableInk* pParent = (NodeRenderableInk*)pCompound; ERROR3IF(pParent==NULL, "Can't find parent of edited attribute"); if (pParent && pGrad->IsEffectAttribute()) // IsValidEffectAttr? { // Node* pGrandParent = pParent->FindParent(); // if (pGrandParent && pGrandParent->IsBounded()) // ((NodeRenderableBounded*)pGrandParent)->ReleaseCached(TRUE, FALSE); // Parents only pParent->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and derived data only } else pParent->ReleaseCached(); pSelView->ForceRedraw(StartSpread, pParent->GetBoundingRect(), FALSE, pGrad); GetApplication ()->ServiceRendering(); if (ISA_RAMPINDEX (DragControl)) { GradFill->EnableBoundsRedraw(); } } else { if (ISA_RAMPINDEX (DragControl)) { GradFill->DisableBoundsRedraw(); } // Oh sod it. Just invalidate the whole blinking lot of them, // and be done with it. //DocRect SelBounds = GetApplication()->FindSelection()->GetBoundingRect(); // Scan the List of Fills and ensure that none of them are cached... ListItem* pAttrPtr = AttrFillGeometry::HitList.GetHead(); Node* pBackMost = NULL; while (pAttrPtr != NULL) { AttrFillGeometry* pAttr = (AttrFillGeometry*)((NodeAttributePtrItem*)pAttrPtr)->NodeAttribPtr; // Force the fills parent object to redraw NodeRenderableInk* pParent = (NodeRenderableInk*)pAttr->FindParent(); ERROR3IF(pParent==NULL, "Can't find parent of edited attribute"); if (pParent && pAttr->IsEffectAttribute()) // IsValidEffectAttr? { // Node* pGrandParent = pParent->FindParent(); // if (pGrandParent && pGrandParent->IsBounded()) // ((NodeRenderableBounded*)pGrandParent)->ReleaseCached(TRUE, FALSE); // Parents only pParent->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and derived data only } else pParent->ReleaseCached(); // Work out the backmost attr if (pBackMost==NULL || pAttr->IsUnder(pBackMost)) pBackMost = pAttr; pAttrPtr = AttrFillGeometry::HitList.GetNext(pAttrPtr); } pSelView->ForceRedraw(StartSpread, SelBounds, FALSE, pBackMost); GetApplication()->ServiceRendering(); if (ISA_RAMPINDEX (DragControl)) { GradFill->EnableBoundsRedraw(); } } } } // Re-enable slow renderers Operation::SetQuickRender(FALSE); }

void OpEditFill::RenderDragBlobs (  DocRect  Rect, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 20/7/94 Parameters: Rect  - the rect that needs redrawing [INPUTS] pSpread - the spread that is being rendered Reimplemented from Operation. Definition at line 1554 of file opgrad.cpp. { if (DontDrawBlobs) return; // If being called from DocView::RenderView, then the spread could be wrong - so // convert the rectangle if necessary. if (pSpread != StartSpread) { Rect.lo = MakeRelativeToSpread(StartSpread, pSpread, Rect.lo); Rect.hi = MakeRelativeToSpread(StartSpread, pSpread, Rect.hi); } AttrFillGeometry::EditedFill = NULL; RenderRegion* pRegion = DocView::RenderOnTop(&Rect, StartSpread, UnclippedEOR); while (pRegion) { GradFill->RenderFillBlobs(pRegion); // Get the Next render region pRegion = DocView::GetNextOnTop(&Rect); } AttrFillGeometry::EditedFill = GradFill; // Bodge to stop fill meshes EOR each other out. AttrFillGeometry::LastRenderedMesh = NULL; }

void OpEditFill::RenderFinalBlobs (  DocRect  Rect, Spread *  pSpread, BOOL  bSolidDrag )  [protected]

Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 9/6/95 Parameters: Rect  - the rect that needs redrawing [INPUTS] pSpread - the spread that is being rendered Definition at line 1680 of file opgrad.cpp. { // Render the blobs 'On' RenderDragBlobs(Rect, pSpread, bSolidDrag); // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them back RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); if (ClipRect.IsIntersectedWith(Rect)) { ClipRect = ClipRect.Intersection(Rect); RenderDragBlobs(ClipRect, pSpread, bSolidDrag); } } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } }

void OpEditFill::RenderInitBlobs (  DocRect  Rect, Spread *  pSpread, BOOL  bSolidDrag )  [protected]

Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 9/6/95 Parameters: Rect  - the rect that needs redrawing [INPUTS] pSpread - the spread that is being rendered Definition at line 1729 of file opgrad.cpp. { // Now EOR off in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them back RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); if (ClipRect.IsIntersectedWith(Rect)) { ClipRect = ClipRect.Intersection(Rect); RenderDragBlobs(ClipRect, pSpread, bSolidDrag); } } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } // Render the blobs 'On' RenderDragBlobs(Rect, pSpread, bSolidDrag); }

void OpEditFill::RenderInitSelectionBlobs (  SelRange *  pSel, DocRect  Rect, Spread *  pSpread )  [protected]

Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 9/6/95 Parameters: Rect  - the rect that needs redrawing [INPUTS] pSpread - the spread that is being rendered Definition at line 1631 of file opgrad.cpp. { // EOR on in all the render regions that are still rendering, // so that the Blob rendering when the region is finished, // will put them back RenderRegionList* pRegionList = GetApplication()->GetRegionList(); if (!pRegionList->IsEmpty()) { RenderRegion* pRegion = (RenderRegion*)pRegionList->GetHead(); while (pRegion) { // Check the RenderRegion is for the same spread. if (pRegion->GetRenderSpread() == pSpread && (pRegion->IsInkRenderStarted || pRegion->NeedsOSPaper)) { // Render the blobs 'clipped' to this Render Region. DocRect ClipRect = pRegion->GetRegionRect(); if (ClipRect.IsIntersectedWith(Rect)) { ClipRect = ClipRect.Intersection(Rect); RenderSelectionFillBlobs(pSel, ClipRect, pSpread); } } // Get the Next render region pRegion = (RenderRegion*)pRegionList->GetNext(pRegion); } } // Render the blobs 'Off' RenderSelectionFillBlobs(pSel, Rect, pSpread); }

void OpEditFill::RenderSelectionFillBlobs (  SelRange *  pSel, DocRect  Rect, Spread *  pSpread )  [protected]

Renders the GradFill as it will look if the drag were to end. If we failed to create the GradFill earlier, it will draw a bounding rect. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 9/6/95 Parameters: Rect  - the rect that needs redrawing [INPUTS] pSpread - the spread that is being rendered Definition at line 1597 of file opgrad.cpp. { // Render all the selection fill blobs RenderRegion* pRegion = DocView::RenderOnTop(&Rect, pSpread, UnclippedEOR); while (pRegion) { Node* pNode = pSel->FindFirst(); while (pNode) { ((NodeRenderable*)pNode)->RenderAppliedFillBlobs(pRegion); pNode = pSel->FindNext(pNode); } // Get the Next render region pRegion = DocView::GetNextOnTop(&Rect); } AttrFillGeometry::LastRenderedMesh = NULL; }

void OpEditFill::SelectAllBlobs (   )  [protected]

Selects all the Start or End fill blobs. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/95 Definition at line 1502 of file opgrad.cpp. { // It's a 'Select all Blobs' thingy AttrFillGeometry::LastRenderedStartBlob = DocCoord(0,0); AttrFillGeometry::LastRenderedEndBlob = DocCoord(0,0); AttrFillGeometry::LastRenderedEnd2Blob = DocCoord(0,0); // Start again at the beginning AttrFillGeometry* pSelAttr = AttrFillGeometry::FindFirstSelectedAttr(FillClone->GetAttributeType()); while (pSelAttr != NULL) { if (pSelAttr) { pSelAttr->SelectBlob(DragControl); pSelAttr->DeselectAllBut(DragControl); } // Move onto the next. pSelAttr = AttrFillGeometry::FindNextSelectedAttr(FillClone->GetAttributeType()); } }

---

Member Data Documentation

BOOL OpEditFill::AlwaysFail [protected]

Definition at line 285 of file opgrad.h.

DocCoord OpEditFill::AnchorPos [protected]

Definition at line 300 of file opgrad.h.

BOOL OpEditFill::ApplyAtEnd [protected]

Definition at line 286 of file opgrad.h.

double OpEditFill::AspectRatio [protected]

Definition at line 297 of file opgrad.h.

List OpEditFill::AttrGroups [protected]

Definition at line 295 of file opgrad.h.

BOOL OpEditFill::CallAllowOp [protected]

Definition at line 291 of file opgrad.h.

BOOL OpEditFill::CheckForCompound [protected]

Definition at line 290 of file opgrad.h.

BOOL OpEditFill::ContinuousEOR = TRUE [static]

Definition at line 305 of file opgrad.h.

BOOL OpEditFill::CreateFill = FALSE [static]

Definition at line 306 of file opgrad.h.

BOOL OpEditFill::DoneIdleRedraw [protected]

Definition at line 279 of file opgrad.h.

BOOL OpEditFill::DontDrawBlobs [protected]

Definition at line 283 of file opgrad.h.

FillControl OpEditFill::DragControl [protected]

Definition at line 270 of file opgrad.h.

BOOL OpEditFill::DragIsIdle [protected]

Definition at line 278 of file opgrad.h.

AttrFillGeometry* OpEditFill::FillClone [protected]

Definition at line 268 of file opgrad.h.

BOOL OpEditFill::ForceAspectLock [protected]

Definition at line 288 of file opgrad.h.

AttrFillGeometry* OpEditFill::GradFill [protected]

Definition at line 267 of file opgrad.h.

UINT32 OpEditFill::IdleFillDelay = 200 [static]

Definition at line 308 of file opgrad.h.

BOOL OpEditFill::InteractiveDragUpdate = TRUE [static]

Definition at line 304 of file opgrad.h.

BOOL OpEditFill::InvalidateAll [protected]

Definition at line 274 of file opgrad.h.

BOOL OpEditFill::InvalidateCompound [protected]

Definition at line 275 of file opgrad.h.

BOOL OpEditFill::IsRequired [protected]

Definition at line 289 of file opgrad.h.

DocRect OpEditFill::LastDragRect [protected]

Definition at line 273 of file opgrad.h.

DocCoord OpEditFill::LastMousePosition [protected]

Definition at line 301 of file opgrad.h.

Node* OpEditFill::pCompound [protected]

Definition at line 276 of file opgrad.h.

BaseDocument* OpEditFill::pFillsDoc [protected]

Definition at line 272 of file opgrad.h.

BOOL OpEditFill::ShouldApplyNewFill [protected]

Definition at line 287 of file opgrad.h.

BOOL OpEditFill::ShowDragBlobs [protected]

Definition at line 282 of file opgrad.h.

Spread* OpEditFill::StartSpread [protected]

Definition at line 269 of file opgrad.h.

MonotonicTime OpEditFill::Time [protected]

Definition at line 280 of file opgrad.h.

FlagState OpEditFill::TranspState [protected]

Definition at line 293 of file opgrad.h.

---

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

• Kernel/opgrad.h (r1785/r1282)
• Kernel/opgrad.cpp (r1785/r1282)

---