barcreationdlg.cpp

Go to the documentation of this file.

// $Id: barcreationdlg.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============================
 */
#include "camtypes.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "barcreationdlg.h"     //This file's header
#include "menuops.h"    
#include "ccdc.h"           // specific #includes needed for kernel-rendered dialogues
//#include "barsdlgs.h"     // _R(IDD_BARCONTROLSTORE)
//#include "simon.h"            // contians the resources of the dlg
//#include "sliceres.h"     // more resources
//#include "resimmap.h"
#include "nodetxts.h"
#include "sprdmsg.h"    // SpreadMsg
#include "slice.h" // so export can invoke this op
#include "opbarcreation.h" // to invoke the create op
#include "slicetool.h" // for the findstate static fn

// these are for the template attribute definitions
// required for the scanning for existing bar attribs
//#include "cxfrech.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "userattr.h"
#include "tmpltatr.h"

#include "layermsg.h"   // the layer messaging

// named set stuff
#include "ngcore.h"
#include "ngitem.h"
#include "ngsentry.h"
#include "ngsetop.h"

//#include "resource.h" // for _R(IDS_CANCEL)

#include "xshelpid.h"


CC_IMPLEMENT_DYNCREATE(BarCreationDlg, DialogOp);
CC_IMPLEMENT_DYNCREATE(BarStatesDlg, DialogOp);
CC_IMPLEMENT_DYNCREATE(BarRedefineStateDlg, DialogOp);

#define new CAM_DEBUG_NEW

#define DLG_TIMER   2020

// Set up our static variables
const CDlgMode BarCreationDlg::Mode = MODELESS;
const UINT32 BarCreationDlg::IDD = _R(IDD_BARCREATIONDLG);

BarCreationDlg *BarCreationDlg::TheDialog = NULL;   


// statics to hold the status of the controls
// so when the dlg is closed and re-openned they
// remember what they were
BOOL BarCreationDlg::ms_WantDefault = TRUE; 
BOOL BarCreationDlg::ms_WantMouse = FALSE; 
BOOL BarCreationDlg::ms_WantClicked = FALSE; 
BOOL BarCreationDlg::ms_WantSelected = FALSE; 
BOOL BarCreationDlg::ms_IsVertical = TRUE; 
BOOL BarCreationDlg::ms_SuggestDesign = TRUE;
BOOL BarCreationDlg::ms_Continuous = TRUE;
BOOL BarCreationDlg::ms_FromSelection = TRUE;
INT32 BarCreationDlg::ms_StateToCreate = 0;
INT32 BarCreationDlg::ms_SizeJustification = 0;
 
INT32 BarCreationDlg::ms_NoOfButtons = 4; 
INT32 BarCreationDlg::ms_Spacing = 0; 
INT32 BarCreationDlg::ms_Mode = NEW_BAR; 
INT32 BarCreationDlg::ms_Stretching = 0;
BOOL BarCreationDlg::ms_GroupsStretch = TRUE;

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

>   BarCreationDlg::BarCreationDlg() : DialogOp(RenderDlg::IDD, RenderDlg::Mode) 

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> from Alex
    Created:    13/8/99
    Purpose:    Constructor

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

BarCreationDlg::BarCreationDlg() : DialogOp(BarCreationDlg::IDD, BarCreationDlg::Mode) 
{
    //Set our member variable pointer so it points at ourself
    if (TheDialog == NULL)
        TheDialog = this;

    m_IsEditing = FALSE;
    m_FirstIsEditing = FALSE;
    m_AlreadyInThisFunction = FALSE;
    m_HasBackBar = FALSE;
    m_ValidBar = TRUE;
}       



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

>   BarCreationDlg::~BarCreationDlg()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> from Alex
    Created:    13/8/99
    Purpose:    Destructor

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

BarCreationDlg::~BarCreationDlg()
{
    //Set our member variable pointer to NULL
    if (TheDialog == this)
        TheDialog = NULL;
} 
 
/********************************************************************************************
>   MsgResult BarCreationDlg::Message( Msg* Message)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    13/8/99
    Inputs:     Message: The incoming message 
        
    Returns:    DialogOp::Message (Message)

    Purpose:    This is the message handler for the BarCreationDlg. It simply takes the
                message and redirects it to one of our Message Handler functions.
     
********************************************************************************************/

