attrmgr.cpp

Go to the documentation of this file.

// $Id: attrmgr.cpp 1445 2006-07-14 20:15:02Z phil $
/* @@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============================
 */

/*
//*/ 

// Include files 
#include "camtypes.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "mario.h"
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "toollist.h"
//#include "simon.h"
#include "attrappl.h"
#include "optsmsgs.h"
//#include "resource.h"
#include "qualattr.h"
//#include "jason.h"
#include "nodetext.h"
//#include "will.h"
#include "helpuser.h"           // for the SetNextMsgHelpContext function
#include "filltool.h"
#include "ndoptmz.h"
#include "colormgr.h"
#include "attrmap.h"
#include "isetattr.h"
#include "strkattr.h"
#include "unicdman.h"
#include "fontman.h"

//#include "will2.h"

#include "userattr.h"
#include "webattr.h"

#include "nodeshad.h"
//#include "gerry.h"

#include "attrbev.h"
#include "nodeshad.h"
#include "brshattr.h"
#include "fthrattr.h"
#include "clipattr.h"
#include "lineattr.h"
#include "coldlog.h"

//#include "cxfrec.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "cxftags.h"
#include "ophist.h"

DECLARE_SOURCE("$Revision: 1445 $");

CC_IMPLEMENT_DYNAMIC(CurrentAttrChangedMsg, Msg) 

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW  

const INT32 AttributeTableGranularity = 20;

// WEBSTER - markn 14/8/97
// Webster 2 uses the attrs last applied by default

#ifdef WEBSTER
// Static attribute preference variables. They have the same names as the preference
BOOL AttributeManager::LastAttrAppliedBecomesCurrent =1;
#else
// Static attribute preference variables. They have the same names as the preference
BOOL AttributeManager::LastAttrAppliedBecomesCurrent = 0;
#endif // WEBSTER

// WEBSTER - markn 6/12/96
// Don't ask the user if they want to set the current attr
#ifdef WEBSTER
BOOL AttributeManager::AskBeforeSettingCurrentAttr   =0;
#else
BOOL AttributeManager::AskBeforeSettingCurrentAttr   =1;
#endif // WEBSTER

BOOL AttributeManager::SendMessages = 1;

BOOL AttributeManager::ShouldAskAboutContoneColours = 1;
BOOL AttributeManager::HaveAskedAboutContoneColours = 0;
BOOL AttributeManager::UserCancelledContoneColours = 0;

// Table variables (table is initially empty)
UINT32          AttributeManager::AttributeTableSize = 0;
UINT32          AttributeManager::NumAttributes      = 0;
AttributeEntry *AttributeManager::DefaultAttrValues  = NULL;
NodeTypeEntry  *AttributeManager::DefaultNodeAttrs   = NULL;

// Default black/white. Defined as RGB so they will separate.
// These are reinitialised in RegisterBasicAttributes to be CMYK
// (because we can't do CMYK static initialisations easily)
DocColour AttributeManager::DefaultBlack = DocColour(0L, 0L, 0L);
DocColour AttributeManager::DefaultWhite = DocColour(255L, 255L, 255L);

NodeRenderableInk* AttributeManager::pLastNodeAppliedTo = NULL;
DocRect AttributeManager::LastAppliedBounds = DocRect(0,0,0,0);


static BOOL UseLastAttrApplied = FALSE;

AttributeManager::AttributeManager() 
{
}



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

    static void AttributeManager::FindDefaultColour(ColourList *ColList,
                                                    UINT32 NameResID,  DocColour *Result)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    8/12/94
    Inputs:     ColList - The colour list in which the default should reside
                NameResID - the ID of the name string for the desired default
                colour (see below)

    Outputs:    (An appropriate colour may have been added to ColList if necessary)
                Result - Is filled in with an appropriate colour. In the case
                of total failure, this may be an immediate DocColour, but will always
                be set to a safe/valid default.
    Returns:    -
    Purpose:    Used in initialisation of default attributes, and when ensuring no
                current attributes use deleted colour(s), to find a suitable default
                colour to use. Two default colours are currently provided, accessed
                by passing in NameResID of _R(IDS_WHITENAME), _R(IDS_BLACKNAME), in order to
                get the default white or black colour respectively.

    Errors:     ERROR3 if Result==NULL.
                Otherwise, will always return a valid result - even if it failed
                to allocate memory for a new IndexedColour, it'll return safely.

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

