sgline.cpp

Go to the documentation of this file.

// $Id: sgline.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============================
 */
// sgline.cpp - Line SuperGallery classes - LineGallery and the LineAttrItem base class.

/*
*/

#include "camtypes.h"       // global types
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "range.h"          // selection & attributes - in camtypes.h [AUTOMATICALLY REMOVED]
#include "qualattr.h"
//#include "attrmgr.h" - in camtypes.h [AUTOMATICALLY REMOVED]

#include "ccdc.h"           // render-into-dialogue support
//#include "fillval.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grnddib.h"

//#include "galres.h"         // super-gallery support
//#include "galstr.h"
#include "sginit.h"
#include "sgline.h"
#include "sgline2.h"
#include "sgmenu.h"
#include "sglinepr.h"

#include "sgldrag.h"        // dragging support
#include "dragmgr.h"

#include "lattrops.h"      // gadgets and resources
//#include "justin.h"
//#include "mario.h"            // for _R(IDE_NOMORE_MEMORY)
//#include "richard2.h"     // for yet more strings

#ifdef VECTOR_STROKING
#include "sgstroke.h"       // Stroke attribute items
#include "strkattr.h"       // Stroke attributes
#include "ppstroke.h"       // PathProcessorStroke
#include "ppairbsh.h"       // PathProcessorStrokeAirbrush
#include "ppvecstr.h"       // PathProcessorStrokeVector
#include "valfunc.h"        // ValueFunctions
#endif

#include "helpuser.h"
//#include "xshelpid.h"
//#include "helppath.h"

#include "brshcomp.h"        // for the new style brushes
#include "ppbrush.h"
#include "brshattr.h"
#include "sgbrush.h"
#include "lineattr.h"
//#include "rik.h"
#include "brushmsg.h"
#include "brshname.h"
//#include "resdll.h"
#include "fileutil.h"
#include "brushop.h"

//#include "freehres.h"     //_R(IDS_FEATURENOTIMPLEMENTED)
//#include "resource.h"     //_R(IDS_OK)

//#include "linegal.h"

// Version control.
DECLARE_SOURCE("$Revision: 1282 $");

// Implement the dynamic class bits...
CC_IMPLEMENT_DYNCREATE(LineGallery, SuperGallery)
CC_IMPLEMENT_DYNAMIC(LineAttrItem, SGDisplayItem)
CC_IMPLEMENT_DYNCREATE(OpDisplayLineGallery, Operation);

// This line mustn't go before any CC_IMPLEMENT_... macros
#define new CAM_DEBUG_NEW


// This always points to the line gallery, or NULL if it doesn't exist.
LineGallery* LineGallery::m_pTheGallery = NULL;

// These are the default scaling factors for the four stock sizes of arrowheads.
double LineGallery::m_anArrowScales[4] = { 3.0, 8.0, 13.0, 18.0 };

// initialise the array that holds the filenames of the default brush files
String_256* LineGallery::m_pFileNameArray = NULL;
UINT32 LineGallery::m_NumDefaultFiles = 0;

/********************************************************************************************
>   LineAttrItem::LineAttrItem(const String& strDescription,
                               LineAttritem::TextPosition eTextPos)
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/3/95
    Inputs:     strDescription          text description of this item, eg "0.5 pt"
                eTextPos                the default position for this item's text
                                        description
    Outputs:    -
    Returns:    -
    Purpose:    Default constructor for a LineAttrItem.
    Errors:     -
    SeeAlso:    SGDisplayItem::SGDisplayItem
********************************************************************************************/

LineAttrItem::LineAttrItem(const String& strDescription, LineAttrItem::TextPosition eTextPos)
  : m_strDescription(strDescription),
    m_eDefaultTextPosition(eTextPos),
    m_fIsCurrentAttrib(FALSE)
{
    // Empty.
}



/********************************************************************************************
>   static BOOL LineAttrItem::UpdateCurrentAttribStatus()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if no problems encountered, eg. out of memory.
    Purpose:    Updates the "current attribute" status flag of every LineAttrItem
                within the line gallery, setting it to whether each item represents an
                attribute value applying to the current selection.
    Errors:     Out of memory.
    SeeAlso:    LineAttrItem::GetRuntimeClass; LineAttrItem::IsEqualValue
********************************************************************************************/

