cdrtext.cpp

Go to the documentation of this file.

// $Id: cdrtext.cpp 1282 2006-06-09 09:46:49Z 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============================
 */
// ********* Text objects for CDR files

/*
*/

#include "camtypes.h"
#include "cdrfiltr.h"
#include "nodetxts.h"
#include "nodetxtl.h"
#include "nodetext.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "txtattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "fontman.h"

DECLARE_SOURCE("$Revision: 1282 $");

#define new CAM_DEBUG_NEW

static TCHAR *CDRDefaultFontName = "AvantGarde Bk BT";
static CDRTextStyle CDRDefaultTextStyle = {0, (72000*24)/72, FALSE, FALSE, FALSE, CDRSCRIPT_NONE,
            (1000*24)/72, 100, JLEFT};

/********************************************************************************************

>   BOOL CDRFilter::ConvertText(cdrfOffsetHeader *Header)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    converts a text object to a node. If the object has an unexpected
                format, then FormatError is set and it return *TRUE* - the return value only
                indicated environmental errors such as lack of memory
    SeeAlso:    

********************************************************************************************/

BOOL CDRFilter::ConvertText(cdrfOffsetHeader *Header)
{
    // check to see if this has an offset for text on a path
    if(FindDataInObject(Header, cdrfOBJOFFSETTYPE_PATHTEXT1) != 0
            && FindDataInObject(Header, cdrfOBJOFFSETTYPE_PATHTEXT2) != 0)
    {
        IsTextOnAPath = TRUE;
    }
    else
    {
        IsTextOnAPath = FALSE;
    }

    // hey, this is text!
    IsText = TRUE;
    IsTextStory = FALSE;

    // dispatch conversion to appropriate routine
    if(Version == CDRVERSION_3)
        return ConvertText3(Header);

    if(Version == CDRVERSION_4)
    {
        if(CDRDATA_WORD(Header->ObjectType) == cdrfOBJTYPE_TEXT)
        {
            return ConvertText4Art(Header);
        }
        else
        {
            return ConvertText4Para(Header);
        }
    }

    // if it's a text story we're fiddling with, see how big the frame is
    INT32 FrameX = 0, FrameY = 0;
    DocCoord Trans = DocCoord(0,0);
    if(Header->ObjectType == cdrfOBJTYPE_TEXTSTORY)
    {
        // find the size of the object
        cdrfTextStoryCoordData *Coords = (cdrfTextStoryCoordData *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS);
    
        if(Coords == 0)
        {
            FormatError = TRUE;
            return TRUE;
        }

        FrameX = CDRDATA_WORD(Coords->XSize);
        FrameY = CDRDATA_WORD(Coords->YSize);
TRACEUSER( "Ben", _T("Initial frame dimensions: X = %d Y = %d\n"), FrameX, FrameY);

        IsTextStory = TRUE;
    }
    else
    {
        IsTextStory = FALSE;
    }

    // OK, the header supplied here is in a block of it's own so we can aquire a new RIFF block
    // for the text info

    // the RIFF object will be at a loda chunk, which is at a one higher level than that of
    // the txsm chunk - find level we don't want to seek over
    ERROR3IF(RIFF->GetObjType() != RIFFOBJECTTYPE_CHUNK || RIFF->GetObjChunkType() != cdrT_loda,
        "CDFFilter::ConvertText called with RIFF on a non-loda chunk");
    UINT32 EndLevel = RIFF->GetObjLevel() - 1;

    // now stroll though the RIFF file
    // stop when we find a txsm chunk, and store any trfd chunks we might meet on the way
    BOOL Found = FALSE;
    do
    {
        if(RIFF->GetObjType() == RIFFOBJECTTYPE_CHUNK && RIFF->GetObjChunkType() == cdrT_txsm)
        {
            // found the text info thingy
            Found = TRUE;
        }
        else if(RIFF->GetObjType() == RIFFOBJECTTYPE_LISTSTART && RIFF->GetObjChunkType() == cdrT_trfl)
        {
            // grab the list contents
            if(!RIFF->GetListContents(&TransformChunk, &TransformChunkSize))
                return FALSE;
        }

        UpdateProgress();

        if(!Found)
            if(!RIFF->NextObject())
                return FALSE;
    
    } while(Found == FALSE && (RIFF->GetObjType() != RIFFOBJECTTYPE_LISTEND || RIFF->GetObjLevel() >= EndLevel));

    if(RIFF->GetObjType() != RIFFOBJECTTYPE_CHUNK || RIFF->GetObjChunkType() != cdrT_txsm)
    {
        FormatError = TRUE;
        return TRUE;
    }

    // get size of chunk
    INT32 TextInfoSize = RIFF->GetObjSize();
    
    // aquire the chunk data
    if(!RIFF->AquireChunkData())
        return FALSE;

    // and get a pointer to the 'nice' info chunk
    ADDR TextInfo;
    if((TextInfo = RIFF->GetAquiredData()) == 0)
    {
        return FALSE;
    }
    cdrfTextInfoHdr *TIH = (cdrfTextInfoHdr *)TextInfo;

    // make a new text story node
    TextStory *TSNode = new TextStory;

    if(TSNode == 0)
        return FALSE;
    
    // get the number of paragraphs
    UINT32 NParagraphs = CDRDATA_WORD(TIH->NParagraphs);

    // set up some variables
    INT32 Loc = sizeof(cdrfTextInfoHdr);
    INT32 FirstLineSpace = -1;
    INT32 InitialFirstLineSpace = -1;
    INT32 ThisLineSpace = 0;
    INT32 PreviousLineSpace = 0;
    INT32 MaximumLineX = 0;     // MaximumLineX and
    INT32 Lines = 1;                // Lines only used for artisitic text
    Justification Just;         // the justification

    // convert the paragraph
    UINT32 CurrentPara;
    INT32 LineX;
    for(CurrentPara = 0; CurrentPara < NParagraphs; CurrentPara++)
    {
        // set up a few things
        LineX = 0;          // current position in the line
        
        // check sizes
        if((Loc + (INT32)sizeof(cdrfTextInfoParaHdr)) > TextInfoSize)
            break;
    
        // get paragraph header info
        cdrfTextInfoParaHdr *ParaHdr = (cdrfTextInfoParaHdr *)(TextInfo + Loc);
        Loc += sizeof(cdrfTextInfoParaHdr);

        // sort out font style definitions
        INT32 NFontDefns = CDRDATA_WORD(ParaHdr->NFontDefns);

        if((Loc + ((INT32)sizeof(cdrfTextInfoFontDefn) * NFontDefns)) > TextInfoSize)
            break;
    
        cdrfTextInfoFontDefn *FontDefns = (cdrfTextInfoFontDefn *)(TextInfo + Loc);
        Loc += (sizeof(cdrfTextInfoFontDefn) * NFontDefns);

        // get some memory for the converted font styles
        if(NFontDefns <= 0)
            break;

        CDRTextStyle *Styles = new CDRTextStyle[NFontDefns];
        
        // convert the first definiton from the style
        if(!GetTextStyleFromCDRStyle(&Styles[0], ParaHdr->Style))
            goto NoMemory;

        // store the justificationness
        Just = Styles[0].Just;

        // just in case of random Corel behaviour...
        PreviousLineSpace = (Styles[0].FontSize * 12) / 10;

        // go through translating all the other styles
        for(INT32 l = 1; l < NFontDefns; l++)
        {
            if(!GetTextStyleFromDefn(&Styles[l], &FontDefns[l], &Styles[0]))
                return FALSE;
        }

        // get the paragraph info
        if((Loc + (INT32)sizeof(cdrfTextInfoParaInfo)) > TextInfoSize)
            break;
        
        cdrfTextInfoParaInfo *PInfo = (cdrfTextInfoParaInfo *)(TextInfo + Loc);

        Loc += sizeof(cdrfTextInfoParaInfo);
        
        INT32 NChars = CDRDATA_WORD(PInfo->NChars);

        // sort out the character array
        if((Loc + ((INT32)sizeof(cdrfTextInfoChar) * NChars)) > TextInfoSize)
            break;
        
        cdrfTextInfoChar *Chars = (cdrfTextInfoChar *)(TextInfo + Loc);

        Loc += (sizeof(cdrfTextInfoChar) * NChars);
    
        // make a new text line for this paragraph
        TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD);
        if(CurrentLine == 0)
            goto NoMemory;

        // and run through adding all those nice characters
        INT32 CurrentChar;
        for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++)
        {
            BOOL NewLine = FALSE;       // whether to create a new line here

            if(IsTextStory == FALSE && CDRDATA_WORD(Chars[CurrentChar].Code) == cdrfTEXT_NEWLINE)
            {
                // update a couple of artisitic text only variables
                Lines++;

                if(LineX > MaximumLineX)
                    MaximumLineX = LineX;

                // create a new line
                NewLine = TRUE;
            }
            
            // find the style of the character
            INT32 Style = ((CDRDATA_WORD(Chars[CurrentChar].Info)) & cdrfTEXTINFOCHAR_INFO_DEFNMASK)
                        >> cdrfTEXTINFOCHAR_INFO_DEFNMASKSBY;

            // create it
            if(CDRDATA_WORD(Chars[CurrentChar].Code) >= ' ')
            {
                TextChar *C = new TextChar(CurrentLine, LASTCHILD, CDRDATA_WORD(Chars[CurrentChar].Code));

                if(C == 0)
                    goto NoMemory;

                if(Style < 0 || Style >= NFontDefns)
                    Style = 0;

                // apply attributes
                if(!ApplyTextAttr(C, &Styles[Style], 0 /*&Styles[0]*/))     // for now, we can't base attributes on anything 'cos the optimiser can't hack it
                    goto NoMemory;
            }

            // add the character width
            LineX += CDRDATA_SWORD(Chars[CurrentChar].XSize);

            // update this line's spacing thingy
            if(Styles[Style].LineSpace > ThisLineSpace)
                ThisLineSpace = Styles[Style].LineSpace;

            // sort out first line spaceing thing
            if(InitialFirstLineSpace == -1)
                InitialFirstLineSpace = Styles[Style].LineSpace;

            if(NewLine)
            {
                // apply the line spacing attribute - make a font size attribute
                if(ThisLineSpace < 512)
                    ThisLineSpace = PreviousLineSpace;
                TxtLineSpaceAttribute Attr((FIXED16)(((double)Styles[0].ParaLineSpacePercent) /* * 1.2*/ / 100));

                // attach
                if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
                    return FALSE;

                // add an EOL
                EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);
                if(EOL == 0)
                    goto NoMemory;
                // make a new line
                CurrentLine = new TextLine(TSNode, LASTCHILD);
                if(CurrentLine == 0)
                    goto NoMemory;

                // sort out first line spacing thing
                if(FirstLineSpace == -1)
                    FirstLineSpace = ThisLineSpace;

                // reset things
                LineX = 0;
                PreviousLineSpace = ThisLineSpace;
                ThisLineSpace = 0;
            }
        }

        // sort out first line spaceing thing
        if(FirstLineSpace == -1)
            FirstLineSpace = ThisLineSpace;

        // apply the line spacing attribute - make a font size attribute
        if(ThisLineSpace < 512)
            ThisLineSpace = PreviousLineSpace;
        TxtLineSpaceAttribute Attr((FIXED16)(((double)Styles[0].ParaLineSpacePercent)  / 100));
    
        // attach
        if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
            return FALSE;

        // pop on an end of line node
        EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);

        if(EOL == 0)
            goto NoMemory;

        // get rid of the font styles
        delete [] Styles;

        PreviousLineSpace = ThisLineSpace;
    }

    // pop a caret at the end of the last line
    {
        Node *LastLine = TSNode->FindLastChild();

        if(LastLine == 0)
            goto FormError;

        Node *LastLineNode = LastLine->FindLastChild();

        ERROR3IF(LastLineNode == 0, "Line node doesn't have any children");
        ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node");
        
        CaretNode *C = new CaretNode(LastLineNode, PREV);
        if(C == 0)
            goto NoMemory;
    }

    // set up maximumlinex - only valid for artisitic text
    if(LineX > MaximumLineX)
        MaximumLineX = LineX;

    // set up a bounding box for this text object and
    // if this is a text story, translate it down a bit
    // so that the top of the first line is at the top of the frame
    if(IsTextStory)
    {
        if(FirstLineSpace == -1)
            goto FormError;         // no first line? How strange...

        // work out the distance to move the text line down = the first line un 120%ed
        INT32 Down = (FirstLineSpace * 10) / 12;

        // work out the rightness shifting
        INT32 Right = 0;
        if(Just == JCENTRE)
        {
            Right = (FrameX / 2) * CDRCOORDS_TO_MILLIPOINTS;
        }
        else if(Just == JRIGHT)
        {
            Right = FrameX * CDRCOORDS_TO_MILLIPOINTS;
        }

        // transform the story
        TSNode->SetStoryMatrix(Matrix(Trans.x+Right, Trans.y-Down));

        // set the format width
        TSNode->SetImportFormatWidth(FrameX * CDRCOORDS_TO_MILLIPOINTS);
TRACEUSER( "Ben", _T("Import format width initially %d\n"), TSNode->GetImportFormatWidth());

        // bounding box for text story
        DocRect BBox = DocRect(Trans.x, Trans.y - (FrameY * CDRCOORDS_TO_MILLIPOINTS),
                Trans.x + (FrameX * CDRCOORDS_TO_MILLIPOINTS), Trans.y);

        TextBBoxes.Add(TSNode, &BBox, JLEFT);
    }
    else
    {
        // set the matrix of the story
        TSNode->SetStoryMatrix(Matrix(0,0));

        // bounding box for a text object
        DocRect BBox = DocRect(0, 0 - FirstLineSpace * Lines,
                (MaximumLineX * CDRCOORDS_TO_MILLIPOINTS), FirstLineSpace);

        TextBBoxes.Add(TSNode, &BBox, Just);

        // see if this is linked to a path
        CheckTextForLinks(TSNode, Header);
    }

    // set some essential variables
    ObjFilled = TRUE;
    ObjStroked = FALSE;

    // all done return...
    pMadeNode = TSNode;

    return TRUE;