// Accuracy of colour matching - same value as Tim uses in importer for 'fuzzy match'
// of the colour.
#define COL_ACCURACY (0.001)

void AttributeManager::FindDefaultColour(ColourList *ColList,
                                         UINT32 NameResID,
                                         DocColour *Result)
{
    ERROR3IF(Result == NULL, "AttrMgr: FindDefaultColour - NULL Result param is illegal");
    if (Result == NULL)
        return;

    // Generate an appropriate colour definition for the desired default colour
    ColourRGBT DesiredDef;          // Existing colour we wish to match (RGB black)
    ColourHSVT DefaultDef;          // Definition, if we are forced to create a new colour (HSV black)
    ColourCMYK CMYKBlack;           // CMYK definition for black
    ColourCMYK CMYKWhite;           // CMYK definition for white

    DesiredDef.Red = DesiredDef.Green = DesiredDef.Blue = DesiredDef.Transparent = 0;
    DefaultDef.Hue = DefaultDef.Saturation = DefaultDef.Value = DefaultDef.Transparent = 0;
    CMYKBlack.Cyan = CMYKBlack.Magenta = CMYKBlack.Yellow = 0;
    CMYKBlack.Key = FIXED24(1.0);
    CMYKWhite.Cyan = CMYKWhite.Magenta = CMYKWhite.Yellow = CMYKWhite.Key = 0;


    if (NameResID ==_R(IDS_BLACKNAME))
        // We want the default black to be CMYK so overprint/seps work
        *Result = DocColour(COLOURMODEL_CMYK, (ColourGeneric *) &CMYKBlack);
    else if (NameResID == _R(IDS_WHITENAME))
        // We want the default white to be CMYK so overprint/seps work
    {
        *Result = DocColour(COLOURMODEL_CMYK, (ColourGeneric *) &CMYKWhite);
        // I need to define the desired colour to make the search work OK.
        DesiredDef.Red = DesiredDef.Green = DesiredDef.Blue = FIXED24(1.0);
        DefaultDef.Value = FIXED24(1.0);
    }
    else if (NameResID == _R(IDS_REDNAME))
    {
        DesiredDef.Red = FIXED24(1.0);
        DefaultDef.Saturation = DefaultDef.Value = FIXED24(1.0);
    }
    else if (NameResID == _R(IDS_YELLOWNAME))
    {
        DesiredDef.Red = DesiredDef.Green = FIXED24(1.0);
        DefaultDef.Hue = FIXED24(1.0 / 6.0);                        // 60 degree hue.
        DefaultDef.Saturation = DefaultDef.Value = FIXED24(1.0);
    }
    else
    {
        // Fill in result with an appropriate Immediate colour in case we fail
        *Result = DocColour(COLOURMODEL_HSVT, (ColourGeneric *) &DefaultDef);
    }

    if (ColList != NULL)
    {   
        // Try to find a colour style of appropriate appearance in our colour list
        ColourContext *CCRGB = ColourContext::GetGlobalDefault(COLOURMODEL_RGBT);
        if (CCRGB == NULL)
        {
            ERROR3("AttrMgr: FindDefault Colour - Failed to get RGB Colour Context");
            return;
        }

        // Search the colour list to see if an existing colour is close enough to the desired
        // colour to use it.
        IndexedColour *NewDefault = (IndexedColour *) ColList->GetHead();
        ColourRGBT RGBDef;

        while (NewDefault != NULL)
        {
            if (!NewDefault->IsDeleted())       // If this colour is alive...
            {
                // Convert this colour to RGB, and see if it looks like our default
                // If it is, we drop out with NewDefault still pointing at it.
                CCRGB->ConvertColour(NewDefault, (ColourGeneric *) &RGBDef);

                if ((ABS(RGBDef.Red   - DesiredDef.Red))   <= FIXED24(COL_ACCURACY) && 
                    (ABS(RGBDef.Green - DesiredDef.Green)) <= FIXED24(COL_ACCURACY) && 
                    (ABS(RGBDef.Blue  - DesiredDef.Blue))  <= FIXED24(COL_ACCURACY))
                    break;
            }

            NewDefault = (IndexedColour *) ColList->GetNext(NewDefault);
        }

        // If we failed to find a style, create a local colour instead
        if (NewDefault == NULL)
        {
            if (NameResID == _R(IDS_BLACKNAME))
                NewDefault = new INDEXEDCOLOUR_CMYK(&CMYKBlack);
            else if (NameResID == _R(IDS_WHITENAME))
                NewDefault = new INDEXEDCOLOUR_CMYK(&CMYKWhite);
            else
                NewDefault = new INDEXEDCOLOUR_HSVT(&DefaultDef);

            if (NewDefault == NULL)
            {
                ERROR3("AttrMgr: FindDefaultColour failed to generate new default IndexedColour");
                return;
            }

            // Set the colour to have a name.
            String_64 ColourName;
            ColourName.Load ( NameResID );

            NewDefault->SetName ( ColourName );

            // Add the new colour to the end of the colour list
            ColList->AddItem(NewDefault);
        }

        if (NewDefault != NULL)     // Fix the DocColour to reference the new IndexedColour
            Result->MakeRefToIndexedColour(NewDefault);
    }

    // else just return - Result has a safe immediate colour definition
}
#undef COL_ACCURACY


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