BOOL LineAttrItem::UpdateCurrentAttribStatus()
{
    // If the line gallery isn't running then we don't bother.
    if (!LineGallery::IsActive()) return TRUE;
    
    // For each group in the line gallery, try to match the current attribute of the
    // selection with the group's items.
    SGDisplayRoot* pRoot = LineGallery::GetInstance()->GetDisplayTree();
    if (pRoot == NULL) return FALSE;

    for (LineAttrGroup* pGroup = (LineAttrGroup*) pRoot->GetChild();
         pGroup != NULL;
         pGroup = (LineAttrGroup*) pGroup->GetNext())
    {
        // Get a pointer to the first item within the group, if any.
        LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild();
        if (pItem == NULL) continue;

        // Get a pointer to the null-terminated array of pointers to run-time classes that
        // this type of item can represent.
        CCRuntimeClass** ppAttribClasses = pItem->GetAttribRuntimeClasses();
        ERROR3IF(ppAttribClasses == NULL,
                    "No attribute run-time classes in LineAttrItem::UpdateCurrentAttribStatus");

        // Count how many types of classes the item represents.  Note the null statement.
        CCRuntimeClass**  pprtc;
        for (pprtc = ppAttribClasses; *pprtc != NULL; pprtc++);
        INT32 nAttribClasses = pprtc - ppAttribClasses;

        // Allocate an array of NodeAttribute pointers for each run-time class.
        typedef NodeAttribute* PATTRIBUTE;
        NodeAttribute** ppCommonAttribs = new PATTRIBUTE[nAttribClasses];
        ERRORIF(ppCommonAttribs == NULL, _R(IDE_NOMORE_MEMORY), FALSE);

        // For each run-time class that appears in *ppAttribClasses, try to find an
        // attribute of the same class that currently applies to the selection.
        for (INT32 i = 0; i < nAttribClasses; i++)
        {
            NodeAttribute* pattr = NULL; // sjk
            SelRange::CommonAttribResult eResult;
            
            eResult = GetApplication()->
                        FindSelection()->
                            FindCommonAttribute(ppAttribClasses[i], &pattr);

            // See if we found either a common attribute or the "default attribute".
            if (pattr != NULL)
            {
                // Check for nothing really brain-damaged happening.
                ERROR3IF(pattr->GetRuntimeClass() != ppAttribClasses[i],
                            "Wrong kind of attribute in LineAttrItem::"
                            "UpdateCurrentAttribStatus");

                // There is just one attribute applying, and we got it.
                ppCommonAttribs[i] = pattr;
            }
            else
            {
                // There are either many or none applying, so we aren't interested.
                ppCommonAttribs[i] = NULL;
            }       
        }

        // OK, so now we have an array of all the attributes this type of item is
        // interested in.  Ask each item within the group to compare itself against
        // each attribute we have found, to see if it represents it or not.
        for (; pItem != NULL; pItem = (LineAttrItem*) pItem->GetNext())
        {
            BOOL fOldState = pItem->m_fIsCurrentAttrib;
            pItem->m_fIsCurrentAttrib = pItem->IsEqualValueToAny(ppCommonAttribs);
            if (pItem->m_fIsCurrentAttrib != fOldState) pItem->ForceRedrawOfMyself();
        }

        // All done, we are finished with these kinds of attributes.
        delete[] ppCommonAttribs;
    }

    // Everything went OK.
    return TRUE;
}



/***********************************************************************************************
>   virtual void LineAttrItem::CalculateMyRect(SGFormatInfo* pFormatInfo,
                                                        SGMiscInfo* pMiscInfo)
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/2/95 (base generated in sgbase.cpp)
    Inputs:     pFormatInfo - The formatting info from which to calculate my position/size
                pMiscInfo - As usual, the useful misc info struct
    Outputs:    member variable FormatRect - is returned filled in with the size/position of
                this LineAttrItem item's display area. This is dependent upon the current display
                mode and format state.
                FormatInfo will be updated as a result of the formatting operation
    Purpose:    Shared code for LineAttrItem items to calculate where they will appear in the
                grand scheme of things
    Notes:      LineAttrItems supply only one display mode ("full info")
    Scope:      private (for use of LineAttrItem class only)
***********************************************************************************************/

void LineAttrItem::CalculateMyRect(SGFormatInfo* pFormatInfo, SGMiscInfo* pMiscInfo)
{
    // Find out the extent of this item, including a gap for formatting.
    MILLIPOINT xSize, ySize;
    GetSize(m_eDefaultTextPosition, &xSize, &ySize);
    if (xSize != SG_InfiniteWidth)
        xSize += GetHorzGap();

    ySize += GetVertGap();

    // Let the base class do what it needs to do with this.
    CalculateFormatRect(pFormatInfo, pMiscInfo, xSize, ySize);
}



/********************************************************************************************
>   void LineAttrItem::GetSize(LineAttrItem::TextPosition eTextPos,
                               MILLIPOINT* pxSize,
                               MILLIPOINT* pySize) const
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/4/95
    Inputs:     eTextPos        where this item's text description should go
    Outputs:    pxSize          where to store the width of the item
                pySize          where to store the height of the item
    Returns:    -
    Purpose:    Used to calculate how large this item is, in millipoints.
    Errors:     -
    SeeAlso:    LineAttrItem::CalculateMyRect
********************************************************************************************/