NoMemory:
    TSNode->CascadeDelete();
    delete TSNode;
    
    return FALSE;

FormError:
    FormatError = TRUE;
    TSNode->CascadeDelete();
    delete TSNode;
    
    return TRUE;
}


/********************************************************************************************

>   BOOL CDRFilter::ConvertText4Art(cdrfOffsetHeader *Header)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    converts a version 4 artisitic text object
    SeeAlso:    

********************************************************************************************/

BOOL CDRFilter::ConvertText4Art(cdrfOffsetHeader *Header)
{
    // get the data from this object
    cdrfTextHeaderV4 *Hdr = (cdrfTextHeaderV4 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS);

    // it has got some coords, hasn't it?
    if(Hdr == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }
    // find pointer to the characters
    cdrfTextCharV4 *ThisChar = (cdrfTextCharV4 *)(Hdr + 1);

    // get the base style
    CDRTextStyle BaseStyle;

    WORD *StyleRef = (WORD *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_STYLE);
    if(StyleRef == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }

    if(!GetTextStyleFromCDRStyle(&BaseStyle, CDRDATA_WORD(*StyleRef)))
        return FALSE;

    // make a new text story node
    TextStory *TSNode = new TextStory;

    if(TSNode == 0)
        return FALSE;

    // run through the text...
    INT32 NChars = CDRDATA_WORD(Hdr->NCharacters);
    INT32 CurrentChar;
    INT32 MaximumLineSpace = BaseStyle.LineSpace;
    INT32 Lines = 1;
    INT32 Depth = 0;

    // make a new text line
    TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD);
    if(CurrentLine == 0)
        goto NoMemory;

    for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++)
    {
        BOOL HasStyles = FALSE;

        if(ThisChar->Info != 0)
            HasStyles = TRUE;

        if(ThisChar->Code >= ' ')
        {
            TextChar *C = new TextChar(CurrentLine, LASTCHILD, ThisChar->Code);

            if(C == 0)
                goto NoMemory;

            // apply attributes
            if(HasStyles)
            {
                // it's got styles of it's own, find and apply them
                cdrfTextCharStyledV4 *SC = (cdrfTextCharStyledV4 *)ThisChar;

                CDRTextStyle ThisStyle;

                if(!GetTextStyleFromChar4(&ThisStyle, SC, &BaseStyle))
                    return FALSE;

                if(!ApplyTextAttr(C, &ThisStyle, 0))
                    goto NoMemory;
        
                if(ThisStyle.LineSpace > MaximumLineSpace)
                    MaximumLineSpace = ThisStyle.LineSpace;
            }
            else
            {
                // just apply the normal attributes
                if(!ApplyTextAttr(C, &BaseStyle, 0))
                    goto NoMemory;
            }
        }

        if(ThisChar->Code == cdrfTEXT_NEWLINE)
        {
            // create a new line...
            // apply the line spacing attribute - make a font size attribute
//          TxtLineSpaceAttribute Attr(MaximumLineSpace);
            TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent)  / 100));

            // attach
            if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
                return FALSE;

            // add an EOL
            EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);
            if(EOL == 0)
                goto NoMemory;

            // make a new line
            CurrentLine = new TextLine(TSNode, LASTCHILD);
            if(CurrentLine == 0)
                goto NoMemory;

            // set things
            Lines++;
            Depth += MaximumLineSpace;
            MaximumLineSpace = BaseStyle.LineSpace;
        }

        if(HasStyles)
        {
            // it's got more than normal bytes in it, so add a few more than usual
            ThisChar = (cdrfTextCharV4 *)(((cdrfTextCharStyledV4 *)ThisChar) + 1);
        }
        else
        {
            // just a normal character, so simply increment it
            ThisChar++;
        }
    }

    // pop a line space attribute on the last line
    {
//      TxtLineSpaceAttribute Attr(MaximumLineSpace);
        TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent)  / 100));

        // attach
        if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
            return FALSE;
    }

    Depth += MaximumLineSpace;

    // finish the last line with an end of line node
    {
        EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);

        if(EOL == 0)
            goto NoMemory;

        // pop a caret at the end of the last line
        Node *LastLine = TSNode->FindLastChild();

        if(LastLine == 0)
            goto FormError;

        Node *LastLineNode = LastLine->FindLastChild();

        ERROR3IF(LastLineNode == 0, "Line node doesn't have any children");
        ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node");
        
        CaretNode *C = new CaretNode(LastLineNode, PREV);
        if(C == 0)
            goto NoMemory;
    }

    // set the matrix of the story
    {
        TSNode->SetStoryMatrix(Matrix(0,0));

        // bounding box for a artisitic text object - approximate it's width
        INT32 Width = (MaximumLineSpace * NChars) / (Lines * 3);

        DocRect BBox = DocRect(0, 0 - Depth, Width, MaximumLineSpace);

        TextBBoxes.Add(TSNode, &BBox, BaseStyle.Just);
    }

    // check it for paths...
    CheckTextForLinks(TSNode, Header);
    
    // set some essential variables
    ObjFilled = TRUE;
    ObjStroked = FALSE;
    IsTextStory = FALSE;

    // all done, return...
    pMadeNode = TSNode;

    return TRUE;