>   BOOL AttributeManager::InitInstance()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/8/94
    Returns:    FALSE if initialisation failed, An error will be set in this situation.
                TRUE is successful.
                
                Purpose:Creates the current attribute groups, and adds the initial current 
                        attributes to them.

                        For a description of attribute groups see CreateCurrentAttributeGroup
    Errors:     -
    SeeAlso:    AttributeManager::CreateCurrentAttributeGroup
    SeeAlso:    AttributeManager::UpdateCurrentAttribute


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

BOOL AttributeManager::InitInstance()
{
    // ****************************************************************************************
    // ****************************************************************************************
    // IMPORTANT !!, whenever a new attribute gets added here, make sure that the ObjectRegistry 
    // is updated as well. Also remember that there are now two current attribute groups to 
    // fill in (TEXT and INK)

    // Register all attribute groups here 

    // Register the NodeRenderableInk attribute group first. The attributes in this group 
    // get applied to all objects except text (sort of - see CreateCurrentAttributeGroup) 
                
    String_256          strGraphic( _R(IDS_GRAPHIC) );
    CreateCurrentAttributeGroup( CC_RUNTIME_CLASS(NodeRenderableInk), (CCRuntimeClass *)NULL, 
        strGraphic );

    // Set up initial current attributes 
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    AttrFlatColourFill* Attr1 = new AttrFlatColourFill; 
    if (Attr1 == NULL)
        return FALSE; 

    // Find default black/whith indexed colours. This will create the new
    // colours if necessary. This all occurs in the Current Document.
    // The constant values give the RGB definition of the colour, and
    // the id of its name string (e.g. 255,255,255 "Default White")
    DocColour DefWhite;
//  FindDefaultColour(ColourManager::GetCurrentColourList(),
//                      _R(IDS_WHITENAME), &DefWhite);
    FindDefaultColour(NULL,
                        _R(IDS_WHITENAME), &DefWhite);
    DocColour DefBlack;
//  FindDefaultColour(ColourManager::GetCurrentColourList(),
//                      _R(IDS_BLACKNAME), &DefBlack);
    FindDefaultColour(NULL,
                        _R(IDS_BLACKNAME), &DefBlack);

    Attr1->SetStartColour(&DefBlack);
    Attr1->SetEndColour(&DefWhite);

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr1, FALSE, TRUE);
    
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrFlatTranspFill* Attr4 = new AttrFlatTranspFill; 
    if (Attr4 == NULL)
        return FALSE; 

    UINT32 Transp = 0;
    Attr4->SetStartTransp(&Transp);
    Attr4->SetEndTransp(&Transp);
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr4, FALSE, TRUE); 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrFillMappingLinear* FillMapp = new AttrFillMappingLinear; 
    if (FillMapp == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), FillMapp, FALSE, TRUE); 


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrTranspFillMappingLinear* TranspFillMapp = new AttrTranspFillMappingLinear; 
    if (TranspFillMapp == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), TranspFillMapp, FALSE, TRUE); 

                                  
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrFillEffectFade* Attr5 = new AttrFillEffectFade; 
    if (Attr5 == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr5, FALSE, TRUE); 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrStrokeColour* Attr2 = new AttrStrokeColour; 
    if (Attr2 == NULL)
        return FALSE; 
    Attr2->Value.Colour = DefBlack;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr2, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrStrokeTransp* Attr6 = new AttrStrokeTransp; 
    if (Attr6 == NULL)
        return FALSE; 
    Attr6->Value.Transp = 0;
    Attr6->Value.TranspType = TT_Mix;
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr6, FALSE, TRUE);  
                                                     

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrLineWidth* Attr3 =  new AttrLineWidth;
    if (Attr3 == NULL)
        return FALSE; 

    Attr3->Value.LineWidth = 500;// 0.5pt
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), Attr3, FALSE, TRUE);  
 

                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrStartArrow* StartArrow =  new AttrStartArrow;
    if (StartArrow == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), StartArrow, FALSE, TRUE);  


                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrEndArrow* EndArrow =  new AttrEndArrow;
    if (EndArrow == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), EndArrow, FALSE, TRUE);  


                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrStartCap* StCaps =  new AttrStartCap;
    if (StCaps == NULL)
        return FALSE; 

    StCaps->Value.StartCap = LineCapButt; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), StCaps, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrJoinType* JoinType =  new AttrJoinType;
    if (JoinType == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), JoinType, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrMitreLimit* MitreLimit =  new AttrMitreLimit;
    if (MitreLimit == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), MitreLimit, FALSE, TRUE);  

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrUser* User =  new AttrUser;
    if (User == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), User, FALSE, TRUE); 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrWebAddress* WebAddress =  new AttrWebAddress;
    if (WebAddress == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), WebAddress, FALSE, TRUE); 

                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~




    AttrWindingRule* WindingRule =  new AttrWindingRule;
    if (WindingRule == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), WindingRule, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrDashPattern* DashPattern =  new AttrDashPattern;
    if (DashPattern == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), DashPattern, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrOverprintLine *OPAttr = new AttrOverprintLine;
        if (OPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), OPAttr, FALSE, TRUE);
    }

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrOverprintFill *OPAttr = new AttrOverprintFill;
        if (OPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), OPAttr, FALSE, TRUE);
    }

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrPrintOnAllPlates *POAPAttr = new AttrPrintOnAllPlates;
        if (POAPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), POAPAttr, FALSE, TRUE);
    }