MsgResult BarCreationDlg::Message( Msg* Message)
{
    BOOL fEndDialog=FALSE;

    //If the message is a dialog message
    if (IS_OUR_DIALOG_MSG(Message))
    {
        //Then work out what it says
        DialogMsg* pDialogMsg = ((DialogMsg*) Message); 
    
        switch (pDialogMsg->DlgMsg)
        {
            case DIM_CREATE:
                SetStringGadgetValue(_R(IDC_BC_DIRECTION), _R(IDS_HORIZ), FALSE, 0);
                SetStringGadgetValue(_R(IDC_BC_DIRECTION), _R(IDS_VERT), FALSE, 1);
                SetStringGadgetValue(_R(IDC_BC_DIRECTION), _R(IDS_SCATTERED), TRUE, 2);

                SetStringGadgetValue(_R(IDC_BC_BUTTON_SIZE), _R(IDS_EXTENDS), FALSE, 0);
                SetStringGadgetValue(_R(IDC_BC_BUTTON_SIZE), _R(IDS_SCALES), FALSE, 1);
                SetStringGadgetValue(_R(IDC_BC_BUTTON_SIZE), _R(IDS_IS_STATIC), TRUE, 2);

                SetStringGadgetValue(_R(IDC_BC_BUTTONS_SAME), _R(IDS_BUTTONS_SAME_SIZE), FALSE, 0);
                SetStringGadgetValue(_R(IDC_BC_BUTTONS_SAME), _R(IDS_BUTTONS_LEFT_SIZE), FALSE, 1);
                SetStringGadgetValue(_R(IDC_BC_BUTTONS_SAME), _R(IDS_BUTTONS_RIGHT_SIZE), FALSE, 2);
                SetStringGadgetValue(_R(IDC_BC_BUTTONS_SAME), _R(IDS_BUTTONS_DIFF_SIZE), TRUE, 3);
                
                SetUpControls();

                // throw the keyboard focus
                //DialogManager::DefaultKeyboardFocus();
                break;
    
            // these two messages are used to throw the focus back to the main window
            case DIM_TITLEFOCUSWARN:
                //DialogManager::DefaultKeyboardFocus();
                break;

            // focus throw
            case DIM_LFT_BN_UP:
                //DialogManager::DefaultKeyboardFocus();
                break;

            case DIM_CANCEL:    
                fEndDialog = TRUE;
                break;

            // special case to find the one typed into the field
            case DIM_TIMER:
                {
                    KillTimer(DLG_TIMER);
                    INT32 NewNoOfButtons = GetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), 1, MAX_BUTTONS_IN_A_BAR);

                    if (NewNoOfButtons == 1)
                    {
                        OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_SHORTENBAROP); 
                        if (pOpDesc != NULL)
                        {
                            OpParamShortenBar ParamShortenBar(m_BarName, NewNoOfButtons);
                            pOpDesc->Invoke(&ParamShortenBar);
                            // update the dialog value
                            ms_NoOfButtons = NewNoOfButtons;
                            SetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), ms_NoOfButtons);
                        }
                        else
                        {
                            ERROR3("Couldn't find OPTOKEN_SHORTENBAROP op descriptor");
                        }
                    }
                }
                break;

            case DIM_TEXT_CHANGED:
                if (m_IsEditing)
                    switch(pDialogMsg->GadgetID)
                {
                case _R(IDC_BC_SPACING):
                    {
                    // the text has changed for the spacing field
                        INT32 spacing = 0;
                        BOOL Valid=0;
                        MILLIPOINT ActualSpacing = GetUnitGadgetValue(_R(IDC_BC_SPACING), PIXELS, -75000, 75000, 0, &Valid);
                        String_256 ActualText = GetStringGadgetValue(_R(IDC_BC_SPACING));
                        spacing = ActualSpacing;


                        if (Valid && !ActualText.IsEmpty() && ms_Spacing != spacing)
                        {
                            ms_Spacing = spacing;

                            if (m_IsEditing)
                                WriteBarProperties();
                        }
                    }
                    //DialogManager::DefaultKeyboardFocus(); // throws focus
                    break;

                case _R(IDC_BC_NO_OF_BUTTONS):
                    {
                    // the text has changed for the spacing field
                        INT32 NewNoOfButtons = GetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), 1, MAX_BUTTONS_IN_A_BAR);

                        // get what the set abr props are then
                        ReadBarProperties();

                        if (NewNoOfButtons > ms_NoOfButtons && NewNoOfButtons <= MAX_BUTTONS_IN_A_BAR)
                        {
                            OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BARDUPLICATIONOP); 
                            if (pOpDesc != NULL)
                            {
                                OpParamBarDuplication AddButtonsParam(m_BarName, m_BarName, NewNoOfButtons - ms_NoOfButtons, ms_Spacing, !ms_IsVertical);
                                pOpDesc->Invoke(&AddButtonsParam);

                                // update the dialog value
                                ms_NoOfButtons = NewNoOfButtons;
                                SetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), ms_NoOfButtons);
                            }
                            else
                            {
                                ERROR3("Couldn't find OPTOKEN_BARDUPLICATIONOP op descriptor");
                            }
                        }
                        else
                        if (NewNoOfButtons < ms_NoOfButtons && NewNoOfButtons > 1)
                        {
                            OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_SHORTENBAROP); 
                            if (pOpDesc != NULL)
                            {
                                OpParamShortenBar ParamShortenBar(m_BarName, NewNoOfButtons);
                                pOpDesc->Invoke(&ParamShortenBar);
                                // update the dialog value
                                ms_NoOfButtons = NewNoOfButtons;
                                SetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), ms_NoOfButtons);
                            }
                            else
                            {
                                ERROR3("Couldn't find OPTOKEN_SHORTENBAROP op descriptor");
                            }
                        }
                        else
                        if (NewNoOfButtons < ms_NoOfButtons && NewNoOfButtons == 1)
                        {
                            SetTimer(DLG_TIMER, 1000, NULL);
                        }

                    }
                    //DialogManager::DefaultKeyboardFocus(); // throws focus
                    break;

                } // end switch

                break;

            // manage button controls
            case DIM_LFT_BN_CLICKED:
                switch(pDialogMsg->GadgetID)
                {
                case _R(IDC_BC_CREATE):
                    if (m_IsEditing)
                    { // open up the states dlg
                        OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BARSTATESDLG); 
                        if (pOpDesc != NULL)
                        {
                            OpParamBarStatesDlg ParamBarStatesDlg(m_BarName);
                            pOpDesc->Invoke(&ParamBarStatesDlg);
                        }

                    }
                    else
                    {
                        if(CreateBar()) // behave in a modal manner - close the dialog having done the deed.
                        {
                            fEndDialog = TRUE;
                            m_IsEditing = TRUE;
                            SetUpControls(TRUE);
                        }
                    }
                    break;

                case _R(IDC_BC_REDEF_BACKBAR):
                    if (m_IsEditing)
                    {
                        // create a back bar
                        INT32 temp = ms_StateToCreate;
                        ms_StateToCreate = BACKBAR;
                        CreateBar();
                        ms_StateToCreate = temp;
                        SetUpControls(TRUE);
                    }
                    break;

                case _R(IDC_BC_GROUPS_STRETCH):
                    ms_GroupsStretch = !GetBoolGadgetSelected(_R(IDC_BC_GROUPS_STRETCH));
                    if (m_IsEditing)
                        WriteBarProperties();
                    break;
                }
                //DialogManager::DefaultKeyboardFocus(); // throws focus
                break;

            
                //NB: This means someone has altered the combo box. It doesn't mean
                //the selection has changed!
            case DIM_SELECTION_CHANGED: 
                switch(pDialogMsg->GadgetID)
                {
                    // changed the direction of the bar
                case _R(IDC_BC_DIRECTION):
                    switch (GetSelectedValueIndex(_R(IDC_BC_DIRECTION)))
                    {
                    case 0: // horz
                        ms_IsVertical = FALSE;
                        ms_Continuous = TRUE;
                        break;

                    case 1: // vert
                        ms_IsVertical = TRUE;
                        ms_Continuous = TRUE;
                        break;

                    case 2: // scattered
                        ms_IsVertical = TRUE;
                        ms_Continuous = FALSE;
                        break;
                    }

                    EnableGadget(_R(IDC_BC_SPACING), ms_Continuous && m_ValidBar);

                    if (m_IsEditing) // update the bar direction now!
                        WriteBarProperties();

                    //DialogManager::DefaultKeyboardFocus(); // throws focus
                    break;

                case _R(IDC_BC_BUTTONS_SAME):
                    ms_SizeJustification = GetSelectedValueIndex(_R(IDC_BC_BUTTONS_SAME));

                    if (m_IsEditing)
                        WriteBarProperties();
                    //DialogManager::DefaultKeyboardFocus(); // throws focus
                    break;

                case _R(IDC_BC_BUTTON_SIZE):
                    ms_Stretching = GetSelectedValueIndex(_R(IDC_BC_BUTTON_SIZE));
                    EnableGadget(_R(IDC_BC_GROUPS_STRETCH), ms_Stretching ? 0 : 1);
                    if (m_IsEditing)
                    {
                        BYTE ExtendFlags = 0; // dont extend

                        if (ms_Stretching == 0)
                        {
                            ExtendFlags = X_EXTEND | Y_EXTEND;
                        }
                        else
                            if (ms_Stretching == 1)
                            {
                                ExtendFlags = X_STRETCH | Y_STRETCH;
                            }

                        OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_CHANGE_BAR_EXTENDS); 
                        if (pOpDesc != NULL)
                        {
                            OpParam BarStretchParam(SliceHelper::GetBarNumberFromBarName(m_BarName), ExtendFlags);
                            pOpDesc->Invoke(&BarStretchParam);
                        }
                        else
                        {
                            ERROR3("Couldn't find OPTOKEN_CHANGE_BAR_EXTENDS op descriptor");
                        }

                        WriteBarProperties();
                    }
                    //DialogManager::DefaultKeyboardFocus(); // throws focus
                    break;

                }
                break;
        }
    }
    else if (MESSAGE_IS_A(Message, OpMsg))
    {
        if (((OpMsg *)Message)->MsgType == OpMsg::AFTER_UNDO ||
            ((OpMsg *)Message)->MsgType == OpMsg::AFTER_REDO ||
            IS_A( ((OpMsg *)Message)->pOp, OpDelete) )
        {
            ReadBarProperties(); // set the controls from what the bar thinks it is
            SetUpControls(TRUE); // set all the controls
        }
    }
    // for whenever someone announces that they have changed the selection.
    else if (MESSAGE_IS_A(Message, SelChangingMsg))
    {
        SelChangingMsg* pSelChange = (SelChangingMsg*)Message;

        if (pSelChange->State == SelChangingMsg::SelectionState::SELECTIONCHANGED ||
            pSelChange->State == SelChangingMsg::SelectionState::NONCOLOURATTCHANGED)
        {
            SetUpDynamicControls();
        }
    }
    // If we've changed to a different document then get rid of the dlg.
    else if (MESSAGE_IS_A(Message, DocChangingMsg))
    {
        DocChangingMsg* TheMsg = (DocChangingMsg*) Message;
        if (TheMsg->State == DocChangingMsg::BORN || TheMsg->State == DocChangingMsg::SELCHANGED)
            Close();
    }
        
    if (fEndDialog) 
    {
        // read the number of buttons if the dlg is closed
        // so we don't have to re-type
        ms_NoOfButtons = GetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), 1, 20);
        if (ms_NoOfButtons > 20) ms_NoOfButtons = 20;
        if (ms_NoOfButtons < 1) ms_NoOfButtons = 1;

        // close the dlg
        Close();           
        End();
    }


    return DialogOp::Message(Message);
} 

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