void LineAttrItem::GetSize(LineAttrItem::TextPosition eTextPos,
                           MILLIPOINT* pxSize,
                           MILLIPOINT* pySize) const
{
    // Make sure we can put the results somewhere.
    ERROR3IF(pxSize == NULL || pySize == NULL, "Null* passed in LineAttrItem::GetSize");

    // Get the basic size and add in a possible text size as well.
    *pxSize = GetWidth();
    *pySize = GetHeight();
    switch (eTextPos)
    {
        case LEFT:
            if (*pxSize != SG_InfiniteWidth)
            {
                *pxSize += (c_nHorzSizeOfText + c_nHorzGapAfterText);
            }
            break;

        case BELOW:
            *pySize += (c_nVertSizeOfText + c_nVertGapAboveText);
            break;

        case NO_LABEL:
            break;

        default:
            ERROR3("Unexpected case in LineAttrItem::GetSize");
            break;
    }
}



/***********************************************************************************************
>   virtual void LineAttrItem::HandleRedraw(SGRedrawInfo* pRedrawInfo,
                                                     SGFormatInfo* pFormatInfo)
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/2/95 (base generated in sgbase.cpp)
    Inputs:     pRedrawInfo - The information on the kernel-rendered redraw area
                pFormatInfo - The formatting information structure
                
                Member variable FormatRect should be set up (before calling this method)
                to be the rectangle in which to draw this item
    Purpose:    LineAttrItem item redraw method - removed from the main HandleEvent
                method merely to make the code tidier.

                Justin here: this version sets default attributes within the render region,
                such as foreground & background colour, and then calls the Render() function
                to do the actual drawing.
    Notes:      VERY IMPORTANT: The rendering must be enclosed by calls to StartRendering
                and StopRendering, to ensure that rendering works properly (in the future
                we may change the redraw system to use a GRenderRegion for each individual
                item, rather than one global one for the window, for which these calls will
                be essential)
    Scope:      protected
***********************************************************************************************/

void LineAttrItem::HandleRedraw(SGRedrawInfo* pRedrawInfo, SGMiscInfo* pMiscInfo)
{
    // Remove the gap between the items, shrink by one pixel to ensure clean clipping,
    // and fix the bounds coincide with the position of pixels.
    DocRect drBounds(FormatRect);
    drBounds.Inflate(-(pMiscInfo->PixelSize + GetHorzGap() / 2),
                     -(pMiscInfo->PixelSize + GetVertGap() / 2));
    GridLockRect(pMiscInfo, &drBounds);

    // Set the foreground and background colours according to whether this item is
    // selected or not.
    DocColour dcolForegnd, dcolBackgnd;
    if (Flags.Selected)
    {
        dcolForegnd = pRedrawInfo->SelForeground;
        dcolBackgnd = pRedrawInfo->SelBackground;
    }
    else
    {
        dcolForegnd = pRedrawInfo->Foreground;
        dcolBackgnd = pRedrawInfo->Background;
    }

    // Set the attributes for drawing the formatted rectangle.
    RenderRegion* pRegion = pRedrawInfo->Renderer;
    pRegion->SetLineWidth(pMiscInfo->PixelSize);        // line is one pixel wide
    pRegion->SetFillColour(dcolBackgnd);

    // If we are drawing an item that is a "current attribute" then we want to draw it
    // with a "selected" line around it.  Otherwise we draw it with effectively no line.
    if (m_fIsCurrentAttrib)
    {
        pRegion->SetLineColour(pRedrawInfo->SelBackground);
    }
    else
    {
        // Draw the line the same colour as the fill colour, so it's "invisible".
        pRegion->SetLineColour(dcolBackgnd);
    }

    // Create a closed path that is filled with the fill colour and if necessary has
    // a visible outline.
    Path pth;
    pth.Initialise();
    pth.IsFilled = TRUE;
    pth.IsStroked = m_fIsCurrentAttrib;     // draw outline if "current attribute"

    // "Draw" the bounding rectangle into the path.
    pth.InsertMoveTo(drBounds.lo);
    pth.InsertLineTo(DocCoord(drBounds.lo.x, drBounds.hi.y));
    pth.InsertLineTo(drBounds.hi);
    pth.InsertLineTo(DocCoord(drBounds.hi.x, drBounds.lo.y));
    pth.InsertLineTo(drBounds.lo);
    pth.CloseSubPath();
    
    // Draw the path.
    pRegion->DrawPath(&pth);

    // Reset the rendering attributes back to the normal: standard gallery foreground
    // and background colours.
    pRegion->SetLineColour(dcolForegnd);
    pRegion->SetFixedSystemTextColours(&dcolForegnd, &dcolBackgnd);

    // Shrink the rectangle by a pixel, to make sure it nicely fits within the bounds,
    // lock down, and let the derived class do the rest of the work as it pleases.
    drBounds.Inflate(-pMiscInfo->PixelSize, -pMiscInfo->PixelSize);
    GridLockRect(pMiscInfo, &drBounds);
    Render(pRegion, drBounds, m_eDefaultTextPosition);
}