#ifdef VECTOR_STROKING // Neville 6/8/97
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrStrokeType* pStroke = new AttrStrokeType;
    if (pStroke == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pStroke, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrVariableWidth* pVarWidth =  new AttrVariableWidth;
    if (pVarWidth == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pVarWidth, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    AttrBevelIndent* pBevelIndent =  new AttrBevelIndent;
    if (pBevelIndent == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBevelIndent, FALSE, TRUE);

    AttrBevelLightAngle* pBevelLightAngle =  new AttrBevelLightAngle;
    if (pBevelLightAngle == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBevelLightAngle, FALSE, TRUE);

    AttrBevelContrast* pBevelContrast =  new AttrBevelContrast;
    if (pBevelContrast == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBevelContrast, FALSE, TRUE);

    AttrBevelLightTilt* pBevelTilt =  new AttrBevelLightTilt;
    if (pBevelTilt == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBevelTilt, FALSE, TRUE);
    
    AttrBevelType* pBevelType =  new AttrBevelType;
    if (pBevelType == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBevelType, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrBrushType* pBrushType = new AttrBrushType;
    if (pBrushType == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pBrushType, FALSE, TRUE);
     
#endif // VECTOR_STROKING

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    AttrFeather* pFeather = new AttrFeather;
    if (pFeather == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), pFeather, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // Create the attribute group for all text objects
    String_256          strText( _R(IDS_TEXT) );
    CreateCurrentAttributeGroup( CC_RUNTIME_CLASS(BaseTextClass), 
                                 CC_RUNTIME_CLASS(NodeRenderableInk), 
                                 strText ); // Base class


    // Attributes specific to text objects first
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // ----------------------------------------------------------------------------------
    // Create the Current text attributes

    AttrTxtFontTypeface* FntAttr = new AttrTxtFontTypeface; 
    if (FntAttr == NULL)
        return FALSE; 

    PORTNOTETRACE("text", "Japanese default font disabled");
#ifndef EXCLUDE_FROM_XARALX
    // If we are in Japan we don't want Times to be the current font
    if (UnicodeManager::IsDBCSOS())
    {
        // This is the Japanese standard font - it's specified in DBCS characters
        // so it won't work in UNICODE builds
        String_64 FontName  = wxT("\x82\x6c\x82\x72 \x82\x6f\x83\x53\x83\x56\x83\x62\x83\x4e");

        FONTMANAGER->CacheNamedFont(&FontName, FC_UNDEFINED);
        FntAttr->Value.HTypeface = FONTMANAGER->GetFontHandle(&FontName, FC_UNDEFINED);
    }
#endif

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), FntAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 
    AttrTxtBold* BoldAttr = new AttrTxtBold;
    if (BoldAttr == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), BoldAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrTxtItalic* ItalicAttr = new AttrTxtItalic;
    if (ItalicAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), ItalicAttr, FALSE, TRUE);  
 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrTxtUnderline* UnderlineAttr = new AttrTxtUnderline;
    if (UnderlineAttr == NULL)
        return FALSE;


    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), UnderlineAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrTxtFontSize* FontSizeAttr   = new AttrTxtFontSize;
    if (FontSizeAttr == NULL)
        return FALSE;

    // change default text size to 12pt (Jonathan)
    FontSizeAttr->Value.FontSize = 12000;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), FontSizeAttr, FALSE, TRUE); 
    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 


    AttrTxtAspectRatio* AspectRatioAttr = new AttrTxtAspectRatio;
    if (AspectRatioAttr == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), AspectRatioAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrTxtJustification* JustificationAttr = new  AttrTxtJustification;
    if (JustificationAttr == NULL)
        return FALSE;

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), JustificationAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    AttrTxtTracking* TxtTrackingAttr = new AttrTxtTracking;
    if (TxtTrackingAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtTrackingAttr, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrTxtScript* TxtScriptAttr = new AttrTxtScript;
    if (TxtScriptAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtScriptAttr, FALSE, TRUE);

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrTxtBaseLine* TxtBaseLineAttr = new AttrTxtBaseLine;
    if (TxtBaseLineAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtBaseLineAttr, FALSE, TRUE);  


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrTxtLineSpace* TxtLineSpaceAttr = new AttrTxtLineSpace;
    if (TxtLineSpaceAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtLineSpaceAttr, FALSE, TRUE);  

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    AttrTxtLeftMargin* TxtLeftMarginAttr = new AttrTxtLeftMargin;
    if (TxtLeftMarginAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtLeftMarginAttr, FALSE, TRUE);

    AttrTxtRightMargin* TxtRightMarginAttr = new AttrTxtRightMargin;
    if (TxtRightMarginAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtRightMarginAttr, FALSE, TRUE);

    AttrTxtFirstIndent* TxtFirstIndentAttr = new AttrTxtFirstIndent;
    if (TxtFirstIndentAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtFirstIndentAttr, FALSE, TRUE);

    AttrTxtRuler* TxtRulerAttr = new AttrTxtRuler;
    if (TxtRulerAttr == NULL)
        return FALSE;
        
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TxtRulerAttr, FALSE, TRUE);


    // Attributes which are not unique to the BaseText group
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Attr1 = new AttrFlatColourFill; 
    if (Attr1 == NULL)
        return FALSE; 

    // Set default black and white colours
    Attr1->SetStartColour(&DefBlack);
    Attr1->SetEndColour(&DefWhite);

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr1, FALSE, TRUE);
    
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Attr4 = new AttrFlatTranspFill; 
    if (Attr4 == NULL)
        return FALSE; 

    Transp = 0;
    Attr4->SetStartTransp(&Transp);
    Attr4->SetEndTransp(&Transp);
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr4, FALSE, TRUE); 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    FillMapp = new AttrFillMappingLinear; 
    if (FillMapp == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), FillMapp, FALSE, TRUE); 


    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    TranspFillMapp = new AttrTranspFillMappingLinear; 
    if (TranspFillMapp == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), TranspFillMapp, FALSE, TRUE); 

                                  
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    Attr5 = new AttrFillEffectFade; 
    if (Attr5 == NULL)
        return FALSE; 
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr5, FALSE, TRUE); 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    Attr2 = new AttrStrokeColour; 
    if (Attr2 == NULL)
        return FALSE; 
    Attr2->Value.Colour = DocColour(COLOUR_NONE);    // Text has no stroke colour attribute

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr2, FALSE, TRUE);  

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    
    Attr6 = new AttrStrokeTransp; 
    if (Attr6 == NULL)
        return FALSE; 
    Attr6->Value.Transp = 0;
    Attr6->Value.TranspType = TT_Mix;
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr6, FALSE, TRUE);  
    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Attr3 =  new AttrLineWidth;
    if (Attr3 == NULL)
        return FALSE; 

    Attr3->Value.LineWidth = 250;   // Text has 250 line width
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), Attr3, FALSE, TRUE);  
 

                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    StartArrow =  new AttrStartArrow;
    if (StartArrow == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), StartArrow, FALSE, TRUE);  


                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    EndArrow =  new AttrEndArrow;
    if (EndArrow == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), EndArrow, FALSE, TRUE);  


                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    StCaps =  new AttrStartCap;
    if (StCaps == NULL)
        return FALSE; 

    StCaps->Value.StartCap = LineCapButt; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), StCaps, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    JoinType =  new AttrJoinType;
    if (JoinType == NULL)
        return FALSE; 
    
    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), JoinType, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    MitreLimit =  new AttrMitreLimit;
    if (MitreLimit == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), MitreLimit, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    WindingRule =  new AttrWindingRule;
    if (WindingRule == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), WindingRule, FALSE, TRUE);  
                                                    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    DashPattern =  new AttrDashPattern;
    if (DashPattern == NULL)
        return FALSE; 

    UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), DashPattern, FALSE, TRUE);
    
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrOverprintLine *OPAttr = new AttrOverprintLine;
        if (OPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), OPAttr, FALSE, TRUE);
    }

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrOverprintFill *OPAttr = new AttrOverprintFill;
        if (OPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), OPAttr, FALSE, TRUE);
    }

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // BLOCK
    {
        AttrPrintOnAllPlates *POAPAttr = new AttrPrintOnAllPlates;
        if (POAPAttr == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), POAPAttr, FALSE, TRUE);
    }