>   OpState BarCreationDlg::GetState(String_256*, OpDescriptor*)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> after Alex
    Created:    13/8/99
    Purpose:    Returns the OpState of the dialogue operation

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

OpState BarCreationDlg::GetState(String_256*, OpDescriptor*)
{
    OpState OpSt;

    // if we don't allow it
    OpSt.Greyed = TRUE;
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread && !pSpread->FindActiveLayer()->IsFrame())
        OpSt.Greyed = FALSE;

    // Tick the menu while the editor is open
    if (TheDialog != NULL)
        OpSt.Ticked = TRUE;

    return(OpSt);
}

         

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

>   BOOL BarCreationDlg::Init()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> after Alex
    Created:    13/8/99
    Returns:    FALSE if it fails (due to lack of memory)
    Purpose:    Creates an OpDescriptor for a HotLink Dialog and declares
                some preferences

*******************************************************************************************/
BOOL BarCreationDlg::Init()
{
    return (RegisterOpDescriptor(0,                             // Tool ID
                                _R(IDS_BARCREATION),                    // String resource ID
                                CC_RUNTIME_CLASS(BarCreationDlg),       // Runtime class
                                OPTOKEN_BARCREATIONDLG,             // Token string
                                BarCreationDlg::GetState,               // GetState function
                                _R(IDH_NavBar_Create_Dialog_Box),                               // Help ID
                                _R(IDBBL_BARCREATION),              // Bubble ID
                                _R(IDD_BARCONTROLSTORE),            // Resource ID
                                _R(IDC_BARCREATION),                // Control ID
                                SYSTEMBAR_UTILITIES,            // Bar ID
                                TRUE,                           // Recieve system messages
                                FALSE,                          // Smart duplicate operation
                                TRUE,                           // Clean operation
                                0,                              // No vertical counterpart
                                NULL,
                                (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC),
                                TRUE
                                )); 
                        
}   
 
      


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

