OpGuideline Class Reference

Allows guidelines to be dragged around. More...

#include <guides.h>

Inheritance diagram for OpGuideline:

List of all members.

Public Member Functions
	OpGuideline ()
	Default constructor.
	~OpGuideline ()
	Default destructor.
virtual void	DoWithParam (OpDescriptor *pOpDesc, OpParam *pParam)
	This function is used to create a guideline in the selected spread. It calls DoAddNewGuideline() with pParam->Param1 specifying the guideline type.
virtual BOOL	DragKeyPress (KeyPress *pKeyPress, BOOL bSolidDrag)
	Responds to a keypress during the drag.
virtual void	DragPointerMove (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL bSolidDrag)
	Responds to a mouse move during a drag of a guideline.
virtual void	DragFinished (DocCoord PointerPos, ClickModifiers ClickMods, Spread *, BOOL Success, BOOL bSolidDrag)
	Responds to the drag of a guideline ending.
virtual BOOL	Undo ()
	Called when the op is undone. This broadcasts a 'Guidelines changed' layer message.
virtual BOOL	Redo ()
	Called when the op is redone. This broadcasts a 'Guidelines changed' layer message.
void	RenderMyDragBlobs ()
	Renders the blobs associated with the current drag.
void	RenderDragBlobs (DocRect Rect, Spread *pSpread, BOOL bSolidDrag)
	Main routine for rendering the blobs associated with the current drag. This can be called from anywhere, e.g. when the view scrolls.
void	GetOpName (String_256 *OpName)
	Returns a desc of the op. Mainly used to fill in the menu item for the undo/redo ops.
Static Public Member Functions
static BOOL	Init ()
	Registers an op desc for this op.
static OpState	GetState (String_256 *Description, OpDescriptor *)
	Func for determining the usability of this op.
static BOOL	IsMouseOverRuler ()
	Test to see where the mouse pointer is. It will return TRUE if the mouse is over either ruler, or the origin gadget.
Protected Member Functions
void	DoDrag (Spread *pSpread, DocCoord PointerPos)
	Starts a drag for a new or existing guideline.
void	DoAddNewGuideline (Spread *pSpread, DocCoord PointerPos, GuidelineType Type)
	Starts a drag to add a new guideline to the document.
void	DoMoveGuideline (Spread *pSpread, DocCoord PointerPos, NodeGuideline *pGuideline)
	Starts a drag to add a new guideline to the document.
BOOL	DoTranslateGuideline (NodeGuideline *pGuideline, MILLIPOINT Ordinate, NodeGuideline **ppNewGuideline=NULL)
	Translates the given guideline to line up with Ordinate, undoably.
BOOL	DoNewGuideline (Node *pContext, AttachNodeDirection AttachDir, GuidelineType Type, MILLIPOINT Ordinate, NodeGuideline **ppNewGuideline=NULL)
	Creates a new guideline to line up with Ordinate, undoably.
BOOL	DoDeleteGuideline (NodeGuideline *pGuideline, BOOL TryToLeaveCopy=FALSE)
	Deletes the given guideline, undoably.
BOOL	DoDeleteListOfGuidelines (NodeGuideline **pGuidelineList)
	Deletes the guidelines in the given list, undoably The list should be terminated by a NULL value.
Layer *	DoCreateGuideLayer ()
	This returns a ptr to the guide layer.
BOOL	CanLeaveCopy ()
	Sees if the user wants to leave a copy behind.
void	UpdateStatusLineAndPointer ()
	Makes sure the status line AND pointer are correct during a drag.
void	BroadcastGuidelineChanges (NodeGuideline *pGuideline)
	Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the parent layer of pGuideline.
void	BroadcastGuidelineChanges (Layer *pLayer)
	Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the given layer.
void	SetOrdinate (DocCoord &PointerPos)
	This does everything required in creating a layer fit to be called the guide layer Sets the Ordinate member var to either the X or the Y value of PointerPos depending on the guideline type.
Protected Attributes
UINT32	UndoIDS
Private Member Functions
	CC_DECLARE_DYNCREATE (OpGuideline)