NoMemory:
    TSNode->CascadeDelete();
    delete TSNode;
    
    return FALSE;

FormError:
    FormatError = TRUE;
    TSNode->CascadeDelete();
    delete TSNode;
    
    return TRUE;
}


/********************************************************************************************

>   BOOL CDRFilter::ConvertText4Para(cdrfOffsetHeader *Header)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    converts a version 4 paragraph text object
    SeeAlso:    

********************************************************************************************/

BOOL CDRFilter::ConvertText4Para(cdrfOffsetHeader *Header)
{
    // get the data from this object
    cdrfParaTextHeaderV4 *Hdr = (cdrfParaTextHeaderV4 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS);

    // set the var...
    IsTextStory = TRUE;

    // it has got some coords, hasn't it?
    if(Hdr == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }


    // find out what text item we need
    if(LinkTable == 0)
    {
        // no link table, oh dear
        FormatError = TRUE;
        return TRUE;
    }

    cdrfLinkTableHdr *th = (cdrfLinkTableHdr *)LinkTable;

    INT32 Entries = CDRDATA_WORD(th->Entries);
    BOOL Found = FALSE;
    WORD *Offsets = (WORD *)(LinkTable + CDRDATA_WORD(th->OffsetsOffset));
    cdrfLinkTableEntryTextV4 *En;
    for(INT32 l = 0; l < Entries; l++)
    {
        En = (cdrfLinkTableEntryTextV4 *)(LinkTable + CDRDATA_WORD(Offsets[l]));
    
        if(CDRDATA_WORD(En->Type) == cdrfLINKTABLEENTRYV4_TEXT &&
                CDRDATA_WORD(En->ObjectSerial) == SerialNumber)
        {
            Found = TRUE;
            break;
        }
    }

    if(Found == FALSE)
    {
        FormatError = TRUE;
        return TRUE;
    }
    
    // locate the text item with those attributes
    CDRVectorStoredItem *Item = (CDRVectorStoredItem *)TextV4.GetHead();
    
    // go through the list of items searching for the reference number given
    while(Item != 0)
    {
        if(Item->Reference == CDRDATA_WORD(En->TextID))
        {
            // OK, we found it...
            break;
        }

        Item = (CDRVectorStoredItem *)TextV4.GetNext(Item);
    }

    if(Item == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }

    Node *Text = Item->Objects;

    // find the base attributes
    CDRTextStyle BaseStyle;

    WORD *StyleRef = (WORD *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_STYLE);
    if(StyleRef == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }

    if(!GetTextStyleFromCDRStyle(&BaseStyle, CDRDATA_WORD(*StyleRef)))
        return FALSE;
    
    // get the maximum height of the first line
    ERROR2IF(!IS_A(Text, TextLine), FALSE, "Node in text list is not a text line");

    // apply attributes to the lines
    TextLine *CurrentLine = (TextLine *)Text;
    while(CurrentLine != 0)
    {
        if(IS_A(CurrentLine, TextLine))
        {
/*          Node *pNode = CurrentLine->FindFirstChild();

            while(pNode != 0)
            {
                if(IS_A(pNode, TextChar))
                {
                    if(!ApplyTextAttr(pNode, &BaseStyle, 0))
                        return FALSE;
                }

                pNode = pNode->FindNext();
            }
*/
            // attach the line spacing onto it
            TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent)  / 100));

            if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
                return FALSE;
        }
        
        CurrentLine = (TextLine *)CurrentLine->FindNext();
    }

    // add it to a text story
    TextStory *TSNode = new TextStory;
    if(TSNode == 0)
        return FALSE;

    Text->InsertChainSimple(TSNode, FIRSTCHILD);

    // remove references to the nodes now inserted from the item
    Item->Objects = 0;

    // set the matrix and add the bbox
    {
        INT32 FirstLineSpace = Item->BBox.hi.y;     // get the line spacing from the bbox defn

        // get the frame size
        INT32 FrameX = CDRDATA_WORD(Hdr->FrameX) * CDRCOORDS_TO_MILLIPOINTS;
        INT32 FrameY = CDRDATA_WORD(Hdr->FrameY) * CDRCOORDS_TO_MILLIPOINTS;

        // work out the distance to move the text line down = the first line un 120%ed
        INT32 Down = (FirstLineSpace * 10) / 12;

        // work out the shift...
        INT32 Right = 0;
        if(BaseStyle.Just == JCENTRE)
        {
            Right = FrameX / 2;
        }
        else if(BaseStyle.Just == JRIGHT)
        {
            Right = FrameX;
        }

        
        // transform the story
        TSNode->SetStoryMatrix(Matrix(Right,-Down));

        // bounding box for text story
        DocRect BBox = DocRect(0, 0 - FrameY, FrameX, 0);

        TextBBoxes.Add(TSNode, &BBox, JLEFT);

        // set it's width to be formatted to
        TSNode->SetImportFormatWidth(FrameX);
    }

    // delete the item
    delete TextV4.RemoveItem(Item);

    // set a few variables
    pMadeNode = TSNode;
    ObjFilled = TRUE;
    ObjStroked = FALSE;

    return TRUE;
}