/********************************************************************************************
>   void LineAttrItem::Render(RenderRegion* pRegion,
                              const DocRect& drBounds,
                              LineAttrItem::TextPosition eTextPos) const
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/3/95
    Inputs:     pRegion         pointer to the RenderRegion to render into
                drBounds        the bounding box to render within
                eTextPos        whether and where to put the text description
    Outputs:    -
    Returns:    -
    Purpose:    Called by the HandleRedraw function.  Can be overridden by derived classes.
                This base class version draws the text describing this item within the
                text bounding box, and a line within the line bounding box.
    Errors:     -
    SeeAlso:    LineAttrItem::HandleRedraw
********************************************************************************************/

void LineAttrItem::Render(RenderRegion* pRegion, const DocRect& drBounds,
                          LineAttrItem::TextPosition eTextPos) const
{
    // Make a copy of the given bounding box rectangle so that we can adjust it later
    // if we render some text within it.
    DocRect drLineBounds(drBounds);
    
    // Next, render the text description of this item, if necessary.
    if (eTextPos != NO_LABEL)
    {
        // We must adjust the bounding box of the line to account for the text rendered
        // into it.  Items display their text on the left of the rendered attribute.
        DocRect drTextBounds(drLineBounds);
        switch (eTextPos)
        {
            case BELOW:
            {
                // Divide the bounds horizontally, text below.
                drTextBounds.hi.y = drTextBounds.lo.y + c_nVertSizeOfText;
                drLineBounds.lo.y = drTextBounds.hi.y + c_nVertGapAboveText;

                // Centre the text bounds.  As there is no "GetTextExtent" function for
                // "system text" we have the obligatory bodge . . .
//              MILLIPOINT nTextLen = (GetDescription().Length() + 1) * c_nAveCharWidth;
                DocRect TextBounds;
                String_256 Desc = GetDescription();
                pRegion->GetFixedSystemTextSize(&Desc, &TextBounds);
                MILLIPOINT nTextLen = TextBounds.Width() / 2;
                MILLIPOINT xMid = (drTextBounds.lo.x + drTextBounds.hi.x) / 2;
                drTextBounds.lo.x = xMid - nTextLen;
                drTextBounds.hi.x = xMid + nTextLen;
                break;
            }

            case LEFT:
                // Divide the bounds vertically, text to the left.
                drTextBounds.hi.x = drTextBounds.lo.x + c_nHorzSizeOfText;
                drLineBounds.lo.x = drTextBounds.hi.x + c_nHorzGapAfterText;
                break;

            default:
                ERROR3("Unexpected case in LineAttrItem::Render");
                return;
        }
    
        // Draw the text description of this item.  Note that the foreground and
        // background colours have already been set by the caller.
        pRegion->DrawFixedSystemText((String*) &GetDescription(), drTextBounds);
    }

    // Set the default line width for lines rendered within the gallery and let a
    // derived class set some specialised rendering attributes for its item. Then draw
    // the line, by default through the centre of the given bounding box.  A derived
    // class may very occasionally need to override this as well (eg. to render join-types).
    pRegion->SaveContext();
        pRegion->SetLineWidth(c_nDefaultLineWidth);
        SetAttributes(pRegion);
        DrawItem(pRegion, drLineBounds);
    pRegion->RestoreContext();
}



/********************************************************************************************
>   virtual void LineAttrItem::DrawItem(RenderRegion* pRegion, const DocRect& drBounds) const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/95
    Inputs:     pRegion             pointer to the RenderRegion to draw into
                drBounds            reference to the bounding box rectangle to draw within
    Outputs:    -
    Returns:    -
    Purpose:    Draws this item within the bouding box.  This default implementation draws
                a single line through the centre of the box, fine for almost all derived
                classes.  You can override this to do something else (cf. the join-types
                attribute item, that must draw two lines that meet).
    Errors:     -
    SeeAlso:    LineAttrItem::Render
********************************************************************************************/