>   void BarCreationDlg::Do(OpDescriptor*)

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> after Jason
    Created:    13/8/99

    Purpose:    Opens the dialog if it is closed. Closes it if it is open.
                Should no longer be called, but use the with param instead
        
********************************************************************************************/

void BarCreationDlg::Do(OpDescriptor*)
{
    m_IsEditing = FALSE;
    m_BarName = "Bar1";
    m_FirstBarName = m_BarName;
    ms_Spacing = 0; // reset the spacing to zero

    if (TheDialog==NULL || TheDialog==this)
    {
        if (Create())
            Open();
        else
            End();
    }
    else
    {
        TheDialog->Open();
        TheDialog->BringToTop();

        End();              // Kill ourself
    }
}

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

>   BOOL BarCreationDlg::Create()

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> after Jason
    Created:    13/8/99
    Inputs:     -
    Outputs:    -
    Returns:    FALSE if it fails
    Purpose:    Creates a Web Address dialogue box. Fails if DialogOp::Create
                fails to create the box.
    Errors:     -
    SeeAlso:    -

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

BOOL BarCreationDlg::Create()
{

    ReadBarProperties();    

    // manipulate the ticks if we are editing a state
    if (!m_IsEditing)
        // if we are creating we must create the default state
    {
        ms_StateToCreate = 0; // create the off state as default
        ms_FromSelection = TRUE; // from the selection of course

        ms_WantDefault = TRUE;
        ms_WantMouse = FALSE;
        ms_WantClicked = FALSE;
        ms_WantSelected = FALSE;

        ms_Spacing = 0; // reset the spacing to zero
        ms_GroupsStretch = TRUE;
    }


    if (TheDialog != this)      // Allow only one instance of this dialogue open at once
        return(FALSE);

    if (DialogOp::Create())
    { 
        return(TRUE);
    }

    return(FALSE);
}

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