Private Attributes
OpGuidelineOpMethod	OpMethod
Spread *	pSpread
NodeGuideline *	pDraggedGuideline
MILLIPOINT	Ordinate
GuidelineType	Type
BOOL	LeaveCopy
Cursor *	pCursor
UINT32	CurrentStatusHelp
INT32	CursorStackID
Layer *	pBroadcastLayer
BOOL	RenderOn

---

Detailed Description

Allows guidelines to be dragged around.

Author:

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

Date:

6/9/95

Definition at line 255 of file guides.h.

---

Constructor & Destructor Documentation

OpGuideline::OpGuideline (   )

Default constructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 1160 of file guides.cpp. { pDraggedGuideline = NULL; pBroadcastLayer = NULL; UndoIDS = _R(IDS_MARKN_EMPTY); LeaveCopy = FALSE; pCursor = NULL; CurrentStatusHelp = _R(IDS_MARKN_EMPTY); CursorStackID = GUIDE_CURSORID_UNSET; RenderOn = TRUE; }

OpGuideline::~OpGuideline (   )

Default destructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 1187 of file guides.cpp. { if (pCursor != NULL) delete pCursor; }

---

Member Function Documentation

void OpGuideline::BroadcastGuidelineChanges (  Layer *  pLayer  )  [protected]

Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the given layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: pLayer  = ptr to layer [INPUTS] -  [OUTPUTS] Returns: - See also: DoWithParams() Definition at line 1228 of file guides.cpp. { if (pLayer != NULL) { BROADCAST_TO_ALL(LayerMsg(pLayer,LayerMsg::GUIDELINES_CHANGED)); } pBroadcastLayer = pLayer; }

void OpGuideline::BroadcastGuidelineChanges (  NodeGuideline *  pGuideline  )  [protected]

Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the parent layer of pGuideline. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: pGuideline  = ptr to guideline [INPUTS] -  [OUTPUTS] Returns: - See also: DoWithParams() Definition at line 1208 of file guides.cpp. { if (pGuideline != NULL) BroadcastGuidelineChanges((Layer*)pGuideline->FindParent(CC_RUNTIME_CLASS(Layer))); }

BOOL OpGuideline::CanLeaveCopy (   )  [protected]

Sees if the user wants to leave a copy behind. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if user wants to leave a copy behind, FALSE otherwise TRUE is returned if the ctrl is pressed, or Numpad + has been pressed an odd number of times during the drag See also: OpGuideline::DragFinished() Definition at line 1832 of file guides.cpp. { return (LeaveCopy || KeyPress::IsConstrainPressed()); }

OpGuideline::CC_DECLARE_DYNCREATE (  OpGuideline   )  [private]

void OpGuideline::DoAddNewGuideline (  Spread *  pSpread, DocCoord  PointerPos, GuidelineType  TheType )  [protected]

Starts a drag to add a new guideline to the document. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: pThisSpread  = ptr to spread drag started in [INPUTS] PointerPos = coord of point clicked TheType = The type of guideline -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 1377 of file guides.cpp. { Type = TheType; DoDrag(pSpread,PointerPos); }

Layer * OpGuideline::DoCreateGuideLayer (   )  [protected]