void LineAttrItem::DrawItem(RenderRegion* pRegion, const DocRect& drBounds) const
{
    // Calculate the mid-point of the vertical sides of the bounding box.
    INT32 yMid = (drBounds.lo.y + drBounds.hi.y) / 2;

    // Draw a line at this height from the left to the right edge.
    Path pthLinePath;
    if (pthLinePath.Initialise())
    {
        pthLinePath.InsertMoveTo(DocCoord(drBounds.lo.x, yMid));
        pthLinePath.InsertLineTo(DocCoord(drBounds.hi.x, yMid));
        pthLinePath.IsFilled  = FALSE;
        pthLinePath.IsStroked = TRUE;
        pRegion->DrawPath(&pthLinePath);
    }
}



/********************************************************************************************
>   virtual MILLIPOINT LineAttrItem::GetWidth() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/4/95
    Inputs:     -
    Outputs:    -
    Returns:    The width of this item, in millipoints.
    Purpose:    Called by the formatting code.
    Errors:     -
    SeeAlso:    LineAttrItem::GetSize; LineAttrItem::CalculateMyRect
********************************************************************************************/

MILLIPOINT LineAttrItem::GetWidth() const
{
    return c_nHorzSizeOfItem;
}



/********************************************************************************************
>   virtual MILLIPOINT LineAttrItem::GetHeight() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    19/4/95
    Inputs:     -
    Outputs:    -
    Returns:    The height of this item, in millipoints.
    Purpose:    Called by the formatting code.
    Errors:     -
    SeeAlso:    LineAttrItem::GetSize; LineAttrItem::CalculateMyRect
********************************************************************************************/

MILLIPOINT LineAttrItem::GetHeight() const
{
    return c_nVertSizeOfItem;
}



/********************************************************************************************
>   virtual MILLIPOINT LineAttrItem::GetHorzGap() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    The horizontal gap between this item and another item of the same type, in
                millipoints.
    Purpose:    Called by the formatting code.  This base-class version returns a default
                value, derived classes may override it to make items closer or further
                apart.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

MILLIPOINT LineAttrItem::GetHorzGap() const
{
    return c_nHorzGapBetweenItems;
}



/********************************************************************************************
>   virtual MILLIPOINT LineAttrItem::GetVertGap() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    The vertical gap between this item and another item of the same type, in
                millipoints.
    Purpose:    Called by the formatting code.  This base-class version returns a default
                value, derived classes may override it to make items closer or further
                apart.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

MILLIPOINT LineAttrItem::GetVertGap() const
{
    return c_nVertGapBetweenItems;
}



/***********************************************************************************************
>   virtual BOOL LineAttrItem::HandleEvent(SGEventType EventType,
                                                    void* EventInfo,
                                                    SGMiscInfo* pMiscInfo)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/2/95 (base generated in sgbase.cpp)
    Inputs:     EventType - An enumerated value describing what type of event is to be processed
                EventInfo - A structure describing the event (may be NULL). The exact thing
                            pointed at by this pointer depends upon the event type:
                            MonoOn
                            Event               Thing EventInfo points at
                            SGEVENT_FORMAT      (SGFormatInfo *)
                            SGEVENT_REDRAW      (SGRedrawInfo *)
                            SGEVENT_MOUSECLICK  (SGMouseInfo *)
                            MonoOff
                Use the provided SGDisplayNode::Get[Format]Info() inlines to retrieve this
                information - they provide useful error/type checking, and hide the cast

                MiscInfo - always provided. Contains a few useful bits of info that may be
                needed for all event types.
    Outputs:    FormatInfo is updated as appropriate
    Returns:    TRUE if the event was handled successfully
                FALSE if it was not
    Purpose:    Handles a SuperGallery DisplayTree event
    Notes:      This overrides the pure virtual SGDisplayNode::HandleEvent method.
                A node need not handle a specific event - if it does not handle it, it
                should return FALSE.
                Redraw and Formatting handlers should never return TRUE, as this will
                prevent the event from continuing through the tree.
                Non-leaf-nodes must call SGDisplayNode::GiveEventToMyChildren in order
                to pass the event dow the tree. THIS node is a leaf-node, so it doesn't.
    SeeAlso:    SGDisplayNode::HandleEvent
***********************************************************************************************/