>   void BarCreationDlg::DoWithParam(OpDescriptor* pOp, OpParam* pParam)       

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> after Alex
    Created:    13/8/99
    Inputs:     OpDescriptor
    Outputs:    -
    Returns:    -
    Purpose:    Performs the BarCreationDlg operation
    Errors:     -
    SeeAlso:    -

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

void BarCreationDlg::DoWithParam(OpDescriptor* pOp, OpParam* pParam)
{
    m_IsEditing = ((OpParamBarCreationDlg *)pParam)->m_IsEditing;
    m_BarName = ((OpParamBarCreationDlg *)pParam)->m_BarName;
    m_FirstBarName = m_BarName;
    m_FirstIsEditing = m_IsEditing;

    if (((OpParamBarCreationDlg *)pParam)->m_ButtonsToEdit)
        ms_NoOfButtons = ((OpParamBarCreationDlg *)pParam)->m_ButtonsToEdit;

    if (TheDialog==NULL || TheDialog==this)
    {
        if (Create())
        {
            Open();
            SetUpControls(TRUE);
        }
        else
            End();
    }
    else
    {
        TheDialog->Open();
        TheDialog->BringToTop();

        TheDialog->m_IsEditing = ((OpParamBarCreationDlg *)pParam)->m_IsEditing;
        TheDialog->m_BarName = ((OpParamBarCreationDlg *)pParam)->m_BarName;
        TheDialog->m_FirstBarName = m_BarName;
        TheDialog->m_FirstIsEditing = m_IsEditing;
        TheDialog->m_ValidBar = TRUE;
        TheDialog->ms_Spacing = 0; // reset the spacing to zero
        TheDialog->ms_GroupsStretch = TRUE;

        TheDialog->EnableAllMyControls(TRUE);

        TheDialog->SetUpControls(TRUE);

        End();              // Kill ourself
    }
}


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

>   BOOL BarCreationDlg::SetUpControls( BOOL DoScan )

    Author:     Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/8/99
    Returns:    TRUE always at present!
    Purpose:    Spookily enough it sets up all the controls in the dlg

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

