// $Id: guides.cpp 1315 2006-06-14 09:51:34Z alex $ /* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE ================================XARAHEADERSTART=========================== Xara LX, a vector drawing and manipulation program. Copyright (C) 1993-2006 Xara Group Ltd. Copyright on certain contributions may be held in joint with their respective authors. See AUTHORS file for details. LICENSE TO USE AND MODIFY SOFTWARE ---------------------------------- This file is part of Xara LX. Xara LX is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation. Xara LX and its component source files are distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Xara LX (see the file GPL in the root directory of the distribution); if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA ADDITIONAL RIGHTS ----------------- Conditional upon your continuing compliance with the GNU General Public License described above, Xara Group Ltd grants to you certain additional rights. The additional rights are to use, modify, and distribute the software together with the wxWidgets library, the wxXtra library, and the "CDraw" library and any other such library that any version of Xara LX relased by Xara Group Ltd requires in order to compile and execute, including the static linking of that library to XaraLX. In the case of the "CDraw" library, you may satisfy obligation under the GNU General Public License to provide source code by providing a binary copy of the library concerned and a copy of the license accompanying it. Nothing in this section restricts any of the rights you have under the GNU General Public License. SCOPE OF LICENSE ---------------- This license applies to this program (XaraLX) and its constituent source files only, and does not necessarily apply to other Xara products which may in part share the same code base, and are subject to their own licensing terms. This license does not apply to files in the wxXtra directory, which are built into a separate library, and are subject to the wxWindows license contained within that directory in the file "WXXTRA-LICENSE". This license does not apply to the binary libraries (if any) within the "libs" directory, which are subject to a separate license contained within that directory in the file "LIBS-LICENSE". ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS ---------------------------------------------- Subject to the terms of the GNU Public License (see above), you are free to do whatever you like with your modifications. However, you may (at your option) wish contribute them to Xara's source tree. You can find details of how to do this at: http://www.xaraxtreme.org/developers/ Prior to contributing your modifications, you will need to complete our contributor agreement. This can be found at: http://www.xaraxtreme.org/developers/contribute/ Please note that Xara will not accept modifications which modify any of the text between the start and end of this header (marked XARAHEADERSTART and XARAHEADEREND). MARKS ----- Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara designs are registered or unregistered trademarks, design-marks, and/or service marks of Xara Group Ltd. All rights in these marks are reserved. Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK. http://www.xara.com/ =================================XARAHEADEREND============================ */ // NodeGuideline implementation /* */ #include "camtypes.h" // WEBSTER - markn 14/1/97 // Removed all code not needed in Webster // This is the same as the code removed from RALPH #ifdef WEBSTER #define EXCLUDE_FROM_RALPH #endif #include "guides.h" #include "snap.h" //#include "stockcol.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "rndrgn.h" //#include "attr.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "view.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "layer.h" #include "sprdmsg.h" //#include "document.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "qualattr.h" #include "camview.h" //#include "markn.h" //#include "ed.h" //#include "tim.h" #include "contmenu.h" //#include "lyrprop.h" //#include "resource.h" #include "usercord.h" #include "layermsg.h" //#include "scrcamvw.h" //#include "grndrgn.h" //#include "osrndrgn.h" //#include "cameleps.h" #include "saveeps.h" #include "nativeps.h" // The old style EPS native filter, used in v1.1 #include "keypress.h" #include "prpsgds.h" #include "snapops.h" //#include "viewrc.h" #include "csrstack.h" //#include "justin.h" //#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "statline.h" #include "toollist.h" //#include "cxfrec.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "cxfrech.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "cxftags.h" //#include "cxfdefs.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "camfiltr.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "page.h" #if !defined(EXCLUDE_FROM_RALPH) #include "optsgrid.h" #include "statline.h" #endif static MILLIPOINT abs_milli(MILLIPOINT n) { if (n<0) return (0-n); else return (n);} #define Swap(a,b) { (a)^=(b), (b)^=(a), (a)^=(b); } #define MAX_INT (0x01000000) #define MIN_INT (0xf0000000) #define GUIDE_CURSORID_UNSET -1 CC_IMPLEMENT_DYNAMIC(NodeGuideline, NodeRenderableInk) #if !defined(EXCLUDE_FROM_RALPH) CC_IMPLEMENT_DYNCREATE(OpGuideline, UndoableOperation) CC_IMPLEMENT_DYNCREATE(OpSpreadOrigin, UndoableOperation) CC_IMPLEMENT_DYNCREATE(GuidelinePropDlg, DialogOp) CC_IMPLEMENT_MEMDUMP(OpGuidelineParam, OpParam) CC_IMPLEMENT_DYNAMIC(LayerMsg, Msg) CC_IMPLEMENT_DYNCREATE(OpDeleteGuideline, OpGuideline) CC_IMPLEMENT_DYNCREATE(OpNewGuideline, OpGuideline) CC_IMPLEMENT_DYNCREATE(OpDeleteAllGuidelines, OpGuideline) CC_IMPLEMENT_DYNCREATE(OpResetSpreadOrigin, OpSpreadOrigin) #else CC_IMPLEMENT_DYNAMIC(LayerMsg, Msg) #endif // Declare smart memory handling in Debug builds #define new CAM_DEBUG_NEW #if !defined(EXCLUDE_FROM_RALPH) //------------------------------------- NodeGuideline* OpDeleteGuideline::pGuideline = NULL; OpGuidelineParam OpNewGuideline::NewGuidelineParam; //------------------------------------- const CDlgMode GuidelinePropDlg::Mode = MODAL; const INT32 GuidelinePropDlg::IDD = _R(IDD_GUIDELINE_PROPERTIES); GuidelinePropDlgParams GuidelinePropDlg::Params; //------------------------------------- #endif // WEBSTER - markn 14/1/97 // Helper func for NodeGuideline::Render() - still in it's experimental stage #ifndef WEBSTER static void PullOntoStep(INT32* pMin,INT32* pMax,INT32 Dist) { if (Dist != 0) { *pMin -= *pMin % Dist; *pMax += Dist-(*pMax % Dist); } } #endif // WEBSTER /********************************************************************************************* > NodeGuideline::NodeGuideline() Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: - Outputs: Returns: - Purpose: This constructor creates a NodeGuideline linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles. Errors: **********************************************************************************************/ NodeGuideline::NodeGuideline(): NodeRenderableInk() { // WEBSTER - markn 14/1/97 #ifndef WEBSTER Type = GUIDELINE_HORZ; Ordinate = 72000*9; #endif // WEBSTER } /*********************************************************************************************** > Node* NodeGuideline::SimpleCopy() // Private method Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: - Outputs: - Returns: A copy of the node, or NULL if memory runs out Purpose: This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected **********************************************************************************************/ Node* NodeGuideline::SimpleCopy() { // WEBSTER - markn 14/1/97 #ifndef WEBSTER NodeGuideline* NodeCopy = new NodeGuideline(); if (NodeCopy != NULL) CopyNodeContents(NodeCopy); return (NodeCopy); #else return NULL; #endif // WEBSTER } /*********************************************************************************************** > void NodeGuideline::CopyNodeContents(NodeGuideline* NodeCopy) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: - Outputs: A copy of this node Returns: - Purpose: This method copies the node's contents to the node pointed to by NodeCopy. Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected ***********************************************************************************************/ void NodeGuideline::CopyNodeContents(NodeGuideline* NodeCopy) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER ENSURE(NodeCopy != NULL,"Trying to copy a NodeGuideline's contents to a NULL node"); NodeRenderableInk::CopyNodeContents(NodeCopy); NodeCopy->Type = this->Type; NodeCopy->Ordinate = this->Ordinate; #endif // WEBSTER } /*********************************************************************************************** > void NodeGuideline::PolyCopyNodeContents(NodeRenderable* pNodeCopy) Author: Phil_Martin (Xara Group Ltd) Created: 18/12/2003 Outputs: - Purpose: Polymorphically copies the contents of this node to another Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected ***********************************************************************************************/ void NodeGuideline::PolyCopyNodeContents(NodeRenderable* pNodeCopy) { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeGuideline), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeGuideline)) CopyNodeContents((NodeGuideline*)pNodeCopy); } /******************************************************************************************** > void* NodeGuideline::GetDebugDetails(StringBase* Str) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: - Outputs: Str: String giving debug info about the node Returns: - Purpose: For obtaining debug information about the Node Errors: - SeeAlso: - ********************************************************************************************/ void NodeGuideline::GetDebugDetails(StringBase* Str) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER NodeRenderableInk::GetDebugDetails(Str); #endif // WEBSTER } /******************************************************************************************** > virtual String Describe(BOOL Plural, BOOL Verbose = TRUE) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: Plural: Flag indicating if the string description should be plural or singular. Outputs: - Retuns: Description of the object Purpose: To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method. The description will always begin with a lower case letter. Errors: A resource exception will be thrown if a problem occurs when loading the string resource. SeeAlso: - ********************************************************************************************/ /* Technical Notes: The String resource identifiers should be of the form: ID__DescriptionS for the singular description and ID__DescriptionP for the plural. */ String NodeGuideline::Describe(BOOL /*Plural*/, BOOL /*Verbose*/) { // ENSURE (FALSE,"The illegal function NodeGuideline::Describe was called\n"); return( _T("") ); // Just to keep the compiler happy }; /*********************************************************************************************** > static MILLIPOINT NodeGuideline::GetScaledPixelWidth(RenderRegion* pRender) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: pRender: Render region to render into (can be NULL) Outputs: - Returns: - Purpose: Gets the scaled pixel width. if pRender != NULL, the render view associated with it is used, otherwise the selected doc view is used. It uses the all View::GetScaledPixelSize() function. ***********************************************************************************************/ MILLIPOINT NodeGuideline::GetScaledPixelWidth(RenderRegion* pRender) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER MILLIPOINT Width = 0; View* pView = NULL; if (pRender != NULL) pView = pRender->GetRenderView(); else pView = DocView::GetCurrent(); if (pView != NULL) { // Get the scaled pixel size for the view FIXED16 ScaledPixelWidth, ScaledPixelHeight; // Not used pView->GetScaledPixelSize(&ScaledPixelWidth, &ScaledPixelHeight); Width = (MILLIPOINT)ScaledPixelWidth.MakeLong(); } return Width; #else return 0; #endif // WEBSTER return 0; } /*********************************************************************************************** > virtual void NodeGuideline::Transform( TransformBase& Trans ) Author: Mark_Neves (Xara Group Ltd) Created: 11/10/95 Inputs: Trans = the transformation to apply Outputs: - Returns: - Purpose: Transforms the guideline using Trans ***********************************************************************************************/ void NodeGuideline::Transform( TransformBase& Trans ) { #if !defined(EXCLUDE_FROM_RALPH) DocCoord Coord(Ordinate,Ordinate); Trans.Transform(&Coord,1); if (Type == GUIDELINE_HORZ) Ordinate = Coord.y; else Ordinate = Coord.x; #endif } /*********************************************************************************************** > virtual void NodeGuideline::PreExportRender(RenderRegion* pRegion) Author: Mark_Neves (Xara Group Ltd) Created: 11/10/95 Inputs: pRegion = the render region to export to Outputs: - Returns: - Purpose: Called before any child nodes are asked to export ***********************************************************************************************/ void NodeGuideline::PreExportRender(RenderRegion* pRegion) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER #ifdef DO_EXPORT if (pRegion->IS_KIND_OF(NativeRenderRegion)) { EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); // pDC->OutputValue(INT32(TAG_GUIDELINE)); // Output start extended object tag and token // pDC->OutputToken("cso"); // pDC->OutputNewLine(); pDC->OutputValue(Ordinate); pDC->OutputValue(INT32(Type)); pDC->OutputToken(_T("glne")); // Camelot "guideline" token pDC->OutputNewLine(); } #endif #endif // WEBSTER } /*********************************************************************************************** > virtual BOOL NodeGuideline::ExportRender(RenderRegion* pRegion) Author: Mark_Neves (Xara Group Ltd) Created: 11/10/95 Inputs: pRegion = the render region to export to Outputs: - Returns: TRUE if exported completely, FALSE to indicate Render() needs to be called Purpose: Called after child nodes are asked to export ***********************************************************************************************/ BOOL NodeGuideline::ExportRender(RenderRegion* pRegion) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER #ifdef DO_EXPORT if (pRegion->IS_KIND_OF(NativeRenderRegion)) { /*EPSExportDC *pDC = */ (EPSExportDC *) pRegion->GetRenderDC(); // pDC->OutputToken(_T("ceo")); // Output end extended object token // pDC->OutputNewLine(); } #endif #endif // WEBSTER return TRUE; } /*********************************************************************************************** > virtual void NodeGuideline::Render(RenderRegion* pRender) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: RendRegion: Render region to render into Outputs: - Returns: - Purpose: For rendering a node ***********************************************************************************************/ void NodeGuideline::Render( RenderRegion* pRender ) { #if !defined(EXCLUDE_FROM_RALPH) pRender->SaveContext(); DocRect Rect = pRender->GetClipRect(); DocCoord StartCoord,EndCoord; // INT32 DashUnit = (72000/4)*4; if (Type == GUIDELINE_HORZ) { StartCoord.x = Rect.lo.x; EndCoord.x = Rect.hi.x; PullOntoStep(&StartCoord.x,&EndCoord.x,pRender->GetScaledPixelWidth()*4); StartCoord.y = EndCoord.y = Ordinate; } else { StartCoord.y = Rect.lo.y; EndCoord.y = Rect.hi.y; PullOntoStep(&StartCoord.y,&EndCoord.y,pRender->GetScaledPixelWidth()*4); StartCoord.x = EndCoord.x = Ordinate; } pRender->DrawLine(StartCoord,EndCoord); pRender->RestoreContext(); #endif } /******************************************************************************************** > BOOL NodeGuideline::NeedsToRender(RenderRegion *pRender) Author: Mark_Neves (Xara Group Ltd) Created: 25/5/94 Inputs: pRender - A pointer to the current render region (null if none) Returns: TRUE => This node should be rendered, FALSE => This node does not need to be rendered. Purpose: This function will indicate to the caller whether or not we want to render the given node, according to the information passed in. SeeAlso: NodeRenderableBounded::NeedsToRender ********************************************************************************************/ SubtreeRenderState NodeGuideline::RenderSubtree(RenderRegion* pRender, Node** ppNextNode, BOOL bClip) { #if !defined(EXCLUDE_FROM_RALPH) // If no cliprect supplied, assume we do need to render if (pRender==NULL) return SUBTREE_ROOTANDCHILDREN; if (pRender->IsPrinting()) return SUBTREE_NORENDER; if (pRender->IS_KIND_OF(EPSRenderRegion)) return SUBTREE_NORENDER; return SUBTREE_ROOTANDCHILDREN; #else return SUBTREE_NORENDER; #endif } /******************************************************************************************** > BOOL NodeGuideline::NeedsToExport(RenderRegion *pRender,BOOL VisibleLayersOnly = FALSE, BOOL CheckSelected = FALSE) Author: Mark_Neves (Xara Group Ltd) Created: 25/5/94 Inputs: pRender - A pointer to the current render region (null if none) ExcludeInvisibleLayers - TRUE => remove nodes which are on invisible layers - FALSE => export everything CheckSelected - TRUE => we check if object selected and only export selected bjects - FALSE => we don't bother checking for selection or not Returns: TRUE => This node should be exported, FALSE => This node does not need to be exported. Purpose: This function will indicate to the caller whether or not we want to export the given node, according to the information passed in. NodeGuidelines only export to the native file format. SeeAlso: NodeGuideline::NeedsToRender ********************************************************************************************/ BOOL NodeGuideline::NeedsToExport(RenderRegion *pRender,BOOL VisibleLayersOnly, BOOL CheckSelected) { // WEBSTER - markn 14/1/97 #ifdef DO_EXPORT #ifndef WEBSTER return (pRender->IS_KIND_OF(NativeRenderRegion)); #endif // WEBSTER #endif return FALSE; } /*********************************************************************************************** > DocRect NodeGuideline::GetRenderRect(BOOL HitTest= FALSE, RenderRegion* pRender = NULL) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: pRenderRect = ptr to a render region (if NULL current DocView is used) HitTest - TRUE if being called during HitTest Outputs: - Returns: Bounding rect for this guideline Purpose: see NodeGuideline::GetRenderRect(Ordinate,Type,HitTest,pRender) SeeAlso: CSnap ***********************************************************************************************/ DocRect NodeGuideline::GetRenderRect(BOOL HitTest, RenderRegion* pRender) { return NodeGuideline::GetRenderRect(Ordinate,Type,HitTest,pRender); } /*********************************************************************************************** > static DocRect NodeGuideline::GetRenderRect(MILLIPOINT Ordinate,GuidelineType Type,BOOL HitTest= FALSE, RenderRegion* pRender = NULL) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: Ordinate = ordinate value Type = guideline type pRenderRect = ptr to a render region (if NULL current DocView is used) HitTest - TRUE if being called during HitTest Outputs: - Returns: Rect to render Purpose: Main routine for calculating the bounding rect that represents a guideline This is mainly used for invalidating areas on screen for redraw purposes. If HitTest is TRUE, the rect is inflated by the size of the magnetic snap distance so that clicking near a guideline in order to drag it will work. SeeAlso: NodeGuideline::GetScaledPixelWidth() ***********************************************************************************************/ DocRect NodeGuideline::GetRenderRect(MILLIPOINT Ordinate,GuidelineType Type,BOOL HitTest, RenderRegion* pRender) { #if !defined(EXCLUDE_FROM_RALPH) DocRect Rect = DocRect(Ordinate,Ordinate,Ordinate,Ordinate); MILLIPOINT PixelWidth = GetScaledPixelWidth(pRender); if (HitTest) PixelWidth = (CSnap::GetSnapDist()*2); else PixelWidth *= 2; if (Type == GUIDELINE_HORZ) { Rect.lo.x = MIN_INT; Rect.hi.x = MAX_INT; Rect.lo.y -= PixelWidth/2; Rect.hi.y += PixelWidth/2; } else { Rect.lo.x -= PixelWidth/2; Rect.hi.x += PixelWidth/2; Rect.lo.y = MIN_INT; Rect.hi.y = MAX_INT; } return Rect; #else return DocRect(0,0,0,0); #endif } /*********************************************************************************************** > virtual DocRect NodeGuideline::GetBoundingRect(BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: DontUseAttrs - TRUE if you want to ignore all the nodes attributes FALSE by default. HitTest - TRUE if being called during HitTest Outputs: - Returns: Bounding rect for the guideline Purpose: Calcs the bounds of the guideline. This varies with the current view. NOTE: Bounds are only given for hit testing. This is so the bounds of guidelines aren't incorporated into the bounds of its parent (i.e. the layer). If you don't do this, doing a 'zoom to objects' will try and zoom to guidelines which is very wrong SeeAlso: CSnap ***********************************************************************************************/ DocRect NodeGuideline::GetBoundingRect(BOOL DontUseAttrs, BOOL HitTest) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER if (HitTest) return GetRenderRect(HitTest); else #endif // WEBSTER return DocRect(0,0,0,0); } /******************************************************************************************** > virtual BOOL NodeGuideline::OnClick( DocCoord PointerPos, ClickType Click, ClickModifiers ClickMods, Spread *pSpread ) Author: Mark_Neves (Xara Group Ltd) Created: 6/9/95 Inputs: PointerPos - The Location of the mouse pointer at the time of the click Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) pSpread - The spread the click occured in Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Purpose: Allows the Node to respond to clicks. Guidelines will return TRUE for ALL clicks. They only acually do something on CLICKTYPE_SINGLE clicks. With this click they initiate a drag on the guideline to allow the user to move them about the page. ***********************************************************************************************/ BOOL NodeGuideline::OnClick( DocCoord PointerPos, ClickType Click, ClickModifiers ClickMods, Spread *pSpread) { #if !defined(EXCLUDE_FROM_RALPH) if (ClickMods.Menu) return FALSE; if (Click == CLICKTYPE_SINGLE) { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_GUIDELINE); ERROR3IF(pOpDesc == NULL,"FindOpDescriptor(OPTOKEN_GUIDELINE) failed"); if (pOpDesc != NULL) { OpGuidelineParam GuidelineParam; GuidelineParam.Method = GUIDELINEOPMETHOD_MOVE_DRAG; GuidelineParam.pGuideline = this; pOpDesc->Invoke(&GuidelineParam); } } #endif return TRUE; } /******************************************************************************************** > virtual BOOL NodeGuideline::OnNodePopUp(Spread* pSpread, DocCoord PointerPos, ContextMenu* pMenu) Author: Mark_Neves (Xara Group Ltd) Created: 12/5/95 Inputs: pSpread The spread in which things are happening PointerPos The Location of the mouse pointer at the time of the click pMenu The menu to which items should be added Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Purpose: Allows the guideline to respond to pop up menu clicks on itself. ********************************************************************************************/ BOOL NodeGuideline::OnNodePopUp(Spread* pSpread, DocCoord PointerPos, ContextMenu* pMenu) { // WEBSTER-ranbirr-01/12/96 #ifndef WEBSTER BOOL ok = TRUE; #if !defined(EXCLUDE_FROM_RALPH) // set up data required for ops which could be invoked GuidelinePropDlg::SetEditGuidelineParams(this); OpDeleteGuideline::SetGuideline(this); ok = ok && pMenu->BuildCommand(OPTOKEN_DELETEGUIDELINE); ok = ok && pMenu->BuildCommand(OPTOKEN_SNAPTOGUIDES,TRUE); ok = ok && pMenu->BuildCommand(OPTOKEN_EDITGUIDELINEPROPDLG); ok = ok && pMenu->BuildCommand(OPTOKEN_GUIDEPROPERTIESDLG); #endif return ok; #else //webster return FALSE; #endif //webster } /******************************************************************************************** > virtual void NodeGuideline::SetSelected(BOOL Status) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: Status = selection state (ignored) Returns: - Purpose: Overrides the base class selection function 'Status' is ignored and the node is always forced to be unselected. ***********************************************************************************************/ void NodeGuideline::SetSelected(BOOL Status) { Flags.Selected = FALSE; } /*********************************************************************************************** > MILLIPOINT NodeGuideline::ExtractOrdinate(DocCoord* pDocCoord) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: pDocCoord = A DocCoord in Spread coords Outputs: - Returns: Either the X or the Y ordinate, dependant on the guideline type Purpose: Central place for ordinate extraction SeeAlso: CSnap ***********************************************************************************************/ MILLIPOINT NodeGuideline::ExtractOrdinate(DocCoord* pDocCoord) { #ifndef WEBSTER // WEBSTER - markn 14/1/97 ERROR3IF(pDocCoord == NULL,"pDocCoord is NULL"); if (Type == GUIDELINE_HORZ) return pDocCoord->y; else return pDocCoord->x; #else return 0; #endif // WEBSTER } /*********************************************************************************************** > void NodeGuideline::ReplaceOrdinate(DocCoord* pDocCoord,MILLIPOINT Ordinate) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: pDocCoord = A DocCoord in Spread coords Ordinate = ordinate value Outputs: Either the X or the Y ordinate of pDocCoord set to Ordinate, dependant on the guideline type Returns: - Purpose: Central place for ordinate setting SeeAlso: CSnap ***********************************************************************************************/ void NodeGuideline::ReplaceOrdinate(DocCoord* pDocCoord,MILLIPOINT Ordinate) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER ERROR3IF(pDocCoord == NULL,"pDocCoord is NULL"); if (Type == GUIDELINE_HORZ) pDocCoord->y = Ordinate; else pDocCoord->x = Ordinate; #endif // WEBSTER } /*********************************************************************************************** > static MILLIPOINT NodeGuideline::ToSpreadOrdinate(Spread* pSpread,MILLIPOINT UserOrdinate,GuidelineType Type) Author: Mark_Neves (Xara Group Ltd) Created: 3/10/95 Inputs: pSpread = ptr to a spread UserOrdinate= ordinate value in UserCoords Type = the type of guideline Outputs: - Returns: Spread ordinate version of UserOrdinate Purpose: Converts a given ordinate within UserCoord space, into a Spread-related ordinate SeeAlso: ***********************************************************************************************/ MILLIPOINT NodeGuideline::ToSpreadOrdinate(Spread* pSpread,MILLIPOINT UserOrdinate,GuidelineType Type) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER ERROR2IF(pSpread == NULL,0,"pSpread is NULL"); UserCoord UCoord(UserOrdinate,UserOrdinate); DocCoord DCoord = UCoord.ToSpread(pSpread); if (Type == GUIDELINE_HORZ) return DCoord.y; else return DCoord.x; #else return 0; #endif // WEBSTER } /*********************************************************************************************** > static MILLIPOINT NodeGuideline::ToUserOrdinate(Spread* pSpread,MILLIPOINT SpreadOrdinate,GuidelineType Type) Author: Mark_Neves (Xara Group Ltd) Created: 3/10/95 Inputs: pSpread = ptr to a spread SpreadOrdinate = ordinate value in UserCoords Type = the type of guideline Outputs: - Returns: User ordinate version of SpreadOrdinate Purpose: Converts a given ordinate within SpreadCoord space, into a User-related ordinate SeeAlso: ***********************************************************************************************/ MILLIPOINT NodeGuideline::ToUserOrdinate(Spread* pSpread,MILLIPOINT SpreadOrdinate,GuidelineType Type) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER ERROR2IF(pSpread == NULL,0,"pSpread is NULL"); DocCoord DCoord(SpreadOrdinate,SpreadOrdinate); UserCoord UCoord = DCoord.ToUser(pSpread); if (Type == GUIDELINE_HORZ) return UCoord.y; else return UCoord.x; #else return 0; #endif // WEBSTER } /*********************************************************************************************** > void NodeGuideline::TranslateRect(DocRect* pDocRect,MILLIPOINT Delta) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: pDocRect = ptr to a DocRect Delta = amount to translate rect by Outputs: Either the X or the Y ordinates of pDocRec are translated by Delta, dependant on the guideline type Returns: - Purpose: Central place for doc rect translation SeeAlso: CSnap ***********************************************************************************************/ void NodeGuideline::TranslateRect(DocRect* pDocRect,MILLIPOINT Delta) { // WEBSTER - markn 14/1/97 #ifndef WEBSTER ERROR3IF(pDocRect == NULL,"pDocRect is NULL"); if (Type == GUIDELINE_HORZ) pDocRect->Translate(0,Delta); else pDocRect->Translate(Delta,0); #endif // WEBSTER } /*********************************************************************************************** > virtual BOOL NodeGuideline::Snap(DocCoord* pDocCoord) Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: pDocCoord = A DocCoord in Spread coords Outputs: - Returns: TRUE if pDocCoord has snapped to this guideline - FALSE otherwise Purpose: The snap function for DocCoords SeeAlso: CSnap ***********************************************************************************************/ BOOL NodeGuideline::Snap(DocCoord* pDocCoord) { #if !defined(EXCLUDE_FROM_RALPH) MILLIPOINT SnapDist = CSnap::GetSnapDist(); MILLIPOINT SrcOrdinate = ExtractOrdinate(pDocCoord); MILLIPOINT Dist = abs_milli(Ordinate-SrcOrdinate); if (Dist <= SnapDist) { ReplaceOrdinate(pDocCoord,Ordinate); return TRUE; } #endif return FALSE; } /*********************************************************************************************** > virtual BOOL NodeGuideline::Snap(DocRect* pDocRect,const DocCoord& PrevCoord,const DocCoord& CurCoord); Author: Mark_Neves (Xara Group Ltd) Created: 5/9/95 Inputs: A DocRect, and two coords Outputs: - Returns: TRUE if pDocRect has snapped to this guideline - FALSE otherwise Purpose: Place holder for derived classes SeeAlso: CSnap ***********************************************************************************************/ BOOL NodeGuideline::Snap(DocRect* pDocRect,const DocCoord& PrevCoord,const DocCoord& CurCoord) { #if !defined(EXCLUDE_FROM_RALPH) MILLIPOINT SnapDist = CSnap::GetSnapDist(); MILLIPOINT SrcOrdinate = ExtractOrdinate(&pDocRect->lo); MILLIPOINT Dist = Ordinate-SrcOrdinate; if (abs_milli(Dist) <= SnapDist) { TranslateRect(pDocRect,Dist); return TRUE; } SrcOrdinate = ExtractOrdinate(&pDocRect->hi); Dist = Ordinate-SrcOrdinate; if (abs_milli(Dist) <= SnapDist) { TranslateRect(pDocRect,Dist); return TRUE; } #endif return FALSE; } /*********************************************************************************************** > virtual BOOL NodeGuideline::WritePreChildrenWeb(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) Created: 8/8/96 Inputs: pFilter = ptr to filter to write to Outputs: - Returns: TRUE if ok, FALSE otherwise Purpose: Web format doesn't export guidelines SeeAlso: ***********************************************************************************************/ BOOL NodeGuideline::WritePreChildrenWeb(BaseCamelotFilter* pFilter) { return FALSE; } /*********************************************************************************************** > virtual BOOL NodeGuideline::WritePreChildrenNative(BaseCamelotFilter* pFilter) Author: Mark_Neves (Xara Group Ltd) Created: 8/8/96 Inputs: pFilter = ptr to filter to write to Outputs: - Returns: TRUE if ok, FALSE otherwise Purpose: Saves out the guideline in the v2 native file format SeeAlso: ***********************************************************************************************/ BOOL NodeGuideline::WritePreChildrenNative(BaseCamelotFilter* pFilter) { #ifdef DO_EXPORT ERROR2IF(pFilter == NULL,FALSE,"NULL filter param"); ERROR3IF(UINT32(Type) > 255,"Can't store the guideline type in a byte"); CamelotFileRecord Rec(pFilter,TAG_GUIDELINE,TAG_GUIDELINE_SIZE); BOOL ok = Rec.Init(); if (ok) ok = Rec.WriteBYTE(Type); if (ok && Type == GUIDELINE_HORZ) ok = Rec.WriteYOrd(Ordinate); else ok = Rec.WriteXOrd(Ordinate); if (ok) ok = pFilter->Write(&Rec); if (!ok) pFilter->GotError(_R(IDE_FILE_WRITE_ERROR)); return ok; #else return FALSE; #endif } //-------------------------------------------------------------------------------------------- #ifdef _DEBUG void NodeGuideline::ShowDebugTreeDetails() const { NodeRenderableInk::ShowDebugTreeDetails(); } #endif //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- #if !defined(EXCLUDE_FROM_RALPH) /*********************************************************************************************** > OpGuideline::OpGuideline() Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: - Outputs: - Returns: - Purpose: Default constructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpGuideline::OpGuideline() { 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() Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: - Outputs: - Returns: - Purpose: Default destructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpGuideline::~OpGuideline() { if (pCursor != NULL) delete pCursor; } /*********************************************************************************************** > void OpGuideline::BroadcastGuidelineChanges(NodeGuideline* pGuideline) Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: pGuideline = ptr to guideline Outputs: - Returns: - Purpose: Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the parent layer of pGuideline SeeAlso: DoWithParams() ***********************************************************************************************/ void OpGuideline::BroadcastGuidelineChanges(NodeGuideline* pGuideline) { if (pGuideline != NULL) BroadcastGuidelineChanges((Layer*)pGuideline->FindParent(CC_RUNTIME_CLASS(Layer))); } /*********************************************************************************************** > void OpGuideline::BroadcastGuidelineChanges(Layer* pLayer) Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: pLayer = ptr to layer Outputs: - Returns: - Purpose: Broadcasts a LayerMsg::LayerReason::GUIDELINES_CHANGED for the given layer SeeAlso: DoWithParams() ***********************************************************************************************/ void OpGuideline::BroadcastGuidelineChanges(Layer* pLayer) { if (pLayer != NULL) { BROADCAST_TO_ALL(LayerMsg(pLayer,LayerMsg::GUIDELINES_CHANGED)); } pBroadcastLayer = pLayer; } /*********************************************************************************************** > void OpGuideline::DoWithParam(OpDescriptor* pOpDesc,OpParam* pParam) Author: Mark_Neves (Xara Group Ltd) Created: 22/9/95 Inputs: pOpDesc = ptr op desc pOpParam = param block to use Outputs: - Returns: - Purpose: This function is used to create a guideline in the selected spread. It calls DoAddNewGuideline() with pParam->Param1 specifying the guideline type. SeeAlso: DoAddNewGuideline(), OilRuler::OnLButtonDown() ***********************************************************************************************/ void OpGuideline::DoWithParam(OpDescriptor* pOpDesc,OpParam* pParam) { 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::DoAddNewGuideline(Spread* pSpread,DocCoord PointerPos,GuidelineType TheType) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: pThisSpread = ptr to spread drag started in PointerPos = coord of point clicked TheType = The type of guideline Outputs: - Returns: - Purpose: Starts a drag to add a new guideline to the document SeeAlso: UndoableOperation ***********************************************************************************************/ void OpGuideline::DoAddNewGuideline(Spread* pSpread,DocCoord PointerPos,GuidelineType TheType) { Type = TheType; DoDrag(pSpread,PointerPos); } /*********************************************************************************************** > void OpGuideline::DoMoveGuideline(Spread* pSpread,DocCoord PointerPos,NodeGuideline* pGuideline) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: pThisSpread = ptr to spread drag started in PointerPos = coord of point clicked pGuideline = the guideline to move Outputs: - Returns: - Purpose: Starts a drag to add a new guideline to the document SeeAlso: UndoableOperation ***********************************************************************************************/ void OpGuideline::DoMoveGuideline(Spread* pSpread,DocCoord PointerPos,NodeGuideline* pGuideline) { pDraggedGuideline = pGuideline; Type = pDraggedGuideline->GetType(); DoDrag(pSpread,PointerPos); } /*********************************************************************************************** > void OpGuideline::DoDrag(Spread* pThisSpread,DocCoord PointerPos) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: pThisSpread = ptr to spread drag started in (NULL means get selected spread) PointerPos = coord of point clicked Outputs: - Returns: - Purpose: Starts a drag for a new or existing guideline SeeAlso: DoMoveGuideline(), DoAddNewGuideline() ***********************************************************************************************/ void OpGuideline::DoDrag(Spread* pThisSpread,DocCoord PointerPos) { 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 ); } /*********************************************************************************************** > virtual void OpGuideline::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: PointerPos = coord of the pointer ClickMods = info on the click modifiers pSpread = ptr to spread Outputs: - Returns: - Purpose: Responds to a mouse move during a drag of a guideline SeeAlso: UndoableOperation ***********************************************************************************************/ void OpGuideline::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL bSolidDrag) { // First Rub out the old box RenderMyDragBlobs(); DocView::SnapCurrent(pSpread,&PointerPos); SetOrdinate(PointerPos); // Render the new drag box RenderMyDragBlobs(); UpdateStatusLineAndPointer(); } /*********************************************************************************************** > virtual void OpGuideline::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL Success , BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: PointerPos = coord of the pointer 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: - Purpose: Responds to the drag of a guideline ending SeeAlso: UndoableOperation ***********************************************************************************************/ void OpGuideline::DragFinished( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL Success, BOOL bSolidDrag) { // 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(); } /*********************************************************************************************** > void OpGuideline::UpdateStatusLineAndPointer() Author: Mark_Neves (Xara Group Ltd) Created: 12/10/95 Inputs: - Outputs: - Returns: - Purpose: Makes sure the status line AND pointer are correct during a drag SeeAlso: UndoableOperation ***********************************************************************************************/ void OpGuideline::UpdateStatusLineAndPointer() { // 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); } } /*********************************************************************************************** > virtual BOOL OpGuideline::DragKeyPress(KeyPress* pKeyPress, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 11/10/95 Inputs: pKeyPress = ptr to keypress object Outputs: - Returns: - Purpose: Responds to a keypress during the drag SeeAlso: DragFinished ***********************************************************************************************/ BOOL OpGuideline::DragKeyPress(KeyPress* pKeyPress, BOOL bSolidDrag) { 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; } /*********************************************************************************************** > static BOOL OpGuideline::IsMouseOverRuler() Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: - Outputs: - Returns: TRUE if mouse is over a ruler, FALSE otherwise Purpose: Test to see where the mouse pointer is. It will return TRUE if the mouse is over either ruler, or the origin gadget. SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::IsMouseOverRuler() { DocView* pDocView = DocView::GetSelected(); if (pDocView != NULL) { CCamView* pCCamView = pDocView->GetConnectionToOilView(); return (pCCamView->IsMouseOverRuler() != OVER_NO_RULERS); } return FALSE; } /*********************************************************************************************** > BOOL OpGuideline::DoTranslateGuideline(NodeGuideline* pGuideline,MILLIPOINT Ordinate,NodeGuideline** ppNewGuideline = NULL) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: pGuideline = ptr to an existing guideline Ordinate = Absolute position to translate to ppNewGuideline = place to put ptr of translated guideline (Can be NULL) Outputs: *ppNewGuideline = ptr to translated guideline (NULL if function fails) Returns: TRUE if successful, FALSE otherwise Purpose: Translates the given guideline to line up with Ordinate, undoably SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::DoTranslateGuideline(NodeGuideline* pGuideline,MILLIPOINT Ordinate,NodeGuideline** ppNewGuideline) { 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; } /*********************************************************************************************** > BOOL OpGuideline::DoNewGuideline(Node* pContext,AttachNodeDirection AttachDir,GuidelineType Type,MILLIPOINT Ordinate,NodeGuideline** ppNewGuideline = NULL) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: pContext = ptr to context node (Can be NULL) 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) Outputs: *ppNewGuideline = ptr to new guideline (NULL if function fails) Returns: TRUE if successful, FALSE otherwise Purpose: Creates a new guideline to line up with Ordinate, undoably SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::DoNewGuideline(Node* pContext,AttachNodeDirection AttachDir,GuidelineType Type,MILLIPOINT Ordinate,NodeGuideline** ppNewGuideline) { 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::DoDeleteGuideline(NodeGuideline* pGuideline,BOOL TryToLeaveCopy = FALSE) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: pGuideline = ptr to an existing guideline TryToLeaveCopy = TRUE to try and leave copy, FALSE means force delete Outputs: - Returns: TRUE if successful, FALSE otherwise Purpose: Deletes the given guideline, undoably SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::DoDeleteGuideline(NodeGuideline* pGuideline,BOOL TryToLeaveCopy) { 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::CanLeaveCopy() Author: Mark_Neves (Xara Group Ltd) Created: 11/10/95 Inputs: - Outputs: - Returns: TRUE if user wants to leave a copy behind, FALSE otherwise Purpose: Sees if the user wants to leave a copy behind TRUE is returned if the ctrl is pressed, or Numpad + has been pressed an odd number of times during the drag SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::CanLeaveCopy() { return (LeaveCopy || KeyPress::IsConstrainPressed()); } /*********************************************************************************************** > BOOL OpGuideline::DoDeleteListOfGuidelines(NodeGuideline** pGuidelineList) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: pGuidelineList = ptr to a list of existing guidelines Outputs: - Returns: TRUE if successful, FALSE otherwise Purpose: Deletes the guidelines in the given list, undoably The list should be terminated by a NULL value SeeAlso: OpGuideline::DragFinished() ***********************************************************************************************/ BOOL OpGuideline::DoDeleteListOfGuidelines(NodeGuideline** pGuidelineList) { ERROR2IF(pGuidelineList == NULL,FALSE,"pGuidelineList is NULL"); BOOL ok= TRUE; while (*pGuidelineList != NULL && ok) { ok = DoDeleteGuideline(*pGuidelineList); pGuidelineList++; } return ok; } /*********************************************************************************************** > Layer* OpGuideline::DoCreateGuideLayer() Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: - Outputs: - Returns: Ptr to the guide layer, or NULL one couldn't be created. Purpose: This returns a ptr to the guide layer. 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 SeeAlso: OpGuideline::DoNewGuideline() ***********************************************************************************************/ Layer* OpGuideline::DoCreateGuideLayer() { 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; } /*********************************************************************************************** > static Layer* OpGuideline::CreateGuideLayer() Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: - Outputs: - Returns: Ptr to a guide layer that's ready to be inserted into the tree Purpose: This does everything required in creating a layer fit to be called the guide layer SeeAlso: - ***********************************************************************************************/ // WEBSTER - markn 15/1/97 // Moved this static function into the Layer class, where it should be /* Layer* OpGuideline::CreateGuideLayer() { Layer* pNewLayer = new Layer; if (pNewLayer != NULL) { String_256 LayerName(_R(IDS_GUIDESLAYERNAME)); pNewLayer->SetVisible(TRUE); pNewLayer->SetLocked(FALSE); pNewLayer->SetPrintable(FALSE); pNewLayer->SetBackground(TRUE); pNewLayer->SetOutline(FALSE); pNewLayer->SetGuide(TRUE); pNewLayer->SetLayerID(LayerName); Quality Qual; Qual.SetQuality(-1); QualityAttribute QualAttr(Qual); NodeAttribute* pNodeAttr = QualAttr.MakeNode(); pNodeAttr->AttachNode(pNewLayer,FIRSTCHILD); } return pNewLayer; } */ /*********************************************************************************************** > void OpGuideline::SetOrdinate(DocCoord& PointerPos) Author: Mark_Neves (Xara Group Ltd) Created: 12/9/95 Inputs: PointerPos = pos of mouse pointer Outputs: - Returns: - Purpose: Sets the Ordinate member var to either the X or the Y value of PointerPos depending on the guideline type SeeAlso: - ***********************************************************************************************/ void OpGuideline::SetOrdinate(DocCoord& PointerPos) { if (Type == GUIDELINE_HORZ) Ordinate = PointerPos.y; else Ordinate = PointerPos.x; } /*********************************************************************************************** > void OpGuideline::RenderMyDragBlobs() Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: - Outputs: - Returns: - Purpose: Renders the blobs associated with the current drag SeeAlso: RenderDragBlobs() ***********************************************************************************************/ void OpGuideline::RenderMyDragBlobs() { DocRect Rect; RenderDragBlobs(Rect,pSpread, FALSE); RenderOn = !RenderOn; } /*********************************************************************************************** > void OpGuideline::RenderDragBlobs(DocRect Rect,Spread* pSpread, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: Rect = region of doc being updated (NOT USED!) pSpread = ptr to the spread being redrawn Outputs: - Returns: - Purpose: Main routine for rendering the blobs associated with the current drag. This can be called from anywhere, e.g. when the view scrolls SeeAlso: - ***********************************************************************************************/ void OpGuideline::RenderDragBlobs(DocRect Rect,Spread* pSpread, BOOL bSolidDrag) { 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); } } /*********************************************************************************************** > virtual BOOL OpGuideline::Undo() Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: - Outputs: - Returns: TRUE if successfull, FALSE otherwise Purpose: Called when the op is undone. This broadcasts a 'Guidelines changed' layer message SeeAlso: - ***********************************************************************************************/ BOOL OpGuideline::Undo() { if (UndoableOperation::Undo()) { BroadcastGuidelineChanges(pBroadcastLayer); return TRUE; } return FALSE; } /*********************************************************************************************** > virtual BOOL OpGuideline::Redo() Author: Mark_Neves (Xara Group Ltd) Created: 4/10/95 Inputs: - Outputs: - Returns: TRUE if successfull, FALSE otherwise Purpose: Called when the op is redone. This broadcasts a 'Guidelines changed' layer message SeeAlso: - ***********************************************************************************************/ BOOL OpGuideline::Redo() { if (UndoableOperation::Redo()) { BroadcastGuidelineChanges(pBroadcastLayer); return TRUE; } return FALSE; } /*********************************************************************************************** > static BOOL OpGuideline::Init() Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: - Outputs: - Returns: TRUE if op successfully declared, FALSE otherwise Purpose: Registers an op desc for this op SeeAlso: - ***********************************************************************************************/ BOOL OpGuideline::Init() { 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 */ ) ); } /*********************************************************************************************** > static OpState OpGuideline::GetState(String_256* Description, OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: Description = ptr to place description of why this op can't happen pOpDesc = ptr to the Op Desc associated with this op Outputs: - Returns: An OpState object Purpose: Func for determining the usability of this op SeeAlso: - ***********************************************************************************************/ OpState OpGuideline::GetState(String_256* Description, OpDescriptor*) { OpState State; return State; } /*********************************************************************************************** > static void OpGuideline::GetOpName(String_256* OpName) Author: Mark_Neves (Xara Group Ltd) Created: 7/9/95 Inputs: OpName = ptr to string Outputs: OpName contains a description of the op Returns: - Purpose: Returns a desc of the op. Mainly used to fill in the menu item for the undo/redo ops. SeeAlso: - ***********************************************************************************************/ void OpGuideline::GetOpName(String_256* OpName) { *OpName = String_256(UndoIDS); } //-------------------------------------------------------------------- //-------------------------------------------------------------------- /*********************************************************************************************** > OpDeleteGuideline::OpDeleteGuideline() Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Default constructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpDeleteGuideline::OpDeleteGuideline() { UndoIDS = _R(IDS_OPDELETEGUIDELINE); } /*********************************************************************************************** > OpDeleteGuideline::~OpDeleteGuideline() Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Default destructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpDeleteGuideline::~OpDeleteGuideline() { } /******************************************************************************************** > void OpDeleteGuideline::Do(OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Creates then opens the dialog Errors: - SeeAlso: - ********************************************************************************************/ void OpDeleteGuideline::Do(OpDescriptor*) { BOOL ok = FALSE; Spread* pSpread = Document::GetSelectedSpread(); if (pGuideline != NULL) ok = DoDeleteGuideline(pGuideline); if (!ok) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); pGuideline = NULL; End(); } /*********************************************************************************************** > static OpState OpDeleteGuideline::GetState(String_256* Description, OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: Description = ptr to place description of why this op can't happen pOpDesc = ptr to the Op Desc associated with this op Outputs: - Returns: An OpState object Purpose: Func for determining the usability of this op SeeAlso: - ***********************************************************************************************/ OpState OpDeleteGuideline::GetState(String_256* Description, OpDescriptor*) { OpState State; State.Greyed = (pGuideline == NULL); return State; } /////////////////////////////////////////////////////////////////////////////// // OpNewGuideline /****************************************************************************** > OpNewGuideline::OpNewGuideline() Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Purpose: Default constructor ******************************************************************************/ OpNewGuideline::OpNewGuideline() { UndoIDS = _R(IDS_OPNEWGUIDELINE2UNDO); } /****************************************************************************** > OpNewGuideline::~OpNewGuideline() Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Purpose: Default destructor ******************************************************************************/ OpNewGuideline::~OpNewGuideline() { } /****************************************************************************** > BOOL OpResetSpreadOrigin::Init() Author: Ed_Cornes (Xara Group Ltd) Created: 10/10/95 Returns: FALSE if fails Purpose: Initilise OpNewGuideline ******************************************************************************/ BOOL OpNewGuideline::Init() { return RegisterOpDescriptor( 0, _R(IDS_OPNEWGUIDELINE2), CC_RUNTIME_CLASS(OpNewGuideline), OPTOKEN_NEWGUIDELINE2 , OpNewGuideline::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ); } /***************************************************************************** > void OpNewGuideline::Do(OpDescriptor* pOpDesc) Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Inputs: pOpDesc - Purpose: sets up param block and invokes OpGuideline::DoWithParams() ******************************************************************************/ void OpNewGuideline::Do(OpDescriptor* pOpDesc) { Spread* pSpread = Document::GetSelectedSpread(); if (pOpDesc!=NULL && pSpread!=NULL && NewGuidelineParam.Method==GUIDELINEOPMETHOD_NEW_IMMEDIATE) { // GuidelineType Type = NewGuidelineParam.Type; DocCoord GuidePos = DocCoord(NewGuidelineParam.NewOrdinate, NewGuidelineParam.NewOrdinate); DoWithParam(pOpDesc,&NewGuidelineParam); NewGuidelineParam.Method = GUIDELINEOPMETHOD_INVALID; // reset static param block } else { ERROR3("OpNewGuideline::Do() - invalid Method or pOpDesc==NULL or no selected spread"); FailAndExecute(); End(); } } /****************************************************************************** > static void OpNewGuideline::SetNewGuidelineParam(GuidelineType Type, MILLIPOINT pos) Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Inputs: Type - type of guide (hoiz/vert) Pos - positin of guide ******************************************************************************/ void OpNewGuideline::SetNewGuidelineParam(GuidelineType Type, MILLIPOINT pos) { NewGuidelineParam.Method = GUIDELINEOPMETHOD_NEW_IMMEDIATE; NewGuidelineParam.Type = Type; NewGuidelineParam.NewOrdinate = pos; } /****************************************************************************** > static OpState OpNewGuideline::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Inputs: pOpDesc - Outputs: pReasonGreyed - Returns: An OpState object ******************************************************************************/ OpState OpNewGuideline::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) { return OpState(); } //-------------------------------------------------------------------- //-------------------------------------------------------------------- /*********************************************************************************************** > OpDeleteAllGuidelines::OpDeleteAllGuidelines() Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Default constructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpDeleteAllGuidelines::OpDeleteAllGuidelines() { UndoIDS = _R(IDS_OPDELETEALLGUIDELINES); } /*********************************************************************************************** > OpDeleteAllGuidelines::~OpDeleteAllGuidelines() Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Default destructor SeeAlso: UndoableOperation ***********************************************************************************************/ OpDeleteAllGuidelines::~OpDeleteAllGuidelines() { } /******************************************************************************************** > void OpDeleteAllGuidelines::Do(OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: - Outputs: - Returns: - Purpose: Creates then opens the dialog Errors: - SeeAlso: - ********************************************************************************************/ void OpDeleteAllGuidelines::Do(OpDescriptor*) { BOOL ok = FALSE; Spread* pSpread = Document::GetSelectedSpread(); if (pSpread != NULL) { Layer* pLayer = pSpread->FindFirstGuideLayer(); if (pLayer != NULL) { ok = TRUE; Node* pNode = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); while (pNode != NULL) { Node* pNextNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGuideline)); ok = ok && DoDeleteGuideline((NodeGuideline*)pNode); pNode = pNextNode; } } } if (!ok) FailAndExecute(); else BroadcastGuidelineChanges(pSpread->FindFirstGuideLayer()); End(); } /*********************************************************************************************** > static OpState OpDeleteAllGuidelines::GetState(String_256* Description, OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 5/10/95 Inputs: Description = ptr to place description of why this op can't happen pOpDesc = ptr to the Op Desc associated with this op Outputs: - Returns: An OpState object Purpose: Func for determining the usability of this op SeeAlso: - ***********************************************************************************************/ OpState OpDeleteAllGuidelines::GetState(String_256* Description, OpDescriptor*) { OpState State(FALSE,TRUE); // Greyed out by default Spread* pSpread = Document::GetSelectedSpread(); if (pSpread != NULL) { Layer* pLayer = pSpread->FindFirstGuideLayer(); if (pLayer != NULL) { Node* pNode = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); State.Greyed = (pNode == NULL); // Ungrey if there are one or more guidelines } } if (State.Greyed) Description->Load(_R(IDS_OPDELETEALLGUIDESGREY)); return State; } /////////////////////////////////////////////////////////////////////////////// // GuidelinePropDlg - or should that be OpGuidelinePropDlg! /******************************************************************************************** > GuidelinePropDlg::GuidelinePropDlg(): DialogOp(GuidelinePropDlg::IDD, GuidelinePropDlg::Mode) Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Purpose: GuidelinePropDlg constructor. Creates a non-undoable operation ********************************************************************************************/ GuidelinePropDlg::GuidelinePropDlg(): DialogOp(GuidelinePropDlg::IDD, GuidelinePropDlg::Mode) { } /******************************************************************************************** > MsgResult GuidelinePropDlg::Message(Msg* pMsg) Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Inputs: pMsg - Returns: a message result Purpose: Handles all the scale dialog's messages ********************************************************************************************/ MsgResult GuidelinePropDlg::Message(Msg* pMsg) { if (IS_OUR_DIALOG_MSG(pMsg)) { DialogMsg* Msg = (DialogMsg*)pMsg; BOOL EndDialog = FALSE; switch (Msg->DlgMsg) { case DIM_CREATE: ShowDetails(); SetKeyboardFocus (_R(IDC_GUIDELINEPROP_POSITION)) ; HighlightText (_R(IDC_GUIDELINEPROP_POSITION)) ; break; case DIM_COMMIT: EndDialog = CommitValues(); if (!EndDialog) Msg->DlgMsg = DIM_NONE; // stop default handler from closing dialog break; case DIM_SOFT_COMMIT: break; case DIM_CANCEL: EndDialog = TRUE; break; case DIM_LFT_BN_CLICKED: break; case DIM_TEXT_CHANGED: break; default: break; } if (EndDialog) // Dialog communication over { // Isn't this pretty? Close(); // Close the dialog End(); // Destroy dialog return OK; } } // Pass everything on to the base class . . . return DialogOp::Message(pMsg); } /******************************************************************************************** > OpState GuidelinePropDlg::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Inputs: pOpDesc - Outputs: pReasonGreyed - Returns: op state Purpose: GuidelinePropDlg GetState method ********************************************************************************************/ OpState GuidelinePropDlg::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) { OpState OpSt; return OpSt; } /******************************************************************************************** > BOOL GuidelinePropDlg::Init() Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Returns: FALSE if fails Purpose: GuidelinePropDlg Init method ********************************************************************************************/ BOOL GuidelinePropDlg::Init() { return RegisterOpDescriptor(0, _R(IDS_OPEDITGUIDELINEPROPDLG), CC_RUNTIME_CLASS(GuidelinePropDlg), OPTOKEN_EDITGUIDELINEPROPDLG, GuidelinePropDlg::GetState, 0, // help ID 0, // bubble ID 0 // bitmap ID ) && RegisterOpDescriptor(0, _R(IDS_OPNEWGUIDELINEPROPDLG), CC_RUNTIME_CLASS(GuidelinePropDlg), OPTOKEN_NEWGUIDELINEPROPDLG, GuidelinePropDlg::GetState, 0, // help ID 0, // bubble ID 0 // bitmap ID ); } /******************************************************************************************** > void GuidelinePropDlg::Do(OpDescriptor* pOpDesc) Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Inputs: pOpDesc - Purpose: Creates then opens the dialog ********************************************************************************************/ void GuidelinePropDlg::Do(OpDescriptor* pOpDesc) { if (Create()==FALSE) { InformError(0,_R(IDS_OK)); End(); } } /******************************************************************************************** > void GuidelinePropDlg::ShowDetails() Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Purpose: Shows guideline details in the dialog ********************************************************************************************/ void GuidelinePropDlg::ShowDetails() { MILLIPOINT Ordinate; GuidelineType Type; Spread* pSpread; String_256 TitleStr(""); if (Params.pGuideline!=NULL) { pSpread = Params.pGuideline->FindParentSpread(); Ordinate = Params.pGuideline->GetOrdinate(); Type = Params.pGuideline->GetType(); TitleStr = String_256(_R(IDS_OPEDITGUIDELINEPROPDLGTITLE)); } else { pSpread = Document::GetSelectedSpread(); Ordinate = Params.Ordinate; Type = Params.Type; TitleStr = String_256(_R(IDS_OPNEWGUIDELINEPROPDLGTITLE)); } SetTitlebarName(&TitleStr); Ordinate = NodeGuideline::ToUserOrdinate(pSpread,Ordinate,Type); SetDimensionGadgetValue(_R(IDC_GUIDELINEPROP_POSITION),Ordinate,pSpread); UINT32 IDS = (Type==GUIDELINE_HORZ) ? _R(IDS_HORIZONTAL) : _R(IDS_VERTICAL); String_256 Str(IDS); SetStringGadgetValue(_R(IDC_GUIDELINEPROP_TYPE),IDS); } /******************************************************************************************** > BOOL GuidelinePropDlg::CommitValues() Author: Mark_Neves (Xara Group Ltd) Created: 29/9/95 Returns: TRUE if values excepted, FALSE otherwise Purpose: Called when the OK button is selected ********************************************************************************************/ BOOL GuidelinePropDlg::CommitValues() { OpGuidelineParam GuidelineParam; BOOL ok; MILLIPOINT Ordinate = GetDimensionGadgetValue(_R(IDC_GUIDELINEPROP_POSITION),Document::GetSelectedSpread(),&ok); if (!ok) return FALSE; if (Params.pGuideline != NULL) { GuidelineParam.Method = GUIDELINEOPMETHOD_MOVE_IMMEDIATE; GuidelineParam.pGuideline = Params.pGuideline; GuidelineParam.NewOrdinate = NodeGuideline::ToSpreadOrdinate(Params.pGuideline->FindParentSpread(),Ordinate,Params.pGuideline->GetType()); } else { GuidelineParam.Method = GUIDELINEOPMETHOD_NEW_IMMEDIATE; GuidelineParam.Type = Params.Type; GuidelineParam.NewOrdinate = NodeGuideline::ToSpreadOrdinate(Document::GetSelectedSpread(),Ordinate,Params.Type); } OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_GUIDELINE); ERROR3IF(pOpDesc == NULL,"FindOpDescriptor(OPTOKEN_GUIDELINE) failed"); if (pOpDesc != NULL) pOpDesc->Invoke(&GuidelineParam); return TRUE; } /****************************************************************************** > static void GuidelinePropDlg::SetNewGuidelineParams(GuidelineType type, MILLIPOINT pos) Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Inputs: Type - type of guide (hoiz/vert) pos - position of guide Purpose: Set up param block for guideline property dialog ******************************************************************************/ void GuidelinePropDlg::SetNewGuidelineParams(GuidelineType type, MILLIPOINT pos) { Params.pGuideline = NULL; Params.Type = type; Params.Ordinate = pos; } /****************************************************************************** > static void GuidelinePropDlg::SetEditGuidelineParams(NodeGuideline* pGuide) Author: Ed_Cornes (Xara Group Ltd) Created: 9/10/95 Inputs: pGuide - guide to edit Purpose: Set up param block for guideline property dialog ******************************************************************************/ void GuidelinePropDlg::SetEditGuidelineParams(NodeGuideline* pGuide) { ERROR3IF(pGuide==NULL,"GuidelinePropDlg::SetEditGuidelineParam() - pGuide==NULL"); Params.pGuideline = pGuide; Params.Type = GUIDELINE_NOTYPE; Params.Ordinate = 0; } /////////////////////////////////////////////////////////////////////////////// // OpSpreadOrigin /******************************************************************************************** > OpSpreadOrigin::OpSpreadOrigin() Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: - Outputs: - Returns: - Purpose: Default constructor Errors: - SeeAlso: - ********************************************************************************************/ OpSpreadOrigin::OpSpreadOrigin() { RenderOn = TRUE; } /******************************************************************************************** > OpSpreadOrigin::~OpSpreadOrigin() Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: - Outputs: - Returns: - Purpose: Default destructor Errors: - SeeAlso: - ********************************************************************************************/ OpSpreadOrigin::~OpSpreadOrigin() { } /*********************************************************************************************** > void OpSpreadOrigin::Do(OpDescriptor* pOpDesc) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: pOpDesc = ptr op desc Outputs: - Returns: - Purpose: This func starts a drag that will end up setting the spread origin SeeAlso: DoAddNewGuideline(), OilRuler::OnLButtonDown() ***********************************************************************************************/ void OpSpreadOrigin::Do(OpDescriptor* pOpDesc) { DocCoord StartPos(-5000,-5000); DoDrag(NULL,StartPos); } /*********************************************************************************************** > void OpSpreadOrigin::DoDrag(Spread* pThisSpread,DocCoord PointerPos) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: pThisSpread = ptr to spread drag started in (NULL means get selected spread) PointerPos = coord of point clicked Outputs: - Returns: - Purpose: Starts a drag for the origin SeeAlso: - ***********************************************************************************************/ void OpSpreadOrigin::DoDrag(Spread* pThisSpread,DocCoord PointerPos) { pSpread = pThisSpread; if (pSpread == NULL) pSpread = Document::GetSelectedSpread(); ERROR3IF(pSpread == NULL,"pSpread == NULL"); if (pSpread == NULL) { End(); return; } CurrentOrigin = PointerPos; RenderMyDragBlobs(); // put up some status line help StatusLine* pStatusLine=GetApplication()->GetpStatusLine(); if (pStatusLine!=NULL) { String_256 temp(_R(IDS_OPSPREADORIGINDRAG)); pStatusLine->UpdateText(&temp,STATUSLINE_SELDESC_STATBAR); } // Tell the Dragging system that we need drags to happen StartDrag( DRAGTYPE_DEFERSCROLL ); } /*********************************************************************************************** > virtual void OpSpreadOrigin::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: PointerPos = coord of the pointer ClickMods = info on the click modifiers pSpread = ptr to spread Outputs: - Returns: - Purpose: Responds to a mouse move during a drag of the origin SeeAlso: UndoableOperation ***********************************************************************************************/ void OpSpreadOrigin::DragPointerMove( DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL bSolidDrag) { // First Rub out the old box RenderMyDragBlobs(); DocView::SnapCurrent(pSpread,&PointerPos); CurrentOrigin = PointerPos; // Render the new drag box RenderMyDragBlobs(); } /*********************************************************************************************** > virtual void OpSpreadOrigin::DragFinished(DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL Success, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: PointerPos = coord of the pointer 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: - Purpose: Responds to the drag of a guideline ending SeeAlso: UndoableOperation ***********************************************************************************************/ void OpSpreadOrigin::DragFinished(DocCoord PointerPos, ClickModifiers ClickMods, Spread*, BOOL Success, BOOL bSolidDrag) { // First Rub out the old boxes RenderMyDragBlobs(); Success = (Success && !OpGuideline::IsMouseOverRuler()); if (Success) { DocView::SnapCurrent(pSpread,&PointerPos); CurrentOrigin = PointerPos; Success = DoChangeOrigin(pSpread,CurrentOrigin); } if (!Success) FailAndExecute(); // End the op & Drag End(); EndDrag(); } /*********************************************************************************************** > BOOL OpSpreadOrigin::DoChangeOrigin(Spread* pSpread, DocCoord NewOrigin) Author: Ed_Cornes (Xara Group Ltd) Created: 8/10/95 Inputs: pSpread = ptr to spread NewOrigin = new origin for the spread Returns: FALSE if fails Purpose: Undoably set a new grid/user origin ***********************************************************************************************/ BOOL OpSpreadOrigin::DoChangeOrigin(Spread* pSpread, DocCoord NewOrigin) { ERROR2IF(pSpread==NULL,FALSE,"OpSpreadOrigin::DoChangeOrigin() - pSpread==NULL"); NodeGrid* pDefaultGrid = pSpread->FindFirstDefaultGridInSpread(); ERROR2IF(pDefaultGrid==NULL,FALSE,"OpSpreadOrigin::DoChangeOrigin() - FindFirstDefaultGrid() failed"); // if no change in origin, just return without inserting an op MILLIPOINT x,y; pDefaultGrid->GetOrigin(&x,&y); // call me stupid but couldn't this return a DocCoord! if (DocCoord(x,y)==NewOrigin) return TRUE; // cunningly (NOT) OpGridResize expects the origin to be page relative! DocCoord NewPageRelativeOrigin; pSpread->SpreadCoordToPagesCoord(&NewPageRelativeOrigin,NewOrigin); // Force the origin to snap to a pixel boundary. NewPageRelativeOrigin.x = ((NewPageRelativeOrigin.x + 375) / 750) * 750; NewPageRelativeOrigin.y = ((NewPageRelativeOrigin.y + 375) / 750) * 750; // set up a complete set of grid params with new origin // (would be nice to have them all default to 'no change' and only specify the new ones but that would be far to obvious!) GridResizeInfo GridParams; GridParams.pSpread = pSpread; GridParams.OriginX = NewPageRelativeOrigin.x; GridParams.OriginY = NewPageRelativeOrigin.y; GridParams.GridDivisions = pDefaultGrid->GetDivisions(); GridParams.GridSubDivisions = pDefaultGrid->GetSubdivisions(); GridParams.GridUnits = pDefaultGrid->GetUnits(); GridParams.TypeOfGrid = pDefaultGrid->GetGridType(); // GridParams.GridSpacing // this seems to be 'MainStep' which is also determined from Divisions and Units return DoResizeGrid(&GridParams); } /*********************************************************************************************** > void OpSpreadOrigin::RenderMyDragBlobs() Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: - Outputs: - Returns: - Purpose: Renders the blobs associated with the current drag SeeAlso: RenderDragBlobs() ***********************************************************************************************/ void OpSpreadOrigin::RenderMyDragBlobs() { DocRect Rect; RenderDragBlobs(Rect,pSpread, FALSE); RenderOn = !RenderOn; } /*********************************************************************************************** > void OpSpreadOrigin::RenderDragBlobs(DocRect Rect,Spread* pSpread, BOOL bSolidDrag) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: Rect = region of doc being updated (NOT USED!) pSpread = ptr to the spread being redrawn Outputs: - Returns: - Purpose: Main routine for rendering the blobs associated with the current drag. This can be called from anywhere, e.g. when the view scrolls SeeAlso: - ***********************************************************************************************/ void OpSpreadOrigin::RenderDragBlobs(DocRect Rect,Spread* pSpread, BOOL bSolidDrag) { static DocRect RenderRect; RenderRegion* pRender = DocView::RenderOnTop( NULL, pSpread, UnclippedEOR ); DocCoord Start; DocCoord End; while (pRender != NULL) { pRender->SetLineColour(COLOUR_BLACK); pRender->SetLineWidth(pRender->GetScaledPixelWidth()); if (RenderOn) { View* pView = pRender->GetRenderView(); if (pView != NULL) { RenderRect = pView->GetDocViewRect(pSpread); RenderRect = RenderRect.ToSpread(pSpread,pView); } RenderRect.Inflate(pRender->GetScaledPixelWidth()); } Start = DocCoord(CurrentOrigin.x,RenderRect.lo.y); End = DocCoord(CurrentOrigin.x,RenderRect.hi.y); pRender->DrawDashLine(Start,End); Start = DocCoord(RenderRect.lo.x,CurrentOrigin.y); End = DocCoord(RenderRect.hi.x,CurrentOrigin.y); pRender->DrawDashLine(Start,End); // Get the Next render region pRender = DocView::GetNextOnTop(NULL); } } /*********************************************************************************************** > static BOOL OpSpreadOrigin::Init() Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: - Outputs: - Returns: TRUE if op successfully declared, FALSE otherwise Purpose: Registers an op desc for this op SeeAlso: - ***********************************************************************************************/ BOOL OpSpreadOrigin::Init() { return RegisterOpDescriptor(0, _R(IDS_OPSPREADORIGIN), CC_RUNTIME_CLASS(OpSpreadOrigin), OPTOKEN_SPREADORIGIN , OpSpreadOrigin::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ); } /*********************************************************************************************** > static OpState OpSpreadOrigin::GetState(String_256* Description, OpDescriptor*) Author: Mark_Neves (Xara Group Ltd) Created: 6/10/95 Inputs: Description = ptr to place description of why this op can't happen pOpDesc = ptr to the Op Desc associated with this op Outputs: - Returns: An OpState object Purpose: Func for determining the usability of this op SeeAlso: - ***********************************************************************************************/ OpState OpSpreadOrigin::GetState(String_256* Description, OpDescriptor*) { OpState State; return State; } /////////////////////////////////////////////////////////////////////////////// // OpResetSpreadOrigin /****************************************************************************** > OpResetSpreadOrigin::OpResetSpreadOrigin() Author: Ed_Cornes (Xara Group Ltd) Created: 10/10/95 Purpose: Default constructor ******************************************************************************/ OpResetSpreadOrigin::OpResetSpreadOrigin() { } /****************************************************************************** > BOOL OpResetSpreadOrigin::Init() Author: Ed_Cornes (Xara Group Ltd) Created: 10/10/95 Returns: FALSE if fails Purpose: Initilise OpResetSpreadOrigin ******************************************************************************/ BOOL OpResetSpreadOrigin::Init() { return RegisterOpDescriptor(0, _R(IDS_OPRESETSPREADORIGIN), CC_RUNTIME_CLASS(OpResetSpreadOrigin), OPTOKEN_RESETSPREADORIGIN , OpResetSpreadOrigin::GetState, 0, /* help ID */ 0, /* bubble ID */ 0 /* bitmap ID */ ); } /***************************************************************************** > void OpResetSpreadOrigin::Do(OpDescriptor* pOpDesc) Author: Ed_Cornes (Xara Group Ltd) Created: 10/10/95 Inputs: pOpDesc - not used Purpose: Sets up params to set origin to page origin and invokes OpSpreadOrigin::DoChangeOrigin() ******************************************************************************/ void OpResetSpreadOrigin::Do(OpDescriptor* pOpDesc) { Spread* pSpread = Document::GetSelectedSpread(); ERROR3IF(pSpread==NULL,"OpResetSpreadOrigin::Do() - no seleted spread"); DocCoord PageOrigin(0,0); BOOL ok = (pSpread!=NULL); if (ok) ok = pSpread->PagesCoordToSpreadCoord(&PageOrigin,DocCoord(0,0)); if (ok) ok = DoChangeOrigin(pSpread,PageOrigin); if (!ok) FailAndExecute(); End(); } /****************************************************************************** > static OpState OpResetSpreadOrigin::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) Author: Ed_Cornes (Xara Group Ltd) Created: 10/10/95 Inputs: pOpDesc - Outputs: pReasonGreyed - Returns: An OpState object ******************************************************************************/ OpState OpResetSpreadOrigin::GetState(String_256* pReasonGreyed, OpDescriptor* pOpDesc) { OpState state(FALSE,TRUE); // assume it will be greyed - for returning errors Spread* pSpread = Document::GetSelectedSpread(); if (pSpread!=NULL) { DocCoord UserOrigin = UserCoord(0,0).ToSpread(pSpread); DocCoord PageOrigin(0,0); if (pSpread->PagesCoordToSpreadCoord(&PageOrigin,DocCoord(0,0))!=FALSE) state.Greyed = (UserOrigin==PageOrigin); } else ERROR3("OpResetSpreadOrigin::GetState() - no seleted spread"); if (state.Greyed && pReasonGreyed!=NULL) pReasonGreyed->Load(_R(IDS_OPRESETSPREADORIGINGREY)); return state; } #endif