BOOL LineAttrItem::HandleEvent(SGEventType EventType, void* EventInfo, SGMiscInfo *MiscInfo)
{
    switch (EventType)
    {
    case SGEVENT_FORMAT:
        {
            SGFormatInfo* FormatInfo = GetFormatInfo(EventType, EventInfo);
            CalculateMyRect(FormatInfo, MiscInfo);      // Cache our FormatRect for later use
        }
        break;


    case SGEVENT_REDRAW:
        {
            // Rely on FormatRect being cached from above
            SGRedrawInfo* RedrawInfo = GetRedrawInfo(EventType, EventInfo);

            // only redraw if we intersect the clip rect
            if (IMustRedraw(RedrawInfo))
            {
                // Now render the item.
                StartRendering(RedrawInfo, MiscInfo);
                RedrawInfo->Renderer->SaveContext();
                HandleRedraw(RedrawInfo, MiscInfo);
                RedrawInfo->Renderer->RestoreContext();
                StopRendering(RedrawInfo, MiscInfo);
            }
        }
        break;      // exit and return FALSE to pass the redraw event on


    case SGEVENT_MOUSECLICK:
        {
            SGMouseInfo *Mouse = GetMouseInfo(EventType, EventInfo);

            if (FormatRect.ContainsCoord(Mouse->Position))
            {
                //OK temporary dodge (see, not a bodge) to stop people doing things with brushes in the
                //line gallery before we get them working!
                // LineAttrItem* pItem = this;
    
                {
                    // If the colour is in the selected document, then it is safe to
                    // do a colour drag - for now, it will only allow drags for the
                    // selected doc.
                    // Otherwise, the normal click action takes place.
                    // If the drag fails (turns into a click) then the normal click action
                    // takes place, passed on by the GalleryColourDragInfo::OnClick handler
                    // SGDisplayGroup *Parent = (SGDisplayGroup *) GetParent();

                    if (Mouse->DoubleClick) // || Parent->GetParentDocument() != Document::GetSelected())
                        DefaultClickHandler(Mouse, MiscInfo);
                    else
                    {
                        DefaultPreDragHandler(Mouse, MiscInfo); 
    
                        GalleryLineDragInfo* pInfo;
                        pInfo = new GalleryLineDragInfo(this, Mouse, MiscInfo, Mouse->MenuClick);
                        if (pInfo != NULL) DragManagerOp::StartDrag(pInfo, GetListWindow());
                    }
                }

                return(TRUE);       // Claim this event - nobody else can own this click
            }
        }
        break;

    default:
        // Pass unknown events on to the base class
        return(SGDisplayItem::HandleEvent(EventType, EventInfo, MiscInfo));
    }

    // Default return value: We do not claim this event, so it will be passed on to others
    return FALSE;
}



/***********************************************************************************************
>   virtual void LineAttrItem::DragWasReallyAClick(SGMouseInfo* pMouse,
                                                            SGMiscInfo* pMiscInfo)
    Author:     Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/4/95
    Inputs:     Mouse - The mouse info passed to the original click handler
                MiscInfo - The misc info passed to the original click handler
    Purpose:    Handles a mouse click event. This is a callback function - drags of
                line attributes from the gallery will call this function back if the drag
                turns out to just be a click.
    SeeAlso:    LineAttrItem::HandleEvent; GalleryLineDragInfo::OnClick
***********************************************************************************************/

void LineAttrItem::DragWasReallyAClick(SGMouseInfo* pMouse, SGMiscInfo* pMiscInfo)
{
    // Just get default selection action to be applied for this click.
    DefaultClickHandler(pMouse, pMiscInfo);
}



/********************************************************************************************
>   virtual BOOL LineAttrItem::DefaultClickHandler(SGMouseInfo* pMouse,
                                                   SGMiscInfo* pMiscInfo)
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    7/4/95
    Inputs:     (see base-class implementation in SGDisplayItem)
    Outputs:    -
    Returns:    (see base-class implementation in SGDisplayItem)
    Purpose:    Overrides the default behaviour when items in the line gallery are
                clicked on, so that it is possible to simple-click and select items
                in different groups without clearing the selection.
    Errors:     -
    SeeAlso:    SGDisplayItem::DefaultClickHandler
********************************************************************************************/