BOOL BarCreationDlg::SetUpControls( BOOL DoScan )
{
    if (m_AlreadyInThisFunction)
        return TRUE;

    SetUpDynamicControls();

    m_AlreadyInThisFunction = TRUE;
    if (m_IsEditing)
    {
        if (DoScan)
        {
            // find out how many buttons there are
            INT32 NumberOfButtons = SliceHelper::CountButtonsInBar(m_BarName);
            if (NumberOfButtons > 0)
                ms_NoOfButtons = NumberOfButtons;

            String_256 BackBarLayer(_R(IDS_BACK_BAR));
            m_HasBackBar = SliceHelper::BarExistsOnLayer(m_BarName, BackBarLayer);
        }

        if (m_HasBackBar)
        {
            SetStringGadgetValue(_R(IDC_BC_REDEF_BACKBAR), _R(IDS_REDEFINE_BACKBAR)); // Redefine
            SetStringGadgetValue(_R(IDC_BACKBAR_TEXT), _R(IDS_RECREATE_BACKBAR_TEXT));
        }
        else
        {
            SetStringGadgetValue(_R(IDC_BC_REDEF_BACKBAR), _R(IDS_CREATE_BACKBAR)); // Create
            SetStringGadgetValue(_R(IDC_BACKBAR_TEXT), _R(IDS_CREATE_BACKBAR_TEXT));
        }
    }
    else
    {
        // if we're creating a new bar, we must have the option for default to be ticked.
        ms_WantDefault = TRUE;
    }

    HideGadget(_R(IDC_BC_CREATE_BACKBAR), m_IsEditing);
    HideGadget(_R(IDC_BACKBAR_TEXT), !m_IsEditing);
    HideGadget(_R(IDC_BC_REDEF_BACKBAR), !m_IsEditing);

    SetSelectedValueIndex(_R(IDC_BC_BUTTONS_SAME), ms_SizeJustification);
    SetSelectedValueIndex(_R(IDC_BC_BUTTON_SIZE), ms_Stretching);

    SetStringGadgetValue(_R(IDC_BC_CREATE), m_IsEditing ? _R(IDS_CREATE_STATES) : _R(IDS_CREATE_STATE)); // States.. or Create
    HideGadget(_R(IDC_BC_CREATE), m_IsEditing); // actually hide the control if we are editing (remove states...)
    
    SetStringGadgetValue(IDCANCEL, m_IsEditing ? _R(IDS_DLG_DONE) : _R(IDS_CANCEL_DIALOG)); // Close or Cancel

    // grey the spacing if it is scattered
    EnableGadget(_R(IDC_BC_SPACING), ms_Continuous && m_ValidBar);

    if (!ms_Continuous)
        SetSelectedValueIndex(_R(IDC_BC_DIRECTION), 2);
    else
        SetSelectedValueIndex(_R(IDC_BC_DIRECTION), ms_IsVertical ? 1 : 0);

    SetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), ms_NoOfButtons);
    SetBoolGadgetSelected(_R(IDC_BC_GROUPS_STRETCH), !ms_GroupsStretch);
    EnableGadget(_R(IDC_BC_GROUPS_STRETCH), ms_Stretching ? 0 : 1);

    SetUnitGadgetValue(_R(IDC_BC_SPACING), PIXELS, ms_Spacing);

    String_256 Title;
    if (m_IsEditing)
        Title.Load(_R(IDS_BAR_EDIT_TITLE));
    else
        Title.Load(_R(IDS_BAR_CREATION_TITLE));

    if (m_ValidBar)
        Title += m_BarName;
    else
    {
        String_256 temp(_R(IDS_NO_VALID_BAR));
        Title += temp;
    }

    SetTitlebarName(&Title);

    m_AlreadyInThisFunction = FALSE;

    return TRUE;
}


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

