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(); // I