BOOL LineAttrItem::DefaultClickHandler(SGMouseInfo* pMouse, SGMiscInfo* pMiscInfo)
{
    // Get some objects.
    SuperGallery* pParent = GetParentGallery();
    SGDisplayGroup* pGroup = (SGDisplayGroup*) GetParent();
    ERROR3IF(pGroup == NULL, "No parent group in LineAttrItem::DefaultClickHandler?");
    
    // If there is any other item within the group already selected then
    // deselect it.  We start searching from the first child of this group.
    for (LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild();
         pItem != NULL;
         pItem = (LineAttrItem*) pItem->GetNext())
    {
         if (pItem != this) pItem->SetSelected(FALSE);
    }

    // If Adjust, toggle my selection state
    // If Select, set myself selected, and ensure all other items deselected
    // NB. NOTE THAT "ADJUST" IS REALLY WHAT EVERY ONE ELSE CALLS "CONSTRAIN"!!
    // (Well, actually, it's what Windows uses for altering a selection... it's not my
    // fault that the rest of Camelot flies in the face of windows conventions... and
    // as galleries are really "super" windows list boxes, they have to use windows
    // conventions. Note also that pMouse->Adjust is not necessarily fixed to any key
    // but happens under Windows to be attached to ctrl or the right button)
    SetSelected((pMouse->Adjust && !pMouse->DoubleClick) ? !Flags.Selected : TRUE);

    // OK, now we have guaranteed that an item is selected on a double click we can run
    // an Apply action.
    if (pMouse->DoubleClick)
    {
        // Apply the attributes.     
        if (pParent->ApplyAction(pMouse->Adjust ? SGACTION_APPLYADJUST : SGACTION_APPLY) &&
            pMouse->Adjust)
        {
            // Adjust/Ctrl double click of an item. This applies the item and then
            // auto closes the gallery (just like RISC OS and Win95)
            // Auto-close only occurs, however, if the item says it's OK, as arrowheads
            // use the ctrl-double click to apply in a special way, so shouldn't autoclose.

            if (ShouldCloseOnDoubleClick())
            {
                pParent->SetVisibility(FALSE);

                DialogBarOp::SetSystemStateChanged();   // Ensure toolbar button pops out again
            }
        }

        return TRUE;
    }

    // Update the pParent to know that we are the new multi-selection anchor
    // (The anchor only changes when single items are (de)selected)
    pParent->SetLastSelectedNode((Flags.Selected) ? this : NULL);

    // Finally, inform the parent gallery that the selection has changed, so it can
    // shade/unshade buttons as appropriate, etc
    pParent->SelectionHasChanged();
    return TRUE;
}



/********************************************************************************************
>   const String& LineAttrItem::GetDescription() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/95
    Inputs:     -
    Outputs:    -
    Returns:    A reference to a string that describes what this item represents.
    Purpose:    Describes this item, basically.
    Errors:     -
    SeeAlso:    LineAttrItem::LineAttrItem
********************************************************************************************/

const String& LineAttrItem::GetDescription() const
{
    return m_strDescription;
}

/********************************************************************************************
>   void LineAttrItem::SetDescription(StringBase *pNewDescription)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    06/03/97
    Inputs:     pNewDescription - New description of the item
    Purpose:    Changes the item's text in the gallery
********************************************************************************************/

void LineAttrItem::SetDescription(StringBase *pNewDescription)
{
    if(pNewDescription != NULL)
    {
        m_strDescription = *pNewDescription;
    }
}



/********************************************************************************************
>   void LineAttrItem::SetTextPosition(LineAttrItem::TextPosition eNewTextPos)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/3/95
    Inputs:     eNewTextPos         the new position of the text description
    Outputs:    -
    Returns:    -
    Purpose:    Tells SGDisplayLineAttrItems whether to display themselves with a label
                describing themselves, or not.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

void LineAttrItem::SetTextPosition(LineAttrItem::TextPosition eNewTextPos)
{
    m_eDefaultTextPosition = eNewTextPos;
}



/********************************************************************************************
>   virtual BOOL LineAttrItem::GetStatusLineHelp(DocCoord* pMousePos, String_256* pResult)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/6/95
    Inputs:     dcMousePos              (not used)
    Outputs:    pResult                 where to put the text
    Returns:    TRUE
    Purpose:    Sets the given string to the text description of this line item.
********************************************************************************************/

BOOL LineAttrItem::GetStatusLineHelp(DocCoord*, String_256* pResult)
{
    // Check for rubbish.
    ERROR3IF(pResult == NULL, "Null String_256* passed to LineAttrItem::GetStatusLineHelp");
    
    // Build up the status-line text.  This is composed of the item's text description,
    // followed by the text of the item's group title, without the last pluralising 's'.
    String_256 str;
    if (IsSelected())
        str = String_256(_R(IDS_LINEGAL_SEL_CTRLCLICK));
    else
        str = String_256(_R(IDS_LINEGAL_SEL_CLICK));

    str += GetDescription();
    str += String_8(_R(IDS_SGLINE_STAT_SPACE_SEP)); // " "
    str += ((LineAttrGroup*) GetParent())->GetTitle();
    str.Left(pResult, str.Length() - 1);

    String_256 strAttr(_R(IDS_LINEGAL_ATTR));
    *pResult += strAttr;

//  if (IsSelected())           // removing this test fixes bug #4684 (hee hee!!)
    {
        String_256 strDbl(_R(IDS_LINEGAL_SEL_DBLCLK));
        *pResult += strDbl;
    }
    
    // Success!
    return TRUE;
}



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

>   virtual BOOL LineAttrItem::ShouldCloseOnDoubleClick(void)

    Author:     Jason_Williams (Xara Group Ltd) <camelotdev@xara.com>
    Created:    12/12/95

    Returns:    TRUE

    Purpose:    When an item is ctrl-double-clicked, the default action is to apply the
                item and close the gallery (for convenience). However, arrowheads do
                a special action for ctrl-double-click (they apply to the other end
                of the line) so they do not want auto-close to occur.

                This function returns TRUE (auto-close) by default, and is overridden
                to return FALSE by derived classes which wish to stop the auto-close action.

    SeeAlso:    LineArrowItem::ShouldCloseOnDoubleClick

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