This returns a ptr to the guide layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Ptr to the guide layer, or NULL one couldn't be created. If the guide layer already exists, a ptr to it is returned. If there isn't a guide layer, it is created and inserted into the doc tree. If this fails the func returns NULL See also: OpGuideline::DoNewGuideline() Definition at line 1887 of file guides.cpp. { Layer* pLayer = pSpread->FindFirstGuideLayer(); if (pLayer != NULL) return pLayer; Layer* pNewLayer = Layer::CreateGuideLayer(); if (pNewLayer != NULL) { // If we insert the new layer as the FIRSTCHILD then this will be behind the page. // If we insert as the last child then we will be at the front of // the stacking order. We need to insert ourselves as the node after the last page node // This used to take this approach before 4/4/97. // Page *pLastPage = pSpread->FindLastPageInSpread(); Layer *pLastLayer = pSpread->FindLastLayer(); // If there is the sepcial background layer present then ensure that we insert after that // Layer * pLayer = pSpread->FindFirstPageBackgroundLayer(); // Node * pInsertionPoint = pLastPage; Node * pInsertionPoint = pLastLayer; // if (pLayer) // pInsertionPoint = pLayer; // Insert the new layer as the next node after the last page. if (pLastLayer && DoInsertNewNode(pNewLayer,pInsertionPoint,NEXT,FALSE,FALSE,FALSE,FALSE)) { pNewLayer->EnsureUniqueLayerID(); BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES)); } else { delete pNewLayer; pNewLayer = NULL; } } return pNewLayer; }

BOOL OpGuideline::DoDeleteGuideline (  NodeGuideline *  pGuideline, BOOL  TryToLeaveCopy = FALSE )  [protected]

Deletes the given guideline, undoably. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pGuideline  = ptr to an existing guideline [INPUTS] TryToLeaveCopy = TRUE to try and leave copy, FALSE means force delete -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: OpGuideline::DragFinished() Definition at line 1788 of file guides.cpp. { BOOL ok = TRUE; if (TryToLeaveCopy && CanLeaveCopy()) { // User is trying to copy the guideline, so just set up the correct undo string UndoIDS = _R(IDS_OPCOPYGUIDELINE); } else { ERROR2IF(pGuideline == NULL,FALSE,"pGuideline is NULL"); pSpread = pGuideline->FindParentSpread(); ERROR2IF_PF(pSpread == NULL,FALSE,("pGuideline (0x%x) has no parent spread",pGuideline)); DocRect Rect = pGuideline->GetRenderRect(FALSE); if (ok) ok = DoInvalidateRegion(pSpread,Rect); if (ok) ok = DoHideNode(pGuideline,TRUE); } return ok; }

BOOL OpGuideline::DoDeleteListOfGuidelines (  NodeGuideline **  pGuidelineList  )  [protected]

Deletes the guidelines in the given list, undoably The list should be terminated by a NULL value. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pGuidelineList  = ptr to a list of existing guidelines [INPUTS] -  [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: OpGuideline::DragFinished() Definition at line 1852 of file guides.cpp. { ERROR2IF(pGuidelineList == NULL,FALSE,"pGuidelineList is NULL"); BOOL ok= TRUE; while (*pGuidelineList != NULL && ok) { ok = DoDeleteGuideline(*pGuidelineList); pGuidelineList++; } return ok; }

void OpGuideline::DoDrag (  Spread *  pThisSpread, DocCoord  PointerPos )  [protected]

Starts a drag for a new or existing guideline. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: pThisSpread  = ptr to spread drag started in (NULL means get selected spread) [INPUTS] PointerPos = coord of point clicked -  [OUTPUTS] Returns: - See also: DoMoveGuideline(), DoAddNewGuideline() Definition at line 1424 of file guides.cpp. { pSpread = pThisSpread; if (pSpread == NULL) pSpread = Document::GetSelectedSpread(); ERROR3IF(pSpread == NULL,"pSpread == NULL"); if (pSpread == NULL) { End(); return; } SetOrdinate(PointerPos); RenderMyDragBlobs(); LeaveCopy = KeyPress::IsKeyPressed(CAMKEY(ADD)); if (pCursor == NULL) { ToolListItem* pItem = Tool::Find(TOOLID_SELECTOR); if (pItem != NULL) { Tool* pTool = pItem->m_pTool; if (pTool != NULL) { if (Type == GUIDELINE_HORZ) pCursor = new Cursor(pTool,_R(IDCSR_SEL_HGUIDE)); else pCursor = new Cursor(pTool,_R(IDCSR_SEL_VGUIDE)); if (pCursor != NULL) CursorStackID = CursorStack::GPush(pCursor); } } } UpdateStatusLineAndPointer(); // Tell the Dragging system that we need drags to happen StartDrag( DRAGTYPE_DEFERSCROLL ); }

void OpGuideline::DoMoveGuideline (  Spread *  pSpread, DocCoord  PointerPos, NodeGuideline *  pGuideline )  [protected]

Starts a drag to add a new guideline to the document. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: pThisSpread  = ptr to spread drag started in [INPUTS] PointerPos = coord of point clicked pGuideline = the guideline to move -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 1400 of file guides.cpp. { pDraggedGuideline = pGuideline; Type = pDraggedGuideline->GetType(); DoDrag(pSpread,PointerPos); }

BOOL OpGuideline::DoNewGuideline (  Node *  pContext, AttachNodeDirection  AttachDir, GuidelineType  Type, MILLIPOINT  Ordinate, NodeGuideline **  ppNewGuideline = NULL )  [protected]

Creates a new guideline to line up with Ordinate, undoably. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pContext  = ptr to context node (Can be NULL) [INPUTS] AttachDir = how the new guideline should be attached to the context node Type = type of guideline to create Ordinate = position of new guideline ppNewGuideline = place to put ptr of new guideline (Can be NULL) *ppNewGuideline  = ptr to new guideline (NULL if function fails) [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: OpGuideline::DragFinished() Definition at line 1736 of file guides.cpp. { if (pContext == NULL) { pContext = DoCreateGuideLayer(); AttachDir = LASTCHILD; } ERROR2IF(pContext == NULL,FALSE,"pContext is NULL"); BOOL ok = TRUE; NodeGuideline* pNewGuideline = new NodeGuideline; ok = (pNewGuideline != NULL); if (ok) { pNewGuideline->SetType(Type); pNewGuideline->SetOrdinate(Ordinate); DocRect Rect = pNewGuideline->GetRenderRect(FALSE); if (ok) ok = DoInsertNewNode(pNewGuideline,pContext,AttachDir,FALSE,FALSE,FALSE,FALSE); if (ok) ok = DoInvalidateRegion(pSpread,Rect); } if (!ok && pNewGuideline != NULL) { delete pNewGuideline; pNewGuideline = NULL; } if (ppNewGuideline != NULL) *ppNewGuideline = pNewGuideline; return ok; }

BOOL OpGuideline::DoTranslateGuideline (  NodeGuideline *  pGuideline, MILLIPOINT  Ordinate, NodeGuideline **  ppNewGuideline = NULL )  [protected]

Translates the given guideline to line up with Ordinate, undoably. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pGuideline  = ptr to an existing guideline [INPUTS] Ordinate = Absolute position to translate to ppNewGuideline = place to put ptr of translated guideline (Can be NULL) *ppNewGuideline  = ptr to translated guideline (NULL if function fails) [OUTPUTS] Returns: TRUE if successful, FALSE otherwise See also: OpGuideline::DragFinished() Definition at line 1702 of file guides.cpp. { ERROR2IF(pGuideline == NULL,FALSE,"pGuideline is NULL"); Type = pGuideline->GetType(); BOOL ok = TRUE; if (ok) ok = DoNewGuideline(pGuideline,NEXT,Type,Ordinate,ppNewGuideline); if (ok) ok = DoDeleteGuideline(pGuideline,TRUE); return ok; }

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

This function is used to create a guideline in the selected spread. It calls DoAddNewGuideline() with pParam->Param1 specifying the guideline type. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/95 Parameters: pOpDesc  = ptr op desc [INPUTS] pOpParam = param block to use -  [OUTPUTS] Returns: - See also: DoAddNewGuideline(), OilRuler::OnLButtonDown() Reimplemented from Operation. Definition at line 1254 of file guides.cpp. { ERROR3IF(pParam == NULL,"pParam is NULL"); if (pParam != NULL) { OpGuidelineParam* pGuidelineParam = (OpGuidelineParam*)pParam; NodeGuideline* pGuideline = pGuidelineParam->pGuideline; OpMethod = pGuidelineParam->Method; switch (OpMethod) { //----------------------------------- case GUIDELINEOPMETHOD_MOVE_DRAG: { ERROR3IF(pGuideline == NULL,"pGuideline is NULL"); if (pGuideline != NULL) { DocCoord PointerPos(pGuideline->GetOrdinate(),pGuideline->GetOrdinate()); DoMoveGuideline(NULL,PointerPos,pGuideline); } } UndoIDS = _R(IDS_OPMOVEGUIDELINE); break; //----------------------------------- case GUIDELINEOPMETHOD_MOVE_IMMEDIATE: { ERROR3IF(pGuideline == NULL,"pGuideline is NULL"); pSpread = Document::GetSelectedSpread(); if (pGuideline != NULL && !DoTranslateGuideline(pGuideline,pGuidelineParam->NewOrdinate)) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); End(); } UndoIDS = _R(IDS_OPMOVEGUIDELINE); break; //----------------------------------- case GUIDELINEOPMETHOD_NEW_DRAG: { DocCoord PointerPos(-5000,-5000); DoAddNewGuideline(NULL,PointerPos,pGuidelineParam->Type); } UndoIDS = _R(IDS_OPNEWGUIDELINE); break; //----------------------------------- case GUIDELINEOPMETHOD_NEW_IMMEDIATE: { pSpread = Document::GetSelectedSpread(); if (!DoNewGuideline(NULL,NEXT,pGuidelineParam->Type,pGuidelineParam->NewOrdinate)) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); End(); } UndoIDS = _R(IDS_OPNEWGUIDELINE); break; //----------------------------------- case GUIDELINEOPMETHOD_CREATE_GUIDE_LAYER: { pSpread = Document::GetSelectedSpread(); Layer* pGuideLayer = DoCreateGuideLayer(); if (pGuideLayer == NULL) FailAndExecute(); else BroadcastGuidelineChanges(pGuideLayer); End(); } UndoIDS = _R(IDS_OPCREATEGUIDELAYER); break; //----------------------------------- case GUIDELINEOPMETHOD_DELETE: { pSpread = Document::GetSelectedSpread(); if (!DoDeleteListOfGuidelines(pGuidelineParam->pGuidelineList)) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); End(); } UndoIDS = _R(IDS_OPDELETESELECTEDGUIDELINES); // ********* NEW RESOURCE STRING!!!!!! break; //----------------------------------- default: ERROR3_PF(("Unknown OpGuideline method : %d",pGuidelineParam->Method)); break; } } }

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

Responds to the drag of a guideline ending. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: PointerPos  = coord of the pointer [INPUTS] ClickMods = info on the click modifiers pSpread = ptr to spread (not used) Success = TRUE if drag ended successfully, FALSE if drag terminated (usu. by pressing Escape) -  [OUTPUTS] Returns: - See also: UndoableOperation Reimplemented from Operation. Definition at line 1520 of file guides.cpp. { // First Rub out the old boxes RenderMyDragBlobs(); if (Success) { DocView::SnapCurrent(pSpread,&PointerPos); SetOrdinate(PointerPos); if (pDraggedGuideline != NULL) { if (IsMouseOverRuler()) { UndoIDS = _R(IDS_OPDELETEGUIDELINE); Success = DoDeleteGuideline(pDraggedGuideline); } else Success = DoTranslateGuideline(pDraggedGuideline,Ordinate); } else Success = !IsMouseOverRuler() && DoNewGuideline(NULL,NEXT,Type,Ordinate); } // End the Drag EndDrag(); // Restore cursor if (CursorStackID != GUIDE_CURSORID_UNSET) { CursorStack::GPop(CursorStackID); CursorStackID = GUIDE_CURSORID_UNSET; } if (pCursor != NULL) { delete pCursor; pCursor = NULL; } if (!Success) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); // End the op End(); }

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

Responds to a keypress during the drag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: pKeyPress  = ptr to keypress object [INPUTS] -  [OUTPUTS] Returns: - See also: DragFinished Reimplemented from Operation. Definition at line 1635 of file guides.cpp. { BOOL Processed = FALSE; switch (pKeyPress->GetVirtKey()) { case CAMKEY(ADD): if (!pKeyPress->IsModified() && pKeyPress->IsPress() && !pKeyPress->IsRepeat()) { LeaveCopy = !LeaveCopy; UpdateStatusLineAndPointer(); Processed = TRUE; } break; case CAMKEY(CONTROL): UpdateStatusLineAndPointer(); Processed = TRUE; break; } return Processed; }

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

Responds to a mouse move during a drag of a guideline. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: PointerPos  = coord of the pointer [INPUTS] ClickMods = info on the click modifiers pSpread = ptr to spread -  [OUTPUTS] Returns: - See also: UndoableOperation Reimplemented from Operation. Definition at line 1487 of file guides.cpp. { // First Rub out the old box RenderMyDragBlobs(); DocView::SnapCurrent(pSpread,&PointerPos); SetOrdinate(PointerPos); // Render the new drag box RenderMyDragBlobs(); UpdateStatusLineAndPointer(); }

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

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

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

Func for determining the usability of this op. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: Description  = ptr to place description of why this op can't happen [INPUTS] pOpDesc = ptr to the Op Desc associated with this op -  [OUTPUTS] Returns: An OpState object See also: - Reimplemented in OpDeleteGuideline, OpDeleteAllGuidelines, and OpNewGuideline. Definition at line 2199 of file guides.cpp. { OpState State; return State; }

BOOL OpGuideline::Init (  void   )  [static]

Registers an op desc for this op. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if op successfully declared, FALSE otherwise See also: - Reimplemented from SimpleCCObject. Reimplemented in OpNewGuideline. Definition at line 2140 of file guides.cpp. { return (GuidelinePropDlg::Init() && OpNewGuideline::Init() && OpSpreadOrigin::Init() && OpResetSpreadOrigin::Init() && #ifndef STANDALONE OpChangeLayerColour::Init() && #endif RegisterOpDescriptor( 0, 0, CC_RUNTIME_CLASS(OpGuideline), OPTOKEN_GUIDELINE , OpGuideline::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ) && RegisterOpDescriptor( 0, _R(IDS_DELETEALLGUIDELINES), CC_RUNTIME_CLASS(OpDeleteAllGuidelines), OPTOKEN_DELETEALLGUIDELINES , OpDeleteAllGuidelines::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ) && RegisterOpDescriptor( 0, _R(IDS_DELETEGUIDELINE), CC_RUNTIME_CLASS(OpDeleteGuideline), OPTOKEN_DELETEGUIDELINE , OpDeleteGuideline::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ) ); }

BOOL OpGuideline::IsMouseOverRuler (   )  [static]

Test to see where the mouse pointer is. It will return TRUE if the mouse is over either ruler, or the origin gadget. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if mouse is over a ruler, FALSE otherwise See also: OpGuideline::DragFinished() Definition at line 1673 of file guides.cpp. { DocView* pDocView = DocView::GetSelected(); if (pDocView != NULL) { CCamView* pCCamView = pDocView->GetConnectionToOilView(); return (pCCamView->IsMouseOverRuler() != OVER_NO_RULERS); } return FALSE; }

BOOL OpGuideline::Redo (   )  [virtual]

Called when the op is redone. This broadcasts a 'Guidelines changed' layer message. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successfull, FALSE otherwise See also: - Reimplemented from Operation. Definition at line 2115 of file guides.cpp. { if (UndoableOperation::Redo()) { BroadcastGuidelineChanges(pBroadcastLayer); return TRUE; } return FALSE; }

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

Main routine for rendering the blobs associated with the current drag. This can be called from anywhere, e.g. when the view scrolls. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: Rect  = region of doc being updated (NOT USED!) [INPUTS] pSpread = ptr to the spread being redrawn -  [OUTPUTS] Returns: - See also: - Reimplemented from Operation. Definition at line 2030 of file guides.cpp. { static DocRect RenderRect; RenderRegion* pRender = DocView::RenderOnTop( NULL, pSpread, UnclippedEOR ); while (pRender != NULL) { // Set line colour for dashed line pRender->SetLineColour(COLOUR_BLACK); DocCoord StartPoint(Ordinate,Ordinate); DocCoord EndPoint(Ordinate,Ordinate); if (RenderOn) { View* pView = pRender->GetRenderView(); if (pView != NULL) { RenderRect = pView->GetDocViewRect(pSpread); RenderRect = RenderRect.ToSpread(pSpread,pView); } RenderRect.Inflate(pRender->GetScaledPixelWidth()); } if (Type == GUIDELINE_HORZ) { StartPoint.x = RenderRect.lo.x; EndPoint.x = RenderRect.hi.x; } else { StartPoint.y = RenderRect.lo.y; EndPoint.y = RenderRect.hi.y; } pRender->DrawDashLine(StartPoint,EndPoint); // Get the Next render region pRender = DocView::GetNextOnTop(NULL); } }

void OpGuideline::RenderMyDragBlobs (   )

Renders the blobs associated with the current drag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: RenderDragBlobs() Definition at line 2007 of file guides.cpp. { DocRect Rect; RenderDragBlobs(Rect,pSpread, FALSE); RenderOn = !RenderOn; }

void OpGuideline::SetOrdinate (  DocCoord &  PointerPos  )  [protected]

This does everything required in creating a layer fit to be called the guide layer Sets the Ordinate member var to either the X or the Y value of PointerPos depending on the guideline type. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: PointerPos  = pos of mouse pointer [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 1985 of file guides.cpp. { if (Type == GUIDELINE_HORZ) Ordinate = PointerPos.y; else Ordinate = PointerPos.x; }

BOOL OpGuideline::Undo (   )  [virtual]

Called when the op is undone. This broadcasts a 'Guidelines changed' layer message. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successfull, FALSE otherwise See also: - Reimplemented from Operation. Definition at line 2089 of file guides.cpp. { if (UndoableOperation::Undo()) { BroadcastGuidelineChanges(pBroadcastLayer); return TRUE; } return FALSE; }

void OpGuideline::UpdateStatusLineAndPointer (   )  [protected]

Makes sure the status line AND pointer are correct during a drag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: UndoableOperation Definition at line 1582 of file guides.cpp. { // if (pCursor != NULL && CursorStackID != GUIDE_CURSORID_UNSET) // CursorStack::GSetTop(pCursor,CursorStackID); // Which status help should we display? UINT32 IDS = _R(IDS_DRAGDELETEGUIDE); if (!IsMouseOverRuler()) { if (CanLeaveCopy()) { if (Type == GUIDELINE_HORZ) IDS = _R(IDS_DRAGCOPYHORZGUIDE); else IDS = _R(IDS_DRAGCOPYVERTGUIDE); } else { if (Type == GUIDELINE_HORZ) IDS = _R(IDS_SELHORZGUIDE); else IDS = _R(IDS_SELVERTGUIDE); } } if (IDS != CurrentStatusHelp) { // put up some status line help CurrentStatusHelp = IDS; String_256 Str(IDS); StatusLine* pStatusLine=GetApplication()->GetpStatusLine(); if (pStatusLine!=NULL) pStatusLine->UpdateText(&Str,STATUSLINE_SELDESC_STATBAR); } }

---

Member Data Documentation

UINT32 OpGuideline::CurrentStatusHelp [private]

Definition at line 325 of file guides.h.

INT32 OpGuideline::CursorStackID [private]

Definition at line 326 of file guides.h.

BOOL OpGuideline::LeaveCopy [private]

Definition at line 323 of file guides.h.

OpGuidelineOpMethod OpGuideline::OpMethod [private]

Definition at line 316 of file guides.h.

MILLIPOINT OpGuideline::Ordinate [private]

Definition at line 321 of file guides.h.

Layer* OpGuideline::pBroadcastLayer [private]

Definition at line 329 of file guides.h.

Cursor* OpGuideline::pCursor [private]

Definition at line 324 of file guides.h.

NodeGuideline* OpGuideline::pDraggedGuideline [private]

Definition at line 320 of file guides.h.

Spread* OpGuideline::pSpread [private]

Definition at line 319 of file guides.h.

BOOL OpGuideline::RenderOn [private]

Definition at line 331 of file guides.h.

GuidelineType OpGuideline::Type [private]

Definition at line 322 of file guides.h.

UINT32 OpGuideline::UndoIDS [protected]

Definition at line 335 of file guides.h.

---

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

• Kernel/guides.h (r1785/r1282)
• Kernel/guides.cpp (r1785/r1315)

---