>   BOOL BarCreationDlg::SetUpDynamicControls()

    Author:     Simon_Knight (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/99
    Returns:    TRUE always at present!
    Purpose:    Sets up all the controls in the dlg that are
                dynamic and reviewed upon a timer.
                So this function is called on a poll, to read the
                states and set the controls.

********************************************************************************************/
BOOL BarCreationDlg::SetUpDynamicControls()
{
    // show the current layer in the dlg
    String_256 LayerName = "";
    Spread* pSpread = Document::GetSelectedSpread();
    if (pSpread == NULL)
        return FALSE;

    SelRange * pSelection = GetApplication()->FindSelection();

    // scan the selection has the bar name changed?

    String_256 TempBarName = "";

    Node * pCurrent = pSelection->FindFirst();
    TemplateAttribute * pTemplAttrib = NULL;
    Node * pTempNode = NULL;

    BOOL HasASelection = pCurrent != NULL;

    while (pCurrent && TempBarName.IsEmpty())
    {
        // look at the bar name on the attrib
        pTemplAttrib = (TemplateAttribute *) SliceHelper::FindNextOfClass(pCurrent, pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));
        while (pTemplAttrib && TempBarName.IsEmpty())
        {
            TempBarName = SliceHelper::GetBarName(pTemplAttrib);
            pTemplAttrib = (TemplateAttribute *) SliceHelper::FindNextOfClass(pTemplAttrib, pCurrent, CC_RUNTIME_CLASS(TemplateAttribute));
        }

        pCurrent = pSelection->FindNext(pCurrent);
    }

    // something is selected but that doesn't have a bar name
    if (HasASelection && TempBarName.IsEmpty() && m_IsEditing)
    {
        // does the selection intersect with any known bars?
        SliceHelper::BarNameInRect(pSelection->GetBoundingRect(), &TempBarName);
    }

    if (m_IsEditing && HasASelection && TempBarName.IsEmpty() && m_ValidBar)
    {
        m_ValidBar = FALSE;
        EnableAllMyControls(FALSE);
        SetUpControls(FALSE);
    }
    else
        if (!m_ValidBar && !TempBarName.IsEmpty() )
        {
            m_ValidBar = TRUE;
            EnableAllMyControls(TRUE);
            m_BarName = "";
        }

    if (TempBarName.CompareTo(m_BarName) != 0 && !TempBarName.IsEmpty())
    {
        m_BarName = TempBarName;
        m_IsEditing = TRUE;
        ReadBarProperties();
        SetUpControls();
    }

    // enable disable the create button if there is no selection
    EnableGadget(_R(IDC_BC_CREATE), m_ValidBar && (HasASelection || m_IsEditing));
    // enable disable the create backbar button if there is no selection
    EnableGadget(_R(IDC_BC_REDEF_BACKBAR), m_ValidBar && HasASelection);
    
    return TRUE;
}

void BarCreationDlg::EnableAllMyControls(BOOL enable)
{
    EnableGadget(_R(IDC_BC_NO_OF_BUTTONS),  enable);
    EnableGadget(_R(IDC_BC_DIRECTION),      enable);
    EnableGadget(_R(IDC_BC_SPACING),        enable);
    EnableGadget(_R(IDC_BC_BUTTON_SIZE),    enable);
    EnableGadget(_R(IDC_BC_BUTTONS_SAME),   enable);
    EnableGadget(_R(IDC_BC_REDEF_BACKBAR),  enable);
    EnableGadget(_R(IDC_BC_CREATE),         enable);
}