#ifdef VECTOR_STROKING // Neville 6/8/97
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // BLOCK
    {
        AttrStrokeType* pStroke = new AttrStrokeType;
        if (pStroke == NULL)
            return FALSE; 

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), pStroke, FALSE, TRUE);  
    }

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    // BLOCK
    {
        AttrVariableWidth* pVarWidth =  new AttrVariableWidth;
        if (pVarWidth == NULL)
            return FALSE;

        UpdateCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), pVarWidth, FALSE, TRUE);
    } 

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
        
    }
    
#endif // VECTOR_STROKING
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    return TRUE; // Success
}

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

>   AttributeManager::~AttributeManager() 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/8/94
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Attribute manager destructor
                    Currently destroys all attributes in all attribute groups

    Errors:     -
    SeeAlso:    -

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


AttributeManager::~AttributeManager() 
{
    // Delete all groups 
    AttributeGroup* CurrentGroup = (AttributeGroup*)AttrGroupList.GetHead(); 
    NodeAttribute* CurrentAttr;
    NodeAttribute* NextAttr;  
    while (CurrentGroup != NULL)
    {
        // Delete all attributes in the group 
        CurrentAttr = CurrentGroup->AttrListHd;// get pointer to first attribute in the 
                                                    // group 
        while (CurrentAttr != NULL)
        {
            NextAttr = (NodeAttribute*)CurrentAttr->FindNext(); 
            delete CurrentAttr; 
            CurrentAttr = NextAttr;     
        }

        delete (AttrGroupList.RemoveItem((ListItem*)CurrentGroup));
        CurrentGroup =(AttributeGroup*)AttrGroupList.GetHead();         // Get next group  
    }
}

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

>   static BOOL AttributeManager::InitDefaults()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/05/94
    Returns:    TRUE if successful, FALSE otherwise

    Purpose:    Initialises the Attribute Manager. 
                    Registers basic attributes 
                    Declares attribute preferences 

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

    Preference: LastAttrAppliedBecomesCurrent
    Section:    Attributes
    Range:      TRUE or FALSE
    Purpose:    When TRUE - Whenever an attribute is applied to objects the attribute becomes
                a current attribute. 
                
    SeeAlso:    AskBeforeSettingCurrentAttr

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

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

    Preference: AskBeforeSettingCurrentAttr
    Section:    Attributes
    Range:      TRUE or FALSE