BOOL LineAttrItem::ShouldCloseOnDoubleClick(void)
{
    return(TRUE);
}



/********************************************************************************************
>   virtual void LineAttrItem::ItemSelected() 

    Author:     Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/1/2000
    Inputs:     pNewAttr - the attribute that we are about to apply
    Outputs:    -
    Returns:    TRUE if we want the line gallery to go ahead and apply the attribute, 
                FALSE if we applied it ourselves.
    Purpose:    utility fn called when the item is selected.  If your item needs to do anything
                just prior to it becoming selected then override this function.
    Errors:     -
    SeeAlso:    BrushAttrItem::ItemSelected
********************************************************************************************/

BOOL LineAttrItem::ItemSelected(NodeAttribute* pNewAttr)
{
    return TRUE;
}


/********************************************************************************************
>   LineAttrGroup::LineAttrGroup(const String_64& strTitle, SuperGallery* pGal)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/95
    Inputs:     strTitle        the title string to display within the group heading
                pGal            pointer to the owning super-gallery object
    Outputs:    -
    Returns:    -
    Purpose:    Contructs a LineAttrGroup, representing a section heading within
                the line-attributes super-gallery.
    Errors:     -
    SeeAlso:    SGDisplayGroup::SGDisplayGroup
********************************************************************************************/

LineAttrGroup::LineAttrGroup(const String_64& strTitle, SuperGallery* pGal)
  : SGDisplayGroup(pGal, NULL, NULL)
{
    // Set the title (in the base class).
    TitleText = strTitle;
}



/********************************************************************************************
>   const String_64& LineAttrGroup::GetTitle() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/6/95
    Returns:    A reference to the string containing this group's title.
    Purpose:    Gets this group's title (the text displayed next to the folder icon).
    SeeAlso:    LineAttrItem::GetStatusLineHelp
********************************************************************************************/

const String_64& LineAttrGroup::GetTitle() const
{
    return TitleText;
}



/********************************************************************************************
>   static BOOL LineGallery::Init()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/3/95
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if gallery initialisation is successful.
    Purpose:    Called when the program starts, loading .INI file settings.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

BOOL LineGallery::Init()
{
    return Camelot.DeclareSection(TEXT("Displays"), 20)
        && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale1"),
                               &m_anArrowScales[0], 0.1, 50.0)
        && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale2"),
                               &m_anArrowScales[1], 0.1, 50.0)
        && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale3"),
                               &m_anArrowScales[2], 0.1, 50.0)
        && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale4"),
                               &m_anArrowScales[3], 0.1, 50.0)
        && PrepareBrushFolders();
}



/********************************************************************************************
>   static LineGallery* LineGallery::GetInstance()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    A pointer to the program's line gallery if it exists, or NULL.
    Purpose:    Public access function to the line gallery.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

LineGallery* LineGallery::GetInstance()
{
    return m_pTheGallery;
}



/********************************************************************************************
>   static BOOL LineGallery::IsActive()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    TRUE if the line gallery is currently visible on-screen, FALSE otherwise.
    Purpose:    Used by the message-handlers of gadgets within the line gallery to
                determine if they should update themselves or not.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

BOOL LineGallery::IsActive()
{
    return m_pTheGallery != NULL && m_pTheGallery->IsVisible();
}



/********************************************************************************************
>   LineGallery::LineGallery()
                                                 
    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/2/95 (base generated in sgbase.cpp)
    Purpose:    LineGallery default constructor.  Sets a global instance pointer to
                this object.
********************************************************************************************/

LineGallery::LineGallery()
{
    // Remember a pointer to the global instance of this gallery.
    ERROR3IF(m_pTheGallery != NULL, "Gallery already exists in LineGallery::LineGallery?");
    m_pTheGallery = this;

    DlgResID=_R(IDD_LINESGALLERY);
    
    // set to the normal default
    m_PreviousLineWidth = 500;
} 



/********************************************************************************************
>   virtual LineGallery::~LineGallery()

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/4/95
    Inputs:     -
    Outputs:    -
    Returns:    -
    Purpose:    Destroys a line gallery, resetting the global instance pointer to NULL.
    Errors:     -
    SeeAlso:    -
********************************************************************************************/

LineGallery::~LineGallery()
{
    // Make sure nothing is seriously screwed-up.
    ERROR3IF(m_pTheGallery == NULL, "No gallery in LineGallery::~LineGallery?");
    m_pTheGallery