BOOL BarCreationDlg::CreateBar()
{
    BOOL Valid = TRUE;
    ms_NoOfButtons = GetLongGadgetValue(_R(IDC_BC_NO_OF_BUTTONS), 1, 20, 0 /*error id*/, &Valid);
    if (!Valid)
    {
        InformWarning(_R(IDS_TOO_MANY_BUTTONS));
        return FALSE;
    }

    // run the Op that does the copying of the selection / bar creation bit

    BOOL MakeBackBarAswell = !m_IsEditing && GetBoolGadgetSelected(_R(IDC_BC_CREATE_BACKBAR));

    ms_WantDefault = FALSE;
    ms_WantMouse = FALSE;
    ms_WantClicked = FALSE;
    ms_WantSelected = FALSE;
    switch(ms_StateToCreate)
    {
    case 0:
        ms_WantDefault = TRUE;
        break;

    case 1:
        ms_WantMouse = TRUE;
        break;

    case 2:
        ms_WantClicked = TRUE;
        break;

    case 3:
        ms_WantSelected = TRUE;
        break;

    }

    OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BARCREATIONOP); 
    if (pOpDesc != NULL)
    {
        // set the mode of the create from
        // the editing flag for now
        if (m_IsEditing)
            ms_Mode = REPLACE_SOME_STATES;
        else
        {
            ms_Mode = NEW_BAR;

            // the text has changed for the spacing field
            INT32 spacing = 0;
            BOOL Valid=0; 
            MILLIPOINT ActualSpacing = GetUnitGadgetValue(_R(IDC_BC_SPACING), PIXELS, 0, 75000, 0, &Valid);
            String_256 ActualText = GetStringGadgetValue(_R(IDC_BC_SPACING));
            spacing = ActualSpacing;

            if (Valid && !ActualText.IsEmpty() && ms_Spacing != spacing)
            {
                ms_Spacing = spacing;
            }
        }

        // add the bar details
        WriteBarProperties();

        BYTE ExtendFlags = 0; // dont extend

        if (ms_Stretching == 0)
            ExtendFlags = X_EXTEND | Y_EXTEND;
        else
            if (ms_Stretching == 1)
                ExtendFlags = X_STRETCH | Y_STRETCH;

        OpParamBarCreation BarParam(ms_WantMouse,
                                    ms_WantClicked,
                                    ms_WantSelected,
                                    (ms_StateToCreate == BACKBAR) || MakeBackBarAswell,
                                    ms_IsVertical,
                                    ms_SuggestDesign,
                                    ms_NoOfButtons,
                                    ms_WantDefault,
                                    ms_Mode,
                                    ms_Spacing,
                                    ms_Continuous,
                                    ms_SizeJustification != 3, // are they the same size ?  0 = same centered 1 = same left 2 = same right 3 = independant
                                    m_BarName,
                                    (ms_StateToCreate == DEFAULT || ms_StateToCreate == BACKBAR) ? TRUE : ms_FromSelection,
                                    ExtendFlags);
        pOpDesc->Invoke(&BarParam);
    }
    else
    {
        ERROR3("Couldn't find OPTOKEN_BARCREATIONOP op descriptor");
    }

    return TRUE;
}





void BarCreationDlg::ReadBarProperties()
{
    NodeBarProperty* pNodeBarProperty = (NodeBarProperty*) Document::GetCurrent()->GetSetSentinel()->FindBarProperty();
    INT32 BarNumber = SliceHelper::GetBarNumberFromBarName(m_BarName);

    if (pNodeBarProperty && BarNumber < pNodeBarProperty->HowMany())
    {
        BarDataType NewBarData = pNodeBarProperty->Bar(BarNumber);
        ms_IsVertical = NewBarData.IsHorizontal ? FALSE : TRUE;
        ms_Continuous = NewBarData.RequiresShuffle;
        ms_SizeJustification = NewBarData.SameSize;
        ms_Spacing = NewBarData.Spacing;
        ms_Stretching = 2; // static no stretching
        if (NewBarData.ButtonsExtend)
            ms_Stretching = 0;
        else if (NewBarData.ButtonsScale)
            ms_Stretching = 1;
        ms_GroupsStretch = NewBarData.GroupsStretch;
    }
}

void BarCreationDlg::WriteBarProperties()
{
    NodeBarProperty* pNodeBarProperty = (NodeBarProperty*) Document::GetCurrent()->GetSetSentinel()->FindBarProperty();
    INT32 BarNumber = SliceHelper::GetBarNumberFromBarName(m_BarName);

    if (pNodeBarProperty )
    {
        BarDataType NewBarData;

        NewBarData.IsHorizontal = !ms_IsVertical;
        NewBarData.RequiresShuffle = ms_Continuous;
        NewBarData.SameSize = ms_SizeJustification;
        NewBarData.Spacing = ms_Spacing;
        NewBarData.ButtonsExtend = (ms_Stretching == 0 ? 1 : 0);
        NewBarData.ButtonsScale = (ms_Stretching == 1 ? 1 : 0);
        NewBarData.GroupsStretch = ms_GroupsStretch;

        pNodeBarProperty->MakeChange(BarNumber, NewBarData);
        // tell everyone that the selection may have changed
        // actually it wont have but the position of the blobs may well have
        // and sending this message means that everyone like the tool will
        // re-evaluate the postitions of the selection (sjk 11/7/00)
        BROADCAST_TO_ALL(SelChangingMsg(SelChangingMsg::NONCOLOURATTCHANGED));
    }
}


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

// Set up our static variables
const CDlgMode BarStatesDlg::Mode = MODELESS;
const UINT32 BarStatesDlg::IDD = _R(IDD_BARSTATESDLG);

BarStatesDlg *BarStatesDlg::TheDialog = NULL;
INT32 BarStatesDlg::m_State = 1;
BOOL BarStatesDlg::ms_SuggestDesign = TRUE;


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