/********************************************************************************************

>   BOOL CDRFilter::GetTextStyleFromChar4(CDRTextStyle *TS, cdrfTextCharStyledV4 *Char, CDRTextStyle *BasedOn)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    gets a text style from a styled version 4 text character
    SeeAlso:    

********************************************************************************************/

BOOL CDRFilter::GetTextStyleFromChar4(CDRTextStyle *TS, cdrfTextCharStyledV4 *Char, CDRTextStyle *BasedOn)
{
    if(BasedOn != 0)
        *TS = *BasedOn;
    else
        *TS = CDRDefaultTextStyle;

    // font name
    if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_FONTNAME) != 0)
    {
/*      TCHAR *FontName = GetFontName(Char->FontRef);
        if(FontName != 0)
        {
            TS->FontName = FontName;
        }
*/
        TS->FontReference = CDRDATA_DWORD(Char->FontRef);
    }

    // font size
    if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_FONTSIZE) != 0)
    {
        if(CDRDATA_WORD(Char->FontSize) != 0)
        {
            TS->FontSize = CDRDATA_WORD(Char->FontSize) * CDRCOORDS_TO_MILLIPOINTS;
        }
    }

    // update line spacing
    TS->LineSpace = (TS->FontSize * (12 * TS->ParaLineSpacePercent)) / 1000;

    // weight
    if((CDRDATA_WORD(Char->Changes) & cdrfSTYLECHANGEV4_WEIGHT) != 0)
    {
        switch(CDRDATA_WORD(Char->FontType))
        {
            case cdrfFONTTYPEV4_BOLD:
                TS->Bold = TRUE;
                TS->Italic = FALSE;
                break;

            case cdrfFONTTYPEV4_ITALIC:
                TS->Bold = FALSE;
                TS->Italic = TRUE;
                break;

            case cdrfFONTTYPEV4_BOLDITALIC:
                TS->Bold = TRUE;
                TS->Italic = TRUE;
                break;

            default:
                TS->Bold = FALSE;
                TS->Italic = FALSE;
                break;
        }
    }
    
    return TRUE;
}

