// $Id: nodetxtl.h 1535 2006-07-25 16:50:32Z 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============================ */ // The TextLine object #ifndef INC_NODETXTL #define INC_NODETXTL //#include "ink.h" - in camtypes.h [AUTOMATICALLY REMOVED] //#include "rndrgn.h" - in camtypes.h [AUTOMATICALLY REMOVED] #include "nodetxts.h" //#include "attrmgr.h" // for FormatRegion::GetTracking() - in camtypes.h [AUTOMATICALLY REMOVED] class EOLNode; class CharMetrics; class NodeGroup; class BecomeA; /******************************************************************************************** > class FormatRegion: public RenderRegion Author: Peter_Arnold (Xara Group Ltd) Created: 17/03/95 Purpose: A FormatRegion is a render region that is used during the formatting of characters. No actual rendering is done; the FormatRegion provides a simple way of managing the attribute stack. Call the init function before using the FormatRegion. This is passed the root node of the subtree to format. The Init function renders all the attributes applied to this node into the FormatRegion. You can then use the object as an attribute stack. You will want to call each nodes Format function. NOTE: you will also want to render all attributes you come across into the FormatRegion ********************************************************************************************/ class FormatRegion : public RenderRegion { CC_DECLARE_DYNAMIC(FormatRegion) FormatRegion(); ~FormatRegion(); BOOL Init(NodeRenderableInk* pFirstNode); // To be safe we override all drawing functions to to prevent drawing // Some are pure and have to be overridden // Pure drawing functions virtual void DrawPathToOutputDevice(Path *PathToRender, PathShape shapePath=PATHSHAPE_PATH) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawRect(DocRect *RectToRender) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawDragRect(DocRect *RectToRender) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawLine(const DocCoord &StartPoint, const DocCoord &EndPoint) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawPixel(const DocCoord &Point) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawBlob(DocCoord p, BlobType type) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawCross(const DocCoord &Point, const UINT32 Size) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawBitmap(const DocCoord &Point, KernelBitmap* pBitmap) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawBitmap(const DocCoord &Point, UINT32 BitmapID, UINT32 ToolID = NULL) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawBitmapBlob(const DocCoord &Point, KernelBitmap* BlobShape) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawBitmapBlob(const DocCoord &Point, ResourceID resID ) {ERROR3("Rendering into a FormatRegion");}; // Non pure ones virtual void DrawFixedSystemText(StringBase *TheText, DocRect &BoundsRect, UINT32 uFormat = DEFAULT_TEXT_FORMATTING) {ERROR3("Rendering into a FormatRegion");}; virtual void SetFixedSystemTextColours(DocColour *TextCol, DocColour *Background) {ERROR3("Rendering into a FormatRegion");}; virtual void GetFixedSystemTextSize(StringBase *TheText, DocRect *BoundsRect, double* atDpi = NULL) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawPixelRect(DocRect *RectToRender) {ERROR3("Rendering into a FormatRegion");}; virtual void DrawPixelLine(const DocCoord &StartPoint, const DocCoord &EndPoint) {ERROR3("Rendering into a FormatRegion");}; // More pure functions virtual BOOL StopRender(void) {return TRUE;}; virtual void InitClipping(void) {}; virtual void InitAttributes(void) {}; virtual void SetLineAttributes(void) {}; virtual void SetOSDrawingMode(void) {}; virtual void SetQualityLevel(void) {}; virtual INT32 CalcPixelWidth(void) {return 1;}; virtual INT32 CalcScaledPixelWidth(void) {return 1;}; public: BOOL GetCharMetrics(CharMetrics* pCharMetrics, WCHAR ch); MILLIPOINT GetCharsKerning(WCHAR chLeft, WCHAR chRight); // jwp 15/10/2000 MILLIPOINT GetTracking() { return RR_TXTTRACKING(); } Justification GetJustification() { return RR_TXTJUSTIFICATION(); } MILLIPOINT GetLineSpacing() { return RR_TXTLINESPACE(); } FIXED16 GetLineSpaceRatio(){ return ((TxtLineSpaceAttribute*)CurrentAttrs[ATTR_TXTLINESPACE].pAttr)->Ratio; } MILLIPOINT GetFontSize() { return RR_TXTFONTSIZE(); } MILLIPOINT GetBaseLineShift() { return RR_TXTBASELINE(); } MILLIPOINT GetLeftMargin() { return RR_TXTLEFTMARGIN(); } MILLIPOINT GetRightMargin() { return RR_TXTRIGHTMARGIN(); } MILLIPOINT GetFirstIndent() { return RR_TXTFIRSTINDENT(); } TxtRuler* GetRuler() { return RR_TXTRULER(); } private: std::auto_ptr m_pFormatDC; }; /******************************************************************************************** > class FormatState: public CC_CLASS_MEMDUMP Author: Martin Wuerthner Created: 21/06/06 Purpose: encapsulates state when wrapping/formatting a text line ********************************************************************************************/ class FormatState: public CC_CLASS_MEMDUMP { public: const BOOL SetCharPositions; // flag indicating whether formatting should set char positions const MILLIPOINT FitWidth; // overall width available VisibleTextNode* const pFirstVTN; // the first VTN in the line const MILLIPOINT CharPosOffset; // used for formatting only (i.e., if SetCharPositions = TRUE) const MILLIPOINT ExtraOnChars; // used for formatting only (i.e., if SetCharPositions = TRUE) const MILLIPOINT ExtraOnSpaces; // used for formatting only (i.e., if SetCharPositions = TRUE) MILLIPOINT Width; // overall width used so far // All formatted text is anchored to a tab stop. There is a notional left tab at position 0 // that anchors the start of the text. ActiveTabType/ActiveTabPos always contain information // about the currently active tab stop. TxtTabType ActiveTabType; // the type of the currently active tab stop MILLIPOINT ActiveTabPos; // its position VisibleTextNode* pLastTabVTN; // the most recently fitted tab character object (maybe NULL) // AnchorPos contains the width of the text formatted up to the most recently encountered tab // character, in other words, the starting position of the field into which the section of text // of text anchored to the currently active tab is to be formatted. MILLIPOINT AnchorPos; // When a non-left tab is encountered, RemainingSpace is set to the remaining space between the // tab character position (AnchorPos) and the position of the tab stop to which it advances // (ActiveTabPos). It is updated as text is formatted to the left of the tab stop. MILLIPOINT RemainingSpace; // if the most recently encountered tab was a Decimal tab, keep track of what its decimal point // character is and whether we have met the decimal point already WCHAR DecimalPointChar; BOOL DecimalPointFound; // default constructor (no need to initialise RemainingSpace and DecimalPointFound) FormatState(MILLIPOINT AvailableWidth, BOOL SetPositions, VisibleTextNode* pFirstNode, MILLIPOINT Indent, MILLIPOINT _CharPosOffset, MILLIPOINT _ExtraOnChars, MILLIPOINT _ExtraOnSpaces): SetCharPositions(SetPositions), FitWidth(AvailableWidth), pFirstVTN(pFirstNode), CharPosOffset(_CharPosOffset), ExtraOnChars(_ExtraOnChars), ExtraOnSpaces(_ExtraOnSpaces), Width(Indent), ActiveTabType(LeftTab), ActiveTabPos(0), pLastTabVTN(NULL), AnchorPos(Indent) {}; void AdvanceBy(MILLIPOINT Advance, BOOL IsADecimalPoint); BOOL FinishTabSection(VisibleTextNode* pLastFormattedNode, BOOL IsLastTabSection); BOOL IsAvailable(MILLIPOINT CharWidth, BOOL IsATab, BOOL IsADecimalPoint); }; /******************************************************************************************** > class TextLineInfo: public CC_CLASS_MEMDUMP Author: Ed_Cornes (Xara Group Ltd) Created: 4/2/96 Purpose: passing line level info to/from functions ********************************************************************************************/ class TextLineInfo : public CC_CLASS_MEMDUMP { CC_DECLARE_MEMDUMP(TextLineInfo); public: TextLineInfo(); MILLIPOINT SumCharAdvances; // NB does not include last char tracking Justification justification; MILLIPOINT LeftMargin; // relative to start of line MILLIPOINT RightMargin; // relative to start of line MILLIPOINT ParaLeftMargin; // left margin from line level attribute (as opposed to object property for text on path) MILLIPOINT ParaRightMargin; // (NB. - the ParaLeftMargin value comes from either the LeftMargin or the FirstLine attribute) const TxtRuler* Ruler; BOOL WordWrapping; INT32 NumChars; INT32 NumSpaces; }; /******************************************************************************************** > class TextLine: public BaseTextClass Author: Simon_Maneggio (Xara Group Ltd) Created: 21/12/94 Purpose: A TextLine gathers together all characters on a single line in a text story. The TextLine object is responsible for rendering all its character node children. It needs to do this because TextChars have no associated bounds and so they can only render themselves relative to other chars. SeeAlso: TextStory ********************************************************************************************/ class TextLine: public BaseTextClass { CC_DECLARE_DYNAMIC(TextLine) public: TextLine(); ~TextLine(); TextLine(Node* ContextNode, AttachNodeDirection Direction); void Init(); virtual Node* SimpleCopy(); void CopyNodeContents(TextLine* NodeCopy); virtual void PolyCopyNodeContents(NodeRenderable* pNodeCopy); virtual CopyType GetCopyType(); virtual INT32 ComplexCopy(CopyStage Stage, Range& RangeToCopy, Node** pOutput); virtual INT32 ComplexHide(UndoableOperation* pOp, Node* pNextNode); virtual BOOL IsSetCandidate() const { return TRUE; } virtual BOOL IsCompound() const { return TRUE; } // See also NodeCompound virtual UINT32 GetNodeSize() const; virtual void GetDebugDetails(StringBase* Str); // Can be deleted before we ship virtual String Describe(BOOL Plural, BOOL Verbose); DocRect GetBlobBoundingRect(); void RenderObjectBlobs(RenderRegion* pRRegion); void RenderTinyBlobs(RenderRegion* pRRegion); DocCoord GetTinyBlobPos(); BOOL CreateNodeGroup(NodeGroup** ppNodeGroup, FormatRegion* pFormatRegion, BecomeA* pBecomeA); static TextLine* CreateEmptyTextLine(Node* pContextNode=NULL, AttachNodeDirection Direction=FIRSTCHILD); virtual BOOL ReCacheMetrics(FormatRegion* pFormmatRegion); BOOL Format(TextStoryInfo* pStoryInfo); BOOL EnsureNextLineOfParagraphHasSameLineLevelAttrs(UndoableOperation* pUndoOp); BOOL ReCalcLineInfo(TextLineInfo* pLineInfo); BOOL PositionCharsInLine(TextLineInfo* pLineInfo); BOOL CalcBaseAndDescentLine(MILLIPOINT* pBaseLine, MILLIPOINT* pDescentLine, MILLIPOINT LastDescentLine, BOOL FirstLine); BOOL SetCharMatrices(MILLIPOINT LinePos); BOOL FitTextToPath(TextStoryInfo* pPathInfo, MILLIPOINT LinePos); BOOL Wrap(UndoableOperation* pUndoOp, MILLIPOINT WrapWidth, MILLIPOINT Indent); VisibleTextNode* FindBreakChar(MILLIPOINT FitWidth, BOOL SetCharPositions, MILLIPOINT Indent, MILLIPOINT CharPosOffset = 0, MILLIPOINT ExtraOnChars = 0, MILLIPOINT ExtraOnSpaces = 0); TextLine* FindFirstLineOfParagraph(); static BOOL IsAttrTypeLineLevel(CCRuntimeClass* pAttrType); BOOL AddChildLineLevelAttrsToSet(AttrTypeSet* pAttrSet); VisibleTextNode* FindCharAtDistAlongLine(MILLIPOINT Distance, BOOL* LeftHandSide); VisibleTextNode* FindFirstVTN() const; VisibleTextNode* FindLastVTN() const; EOLNode* FindEOLNode() const; CaretNode* FindCaret() const; TextLine* FindNextLine() const; TextLine* FindPrevLine() const; MILLIPOINT GetLastCharTracking(); BOOL WholeLineSelected(); BOOL WillLineWrapOnPath(FIXED16 xscale, MILLIPOINT PLength); // v2 file format functions virtual BOOL WritePreChildrenWeb(BaseCamelotFilter *pFilter); virtual BOOL WritePreChildrenNative(BaseCamelotFilter *pFilter); virtual BOOL WriteBeginChildRecordsWeb(BaseCamelotFilter* pFilter); virtual BOOL WriteBeginChildRecordsNative(BaseCamelotFilter* pFilter); virtual BOOL WriteEndChildRecordsWeb(BaseCamelotFilter* pFilter); virtual BOOL WriteEndChildRecordsNative(BaseCamelotFilter* pFilter); // private member access functions MILLIPOINT GetLineDescent() { return mLineDescent; } MILLIPOINT GetLineAscent() { return mLineAscent; } MILLIPOINT GetLineSize() { return mLineSize; } void SetLineDescent(MILLIPOINT Descent) { mLineDescent = Descent; } void SetLineAscent( MILLIPOINT Ascent) { mLineAscent = Ascent; } void SetLineSize( MILLIPOINT Size) { mLineSize = Size; } void UpdateLineDescent(MILLIPOINT Descent) { if (DescentmLineAscent ) mLineAscent = Ascent; } void UpdateLineSize( MILLIPOINT Size) { if ( Size>mLineSize ) mLineSize = Size; } Justification GetJustification() { return mJustification; } MILLIPOINT GetLineSpacing() { return mLineSpacing; } FIXED16 GetLineSpaceRatio() { return mLineSpaceRatio; } MILLIPOINT GetParaLeftMargin() { return mLeftMargin; } MILLIPOINT GetParaFirstIndent() { return mFirstIndent; } MILLIPOINT GetParaRightMargin() { return mRightMargin; } const TxtRuler* GetRuler() { return mpRuler; } void SetJustification( Justification justification) { mJustification = justification; } void SetLineSpacing( MILLIPOINT Spacing) { mLineSpacing = Spacing; } void SetLineSpaceRatio( FIXED16 SpaceRatio) { mLineSpaceRatio = SpaceRatio; } void SetParaLeftMargin( MILLIPOINT Margin) { mLeftMargin = Margin; } void SetParaFirstIndent(MILLIPOINT Indent) { mFirstIndent = Indent; } void SetParaRightMargin(MILLIPOINT Margin) { mRightMargin = Margin; } void SetRuler( const TxtRuler* pRuler) { if (*mpRuler != *pRuler) *mpRuler = *pRuler; } MILLIPOINT GetPosInStory() { return mPosInStory; } void SetPosInStory(MILLIPOINT pos) { mPosInStory=pos; } protected: MILLIPOINT GetEffectiveLeftMargin(); private: MILLIPOINT mLineDescent; // largest descent of any char in all fonts on the line MILLIPOINT mLineAscent; // largest ascent of any char in all fonts on the line MILLIPOINT mLineSize; // largest size of any char in all fonts on the line Justification mJustification; // cache for value read from attr stack MILLIPOINT mLineSpacing; // cache for value read from attr stack FIXED16 mLineSpaceRatio; // cache for value read from attr stack MILLIPOINT mLeftMargin; // cache for value read from attr stack MILLIPOINT mFirstIndent; // cache for value read from attr stack MILLIPOINT mRightMargin; // cache for value read from attr stack TxtRuler* mpRuler; // cache for value read from attr stack // NB - this is a list object owned by this object MILLIPOINT mPosInStory; // y position of base of line relative to story }; #endif