/********************************************************************************************

>   BOOL CDRFilter::ConvertText3(cdrfOffsetHeader *Header)

    Author:     Ben_Summers (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24 03 95
    Inputs:     none
    Returns:    error flag
    Purpose:    converts a version 3 text object to a node. If the object has an unexpected
                format, then FormatError is set and it return *TRUE* - the return value only
                indicated environmental errors such as lack of memory
    SeeAlso:    

********************************************************************************************/

BOOL CDRFilter::ConvertText3(cdrfOffsetHeader *Header)
{
    // is it a text story?
    if(Header->ObjectType == (cdrfOBJTYPE_TEXTSTORY - cdrfOBJTYPE_V3ADD))
        IsTextStory = TRUE;

    // get the data from this object
    cdrfTextHeaderV3 *Hdr = (cdrfTextHeaderV3 *)FindDataInObject(Header, cdrfOBJOFFSETTYPE_COORDS);

    // it has got some coords, hasn't it?
    if(Hdr == 0)
    {
        FormatError = TRUE;
        return TRUE;
    }
//TRACEUSER( "Ben", _T("FrameX = %d, FrameY = %d\n"), Hdr->FrameX, Hdr->FrameY);

    INT32 FrameX = CDRDATA_WORD(Hdr->FrameX) * CDRCOORDS_TO_MILLIPOINTS;
    INT32 FrameY = CDRDATA_WORD(Hdr->FrameY) * CDRCOORDS_TO_MILLIPOINTS;

    // find pointer to the characters
    cdrfTextCharV3 *ThisChar = (cdrfTextCharV3 *)(Hdr + 1);

    // get the base style
    CDRTextStyle BaseStyle;

    if(!GetTextStyle3(&BaseStyle, CDRDATA_WORD(Hdr->BaseFontStyle)))
        return FALSE;

    // add the justifcation stuff to it
    TRACEUSER( "Ben", _T("Justificatoin V3 = %d\n"), Hdr->Justification);
    switch(Hdr->Justification)
    {
        case cdrfJUSTIFICATIONV3_LEFT:
        default:
            BaseStyle.Just = JLEFT;
            break;

        case cdrfJUSTIFICATIONV3_CENTRE:
            BaseStyle.Just = JCENTRE;
            break;

        case cdrfJUSTIFICATIONV3_RIGHT:
            BaseStyle.Just = JRIGHT;
            break;
    }
    
    // make a new text story node
    TextStory *TSNode = new TextStory;

    if(TSNode == 0)
        return FALSE;

    // run through the text...
    INT32 NChars = CDRDATA_WORD(Hdr->NCharacters);
    INT32 CurrentChar;
    INT32 MaximumLineSpace = BaseStyle.LineSpace;
    INT32 Lines = 1;
    INT32 Depth = 0;

    // make a new text line
    TextLine *CurrentLine = new TextLine(TSNode, LASTCHILD);
    if(CurrentLine == 0)
        goto NoMemory;

    for(CurrentChar = 0; CurrentChar < NChars; CurrentChar++)
    {
        BOOL HasStyles = FALSE;

        if(ThisChar->Info != 0)
            HasStyles = TRUE;

        if(ThisChar->Code >= ' ')
        {
            TextChar *C = new TextChar(CurrentLine, LASTCHILD, ThisChar->Code);

            if(C == 0)
                goto NoMemory;

            // apply attributes
            if(HasStyles)
            {
                // it's got styles of it's own, find and apply them
                cdrfTextCharStyledV3 *SC = (cdrfTextCharStyledV3 *)ThisChar;

                CDRTextStyle ThisStyle;

                if(!GetTextStyle3(&ThisStyle, CDRDATA_WORD(SC->Style), &BaseStyle))
                    return FALSE;

                if(!ApplyTextAttr(C, &ThisStyle, 0))
                    goto NoMemory;
        
                if(ThisStyle.LineSpace > MaximumLineSpace)
                    MaximumLineSpace = ThisStyle.LineSpace;
            }
            else
            {
                // just apply the normal attributes
                if(!ApplyTextAttr(C, &BaseStyle, 0))
                    goto NoMemory;
            }
        }

        if(ThisChar->Code == cdrfTEXT_NEWLINE)
        {
            // create a new line...
            // apply the line spacing attribute - make a font size attribute
//          TxtLineSpaceAttribute Attr(MaximumLineSpace);
            TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent)  / 100));

            // attach
            if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
                return FALSE;

            // add an EOL
            EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);
            if(EOL == 0)
                goto NoMemory;

            // make a new line
            CurrentLine = new TextLine(TSNode, LASTCHILD);
            if(CurrentLine == 0)
                goto NoMemory;

            // set things
            Lines++;
            Depth += MaximumLineSpace;
            MaximumLineSpace = BaseStyle.LineSpace;
        }

        if(HasStyles)
        {
//TRACEUSER( "Ben", _T("Char has styles, code %d (%c)\n"), ThisChar->Code, ThisChar->Code); 
            // it's got more than normal bytes in it, so add a few more than usual
            ThisChar = (cdrfTextCharV3 *)(((cdrfTextCharStyledV3 *)ThisChar) + 1);
        }
        else
        {
//TRACEUSER( "Ben", _T("Char, code %d (%c)\n"), ThisChar->Code, ThisChar->Code); 
            // just a normal character, so simply increment it
            ThisChar++;
        }
    }

    // pop a line space attribute on the last line
    {
//      TxtLineSpaceAttribute Attr(MaximumLineSpace);
        TxtLineSpaceAttribute Attr((FIXED16)(((double)BaseStyle.ParaLineSpacePercent)  / 100));

        // attach
        if(!ApplyTextAttrDoApply(CurrentLine, &Attr, FALSE))
            return FALSE;
    }

    Depth += MaximumLineSpace;

    // finish the last line with an end of line node
    {
        EOLNode *EOL = new EOLNode(CurrentLine, LASTCHILD);

        if(EOL == 0)
            goto NoMemory;

        // pop a caret at the end of the last line
        Node *LastLine = TSNode->FindLastChild();

        if(LastLine == 0)
            goto FormError;

        Node *LastLineNode = LastLine->FindLastChild();

        ERROR3IF(LastLineNode == 0, "Line node doesn't have any children");
        ERROR3IF(!LastLineNode->IsKindOf(CC_RUNTIME_CLASS(EOLNode)), "Last entry of a line is not an EOL node");
        
        CaretNode *C = new CaretNode(LastLineNode, PREV);
        if(C == 0)
            goto NoMemory;
    }

    if(IsTextStory)
    {
        // get a first line height
        INT32 FirstLineHeight = (BaseStyle.LineSpace * 10) / 12;

        // work out the rightness shifting
        INT32 Right = 0;
        if(BaseStyle.Just == JCENTRE)
        {
            Right = FrameX / 2;
        }
        else if(BaseStyle.Just == JRIGHT)
        {
            Right = FrameX;
        }

        // set the matrix of the story
        TSNode->SetStoryMatrix(Matrix(Right, -FirstLineHeight));

        // bounding box for a text frame
        DocRect BBox = DocRect(0, 0 - FrameY, FrameX, 0);

        TextBBoxes.Add(TSNode, &BBox, JLEFT);
    
        // set it's width to be formatted to
        TSNode->SetImportFormatWidth(FrameX);
    }
    else
    {
        // set the matrix of the story
        TSNode->SetStoryMatrix(Matrix(0,0));

        // bounding box for a artisitic text object - approximate it's width
        INT32 Width = (MaximumLineSpace * NChars) / (Lines * 3);

        DocRect BBox = DocRect(0, 0 - Depth, Width, MaximumLineSpace);

        TextBBoxes.Add(TSNode, &BBox, BaseStyle.Just);
    
        // check it for path on a text
        CheckTextForLinks(TSNode, Header);
    }

    // set some essential variables
    ObjFilled = TRUE;
    ObjStroked = FALSE;

    // all done, return...
    pMadeNode = TSNode;

    return TRUE;

NoMemory:
    TSNode->Cas