prevwdlg.cpp

Go to the documentation of this file.

// $Id: prevwdlg.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============================
 */
// A simple Dialog That does some Gavin Rendering into itself

/*
*/

#include "camtypes.h"
#include "prevwdlg.h"

#include "ccdc.h"       // specific #includes needed for kernel-rendered dialogues
#include "dlgcol.h"     // DialogColourInfo
//#include "fillval.h"
#include "grnddib.h"

//#include "prevwres.h"
#include "impexpop.h"   // BitmapExportParam
#include "nodebmp.h"    // NodeBitmap
//#include "gifutil.h"  // GDM_BACKTOBACK
#include "dlgview.h"    // DialogView

//#include "rikdlg.h"       // _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "ctrlhelp.h"
//#include "docvmsg.h" - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "spread.h"       // GetFirstFrameLayer() - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "xshelpid.h" //For the help ID

// This is not compulsory, but you may as well put it in so that the correct version
// of your file can be registered in the .exe
DECLARE_SOURCE("$Revision: 1282 $");

// An implement to match the Declare in the .h file.
// If you have many classes, it is recommended to place them all together, here at the start of the file
CC_IMPLEMENT_DYNCREATE(AnimatedBitmapItem, ListItem)
CC_IMPLEMENT_DYNCREATE(PreviewDialog, DialogOp)

// This will get Camelot to display the filename and linenumber of any memory allocations
// that are not released at program exit
#define new CAM_DEBUG_NEW


// Set the static vars of the render dialog
const CDlgMode  PreviewDialog::Mode = MODELESS; 
const UINT32        PreviewDialog::IDD = _R(IDD_PREVIEWDIALOG);
      BOOL      PreviewDialog::m_AnimationPropertiesChanged = FALSE;
              
typedef struct
{
    CGadgetID   Gadget;         // Gadget ID
    UINT32      BubbleID;       //Bubble help ID for this gadget
} GadgetBubbleHelp;


// If extra controls are added to the Preview dialog and
// they require Bubble help, add them to this table.
static GadgetBubbleHelp BubbleHelp[] = 
{

    {   _R(IDC_PREVIEW_PLAY),        _R(IDS_PREVIEWBH_PLAY)      },
    {   _R(IDC_PREVIEW_STOP),        _R(IDS_PREVIEWBH_STOP)      },
    {   _R(IDC_PREVIEW_NEXTFRAME),   _R(IDS_PREVIEWBH_NEXTFRAME) },
    {   _R(IDC_PREVIEW_PREVFRAME),   _R(IDS_PREVIEWBH_PREVFRAME) }, 
    {   _R(IDC_PREVIEW_SLIDER),      _R(IDS_PREVIEWBH_SLIDER)    },
    {   0, 0                                         }  

};

BOOL PreviewDialog::viaBitmapGallery = FALSE;




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

>   AnimatedBitmapItem::AnimatedBitmapItem(KernelBitmap *pEntry, Layer * pLayer = NULL)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Inputs:     pEntry  - The bitmap to add to the list of frames
                pLayer  - The layer that the bitmap is associated with (defaults to NULL)
    Purpose:    To add a bitmap to the list of frames in the animation sequence. If it has
                an associated layer then add this at the same time.

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

AnimatedBitmapItem::AnimatedBitmapItem(KernelBitmap * pEntry, Layer * pLayer)
{
    m_pBitmap = pEntry;
    m_pLayer = pLayer;
}

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

>   AnimatedBitmapItem::AnimatedBitmapItem()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Purpose:    Default contructor.

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

AnimatedBitmapItem::AnimatedBitmapItem()
{
    ERROR3("AnimatedBitmapItem::AnimatedBitmapItem - call the other constructor");
    m_pBitmap = NULL;
    m_pLayer = NULL;
}

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

>   AnimatedBitmapItem::~AnimatedBitmapItem()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Purpose:    Default destructor

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

AnimatedBitmapItem::~AnimatedBitmapItem()
{
    // Do not attempt to delete the pointers that we have as these are references
    // rather than anything that we have allocated
}



/*******************************************************************************************
********************************************************************************************/
// Initialise our statics

PreviewDialog * PreviewDialog::m_pPreviewDialog = NULL;
UINT32          PreviewDialog::m_Delay = 0; 


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

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

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Purpose:    Constructs a Preview Dialog

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

PreviewDialog::PreviewDialog() : DialogOp(PreviewDialog::IDD, PreviewDialog::Mode), m_Timer(this)
{
    m_BitmapListSize            = 0;
    m_CurrentItem               = 0;
    m_pPreviewDialog            = this;
    m_pRender                   = NULL;
    m_PlayAnimation             = TRUE;
    m_DisplayNextFrame          = FALSE;
    m_DisplayPreviousFrame      = FALSE;
    m_SliderPosition            = m_BitmapListSize;
    m_DocumentAboutToDie        = FALSE;
    m_SetPreviewDlgToIdleState  = FALSE;
    m_GeneratedFrameLayers      = FALSE;
    m_DisposalMethod            = GDM_BACKTOBACK;
    m_CurrentDisposalMethod     = GDM_BACKTOBACK;

    m_AnimationRect.MakeEmpty();

    // Reset the loop counts
    m_CurrentLoopCount          = 0;    // The loop that we are currently on (default to start)
    m_RequiredLoopCount         = 0;    // The loop count that we must reach (default for ever)
    
    //viaBitmapGallery          = FALSE;        // THIS MUST ALREADY HAVE BEEN SET TO THE CORRECT
                                                // VALUE !!!!!
    
    // Get the input focus for bubble help.
    GetApplication()->RegisterIdleProcessor(IDLEPRIORITY_HIGH, this);
}       

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

>   PreviewDialog::~PreviewDialog()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Purpose:    Destructor

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

PreviewDialog::~PreviewDialog()
{
    // clean out the render region, if allocated
    if (m_pRender)
    {
        // Delete the render region and its (dialog) view
        // Do it by hand as StopRender should have been called already
        delete m_pRender->GetRenderView();
        delete m_pRender;
//      DestroyGRenderRegion(m_pRender);
        m_pRender = NULL;
    }
    
    // Clean out the list of bitmaps that we were animating
    m_BitmapList.DeleteAll();

    // kill the static link to this dialog box
    m_pPreviewDialog = NULL;

    // The dialog has been destroyed, remove the input focus.
    GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_HIGH, this);
} 



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

>   MsgResult PreviewDialog::Message(Msg* Message)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Purpose:    Handles all the Preview dialog's messages 

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

MsgResult PreviewDialog::Message(Msg* Message)
{
    MsgResult Result;

    BOOL EndDialog = FALSE;     // TRUE if we should quit the dialog

    // See if it is for us
    if (IS_OUR_DIALOG_MSG(Message))
    {
        // it is
        DialogMsg* Msg = (DialogMsg*)Message;

        // decide what to do
        switch (Msg->DlgMsg)
        {
            // Create message
            case DIM_CREATE :
                // As it is a modal dialog box we are sent a message to say the dialog box
                // is being created, so we have a chance to set the initial control values.
            //  if (Mode == MODAL)
            {
                    InitDialog();
                    SetUpCallBack();
                    
                    INT32 i = 0;
                    while (BubbleHelp[i].Gadget)                        
                    {
                        SetGadgetHelp(BubbleHelp[i].Gadget, BubbleHelp[i].BubbleID, BubbleHelp[i].BubbleID);
                        i++;
                    }
                break;
            }
            //  break;

            // Close and destroy the dialog 
            case DIM_COMMIT :
            case DIM_CANCEL :
            {
                EndDialog = TRUE;                       // Flag to close and end
                break;
            }
            //case DIM_SLIDER_POS_SET:
            case DIM_SLIDER_POS_CHANGING:
            {
                // Messages to all the controls, handled individually
                if (Msg->GadgetID == _R(IDC_PREVIEW_SLIDER))
                {
                    // While the animation is playing, if this button is selected,
                    // the play button is clicked out, the stop button is clicked in,
                    // and the next/previous frame in the animation is displayed. 
                    PreviewDlgStop();
                    // Kill any bubble help just in case the user has bubble help up
                    // over the slider
PORTNOTE("other", "Remove Bubble help reference");
#ifndef EXCLUDE_FROM_XARALX
                    ControlHelper::BubbleHelpDisable();
#endif
                    SetSliderPosition();                                                
                                                
                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    InvalidateGadget(_R(IDC_REDRAW_ME));
                }
                break;  //DIM_SLIDER_POS_CHANGING:
            }

            case DIM_LFT_BN_CLICKED :
            {
                // See which button was pressed
                if (FALSE) {}
                else if (Msg->GadgetID == _R(IDC_PREVIEW_PLAY))
                {
                    // Play the animation.
                    PreviewDlgPlay();
                    
                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    InvalidateGadget(_R(IDC_REDRAW_ME));
                }
                else if (Msg->GadgetID == _R(IDC_PREVIEW_STOP))
                {
                    // Stop the animation.
                    PreviewDlgStop();

                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    InvalidateGadget(_R(IDC_REDRAW_ME));
                }
                else if (Msg->GadgetID == _R(IDC_PREVIEW_NEXTFRAME))
                {
                    //  While the animation is playing, if this button is selected,
                    //  the play button is clicked out, the stop button is clicked in,
                    //  and the next frame in the animation is displayed. 
                    PreviewNextFrame();
                                            
                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    InvalidateGadget(_R(IDC_REDRAW_ME));

                    // Only show one frame at a time, therefore set this flag back to false. 
                    m_DisplayNextFrame = FALSE;
                }
                else if (Msg->GadgetID == _R(IDC_PREVIEW_PREVFRAME))
                {
                    // While the animation is playing, if this button is selected,
                    // the play button is clicked out, the stop button is clicked in,
                    // and the previous frame in the animation is displayed. 
                    PreviewPreviousFrame();
                    
                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    InvalidateGadget(_R(IDC_REDRAW_ME));

                    // Only show one frame at a time, therefore, set this flag to false. 
                    m_DisplayPreviousFrame = FALSE;
                }
                else if (Msg->GadgetID == _R(IDC_PREVIEW_REFRESH))
                {
                    // Has the refresh button been clicked, while the dlg is in an idle state.
                    if (m_SetPreviewDlgToIdleState)
                        SetDlgStateAfterDocChange();
                    else
                        SetDlgStateAfterRefresh();                              
                }
                /*
                else if (Msg->GadgetID == _R(IDC_PREVIEW_STARTFRAME))
                {
                    m_DisplayListOfBitmaps = TRUE;

                    // Find the first frame in our list.
                    m_pPreviewDialog->SelectFirstBitmap();

                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    m_pPreviewDialog->InvalidateGadget(_R(IDC_REDRAW_ME));
                    m_DisplayListOfBitmaps = FALSE;

                    break;
                }*/

                /*
                else if (Msg->GadgetID == _R(IDC_PREVIEW_ENDFRAME))
                {
                    m_DisplayListOfBitmaps = TRUE;
                    // Find the first frame in our list.
                    SelectLastBitmap();

                    // Force the gadget to be repainted, 
                    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
                    m_pPreviewDialog->InvalidateGadget(_R(IDC_REDRAW_ME));
                    m_DisplayListOfBitmaps = FALSE;
                }
                {
                    BOOL Valid = FALSE;
                    BOOL State = GetLongGadgetValue(Msg->GadgetID, 0, 1, NULL, &Valid);
                    //if (State)
                    //  SetLongGadgetValue(Msg->GadgetID, !State);
                    break;
                } */
            }

            case DIM_REDRAW :
            {
                // This is where all the redrawing is done
                // Which control in the window is sending the redraw message (if there are many
                // grdraw controls you can tell which is which from the Gadget ID
                if (Msg->GadgetID == _R(IDC_REDRAW_ME))
                {
                    if(m_SetPreviewDlgToIdleState)
                        // Set the Preview dialog to an idle state.
                        SetPreviewDialogToIdleState((ReDrawInfoType*) Msg->DlgMsgParam);
                    else
                        // Render this control.
                        RenderControl((ReDrawInfoType*) Msg->DlgMsgParam);                                              
                }
                else
                {
                    // give out an error in debug builds, ignore in retail builds
                    ERROR3("Got a redraw message for a control I don't know about");
                }
                break;
            }   
            default:
                break;
        }
    }
    else if (MESSAGE_IS_A(Message, DocChangingMsg))
    {
        DocChangingMsg *Msg = (DocChangingMsg *) Message;
        switch (Msg->State)
        {
            case DocChangingMsg::ABOUTTODIE:
            /*{
                if (Msg->pOldDoc == NULL)
                {
                    //Stop playing the animation.
                    m_DocumentAboutToDie = TRUE;

                    // Since the document is about to die, no frame layers will exist.
                    m_GeneratedFrameLayers = FALSE;

                    // Reset the disposal method
                    m_DisposalMethod = GDM_BACKTOBACK;
                    m_CurrentDisposalMethod = GDM_BACKTOBACK;
                
                    // End the dialog
                    // EndDialog = TRUE;                        // Flag to close and end
                }
                break;
            }*/
            case DocChangingMsg::SELCHANGED:
            case DocChangingMsg::BORN:
            /*{
                // called when new is used,thereafter called when no docs. are around.
                if (Msg->pNewDoc == NULL)
                {
                    SetDialogToIdleState();

                    // End the dialog
                    //EndDialog = TRUE;                     // Flag to close and end
                }
                // There is an active doucment around.
                else
                {
                    SetDialogToIdleState();
                }
                break;
            }*/
                EndDialog = TRUE;
            break;

            default:
                break;
        }
    }

    // End dialog here
    if (EndDialog) 
    {
        Close();                // Hide the dialog box
        End();                  // Finish the operation
        return OK;
    }

    // Allow the base class access to the message, it will do the
    // DLG_EAT_IF_HUNGRY(Msg) for us
    // Must do this before the Close and End
    Result = DialogOp::Message(Message);


    // The message was for our dialog box so return that we have handled it, if necessary
    //return (DLG_EAT_IF_HUNGRY(Msg)); 
    return Result;
}  

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

>   BOOL PreviewDialog::SetDialogToIdleState()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/7/97
    Returns:    TRUE if successful, else FALSE
    Purpose:    Ensures that the the dialog is set into an idle state showing a cross in
                the preview section.

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

BOOL PreviewDialog::SetDialogToIdleState()
{
    // Stop playing the animation.
    m_DocumentAboutToDie = TRUE;
    m_PlayAnimation = FALSE;
    
    // Set the Preview dialog to an idle state.
    m_SetPreviewDlgToIdleState = TRUE;

    // Since the document has changed no frame layers will exist.
    // They will require generating.
    m_GeneratedFrameLayers = FALSE;

    // Reset the disposal methods
    m_DisposalMethod = GDM_BACKTOBACK;
    m_CurrentDisposalMethod = GDM_BACKTOBACK;

    // SetDlgState(TRUE);

    // Clean the list of bitmaps that we were animating.
    m_BitmapList.DeleteAll();
    m_BitmapListSize            = 0;
    m_CurrentItem               = 0;
    m_SliderPosition            = m_BitmapListSize;
    m_AnimationRect.MakeEmpty();

    // Reset the loop counts
    m_CurrentLoopCount          = 0;    // The loop that we are currently on (default to start)
    m_RequiredLoopCount         = 0;    // The loop count that we must reach (default for ever)

    // Force the gadget to be repainted, 
    InvalidateGadget(_R(IDC_REDRAW_ME));

    return TRUE;
}

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

>   BOOL PreviewDialog::InitDialog()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Returns:    TRUE if successful, else FALSE
    Purpose:    Sets initial dialog values 

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

BOOL PreviewDialog::InitDialog()
{
    SetGadgetBitmaps(_R(IDC_PREVIEW_SLIDER), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER));
    INT32 StepValue = 100;
    if (m_BitmapListSize > 0)
        StepValue = 100/m_BitmapListSize;

    // Set the range of the slider control plus the step value.  
    SetGadgetRange(_R(IDC_PREVIEW_SLIDER), 1, m_BitmapListSize, StepValue); 
    SetLongGadgetValue(_R(IDC_PREVIEW_SLIDER), m_BitmapListSize - m_CurrentItem);

    // Find the correct bitmap to display.                      
    UINT32 BitmapNum = (m_BitmapListSize - 1);
    SelectCurrentBitmap(BitmapNum);
    
    // Set up the bitmaps for the play controls
    // Uses the title defined in the rc file so do not specify any bitmaps
    SetGadgetBitmaps(_R(IDC_PREVIEW_PLAY), 0, 0);
    SetGadgetBitmaps(_R(IDC_PREVIEW_STOP), 0, 0);
    SetGadgetBitmaps(_R(IDC_PREVIEW_NEXTFRAME), 0, 0);
    SetGadgetBitmaps(_R(IDC_PREVIEW_PREVFRAME), 0, 0);
    SetGadgetBitmaps(_R(IDC_PREVIEW_STARTFRAME), 0, 0);
    SetGadgetBitmaps(_R(IDC_PREVIEW_ENDFRAME), 0, 0);

    // Reset the loop count that we are currently on
    m_CurrentLoopCount = 0;

    // Are we in single bitmap mode?
    if (m_BitmapListSize == 1)
    {
        // Single bitmap mode

        // Enable the play button = grab all frames and play
        if (viaBitmapGallery)
        {
            EnableGadget(_R(IDC_PREVIEW_PLAY), FALSE);//TRUE);

            // Set the title of the dialog to "Preview single bitmap"
            String_256 title(_R(IDS_PREVIEWTITLE_SINGLEBITMAP));
            SetTitlebarName(&title); 

            // change the name field from saying "Frame:" to "Image:"
            String_32 Name(_R(IDS_PREVIEW_FRAMENAMETYPESTR));
            SetStringGadgetValue(_R(IDC_PREVIEW_FRAMENAMETYPE), Name);
        }
        else
        {
            EnableGadget(_R(IDC_PREVIEW_PLAY), TRUE);

            // Set the title of the dialog to "Preview single frame"
            String_256 title(_R(IDS_PREVIEWTITLE_SINGLE));
            SetTitlebarName(&title); 
        }

        // disable all the other controls
        EnableGadget(_R(IDC_PREVIEW_STOP), FALSE);
        EnableGadget(_R(IDC_PREVIEW_NEXTFRAME), FALSE);
        EnableGadget(_R(IDC_PREVIEW_PREVFRAME), FALSE);

        // Disable the slider
        EnableGadget(_R(IDC_PREVIEW_SLIDER), FALSE);

        // Disable the refresh button
        EnableGadget (_R(IDC_PREVIEW_REFRESH), FALSE);

        m_PlayAnimation = FALSE;
    }
    else
    {
        // No, in multiple bitmap mode

        if (viaBitmapGallery)
        {
            // Set the title of the dialog to "Preview multiple images"
            String_256 title(_R(IDS_PREVIEWTITLE_MULTIPLEBITMAP));
            SetTitlebarName(&title);

            // change the name field from saying "Frame:" to "Image:"
            String_32 Name(_R(IDS_PREVIEW_FRAMENAMETYPESTR));
            SetStringGadgetValue(_R(IDC_PREVIEW_FRAMENAMETYPE), Name);
        }
        else
        {
            // Set the title of the dialog to "Preview all frames"
            String_256 title(_R(IDS_PREVIEWTITLE_MULTIPLE));
            SetTitlebarName(&title); 
        }

        // Disable the Play buttton. Enable the Stop buttton.
        EnableGadget(_R(IDC_PREVIEW_PLAY), FALSE);
        EnableGadget(_R(IDC_PREVIEW_STOP), TRUE);

        // Enable the slider
        EnableGadget(_R(IDC_PREVIEW_SLIDER), TRUE);

        // although I would like to do this here, viaBitmapGallery has not been set yet
        // so instead we do this within ToggleViaBitmapGallery ()
        
        if (viaBitmapGallery)
        {
            EnableGadget (_R(IDC_PREVIEW_REFRESH), FALSE);
            SetPlayAnimation (TRUE);
        }
    }

/*  SetGadgetBitmaps(_R(IDC_PREVIEW_PLAY), _R(IDB_PREVIEW_PLAY), _R(IDB_PREVIEW_PLAY));
    SetGadgetBitmaps(_R(IDC_PREVIEW_STOP), _R(IDB_PREVIEW_STOP), _R(IDB_PREVIEW_STOP));
    SetGadgetBitmaps(_R(IDC_PREVIEW_NEXTFRAME), _R(IDB_PREVIEW_NEXT), _R(IDB_PREVIEW_NEXT));
    SetGadgetBitmaps(_R(IDC_PREVIEW_PREVFRAME), _R(IDB_PREVIEW_PREVIOUS), _R(IDB_PREVIEW_PREVIOUS));
    SetGadgetBitmaps(_R(IDC_PREVIEW_STARTFRAME), _R(IDB_PREVIEW_START), _R(IDB_PREVIEW_START));
    SetGadgetBitmaps(_R(IDC_PREVIEW_ENDFRAME), _R(IDB_PREVIEW_END), _R(IDB_PREVIEW_END)); */

    // Set up the frame/layer name control
    String_32 BlankName(TEXT(""));
    SetStringGadgetValue(_R(IDC_PREVIEW_FRAMENAME), BlankName);

    return TRUE;
}

void PreviewDialog::ToggleViaBitmapGallery (BOOL val)
{
    viaBitmapGallery = val;//TRUE;

/*  if (viaBitmapGallery)
    {
//      EnableGadget (_R(IDC_PREVIEW_REFRESH), FALSE);
//      m_Delay = 100;                              // lets make the frames tick slower ....
    }
    else
    {
        EnableGadget (_R(IDC_PREVIEW_REFRESH), TRUE);
    }*/
}


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

>   BOOL PreviewDialog::ReInitDialog()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> from Ranbir code which was in OpGrabFrame::SetFullBitmapList
    Created:    17/6/97
    Returns:    TRUE if successful, else FALSE
    Purpose:    Will reset the initial dialog values. Should be used on an already open
                dialog box.

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

BOOL PreviewDialog::ReInitDialog()
{
    if (GetDlgState())
    {
        SetDocumentAboutToDie(FALSE);
        SetDlgState(FALSE);
        // Set the correct state of the controls.
    }

    // Reset the disposal method
    m_DisposalMethod = GDM_BACKTOBACK;
    m_CurrentDisposalMethod = GDM_BACKTOBACK;

    // Reset the loop count that we are currently on
    m_CurrentLoopCount = 0;

    // Is there more than one bitmap in the animation?
    INT32   BitmapListSize = GetBitmapListSize();
    if (BitmapListSize == 1)
    {
        // Set the title of the dialog to "Preview single frame"
        String_256 title(_R(IDS_PREVIEWTITLE_SINGLE));
        SetTitlebarName(&title); 

        // Enable the play button = grab all frames and play
        EnableGadget(_R(IDC_PREVIEW_PLAY), FALSE);//TRUE);

        // Disable all the other controls
        EnableGadget(_R(IDC_PREVIEW_STOP), FALSE);
        EnableGadget(_R(IDC_PREVIEW_NEXTFRAME), FALSE);
        EnableGadget(_R(IDC_PREVIEW_PREVFRAME), FALSE);

        // Disable the slider
        EnableGadget(_R(IDC_PREVIEW_SLIDER), FALSE);

        // Disable the refresh button
        EnableGadget (_R(IDC_PREVIEW_REFRESH), FALSE);

        // A single frame layer has been generated.
        SetGeneratedFrameLayers(FALSE);
    }
    else
    {
        // Set the title of the dialog to "Preview all frames"
        String_256 title(_R(IDS_PREVIEWTITLE_MULTIPLE));
        SetTitlebarName(&title); 

        // Enable the slider
        EnableGadget(_R(IDC_PREVIEW_SLIDER), TRUE);

        if (viaBitmapGallery)
        {
            EnableGadget (_R(IDC_PREVIEW_REFRESH), FALSE);
            SetPlayAnimation (TRUE);
        }

        // Is the animation playing.
        if (GetPlayAnimation())
        {
            // Set the correct state of the controls.
            EnableGadget(_R(IDC_PREVIEW_PLAY), FALSE);
            EnableGadget(_R(IDC_PREVIEW_STOP), TRUE);
            EnableGadget(_R(IDC_PREVIEW_NEXTFRAME), TRUE);
            EnableGadget(_R(IDC_PREVIEW_PREVFRAME), TRUE);

            // A document change will stop the timer, therefore re-start it.
            RestartTimer();                 
        }
        else
        {
            // Set the correct state of the controls.
            EnableGadget(_R(IDC_PREVIEW_PLAY), TRUE);
            EnableGadget(_R(IDC_PREVIEW_STOP), FALSE);
            EnableGadget(_R(IDC_PREVIEW_NEXTFRAME), TRUE);
            EnableGadget(_R(IDC_PREVIEW_PREVFRAME), TRUE);
        }

        // Set the correct state of the dlg.
        // Ensure that the timer does not get stopped after we restarted it as it thinks
        // that either the animation properties have changed or the document is about to die
        SetDlgState(FALSE);
        SetDocumentAboutToDie(FALSE);
        SetGeneratedFrameLayers(TRUE);
        SetAnimationPropertiesChanged(FALSE);
    }

    // If there is only a single layer, set the slider to the end.
    m_SliderPosition = m_BitmapListSize;
    SetLongGadgetValue(_R(IDC_PREVIEW_SLIDER), m_BitmapListSize);
    
    // Since the dialog is modeless, the user can add extra layers,
    // therefore reset the step value of the slider.
    INT32 Step = 100/ m_BitmapListSize;
    SetGadgetRange(_R(IDC_PREVIEW_SLIDER), 1, m_BitmapListSize, Step);
    SetGadgetBitmaps(_R(IDC_PREVIEW_SLIDER), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER));

    // Find the correct bitmap to display.                      
    //if (m_SliderPosition >= m_BitmapListSize)
    //  m_SliderPosition = 0;
    UINT32 BitmapNum = m_BitmapListSize - m_SliderPosition;
    SelectCurrentBitmap(BitmapNum);

    // Force the gadget to be repainted, 
    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
    InvalidateGadget(_R(IDC_REDRAW_ME));

    // Set up the frame/layer name control
    String_32 BlankName(TEXT(""));
    SetStringGadgetValue(_R(IDC_PREVIEW_FRAMENAME), BlankName);

    return TRUE;
}

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

>   BOOL PreviewDialog::SelectCurrentFrame(const UINT32 Position)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    28/7/97
    Inputs:     The frame to be selected (0 .. max frames - 1)
    Returns:    True if worked ok, False otherwise
    Purpose:    Tries to set the current frame to be displayed and ensure that associated
                items are set e.g. the slider.

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

BOOL PreviewDialog::SelectCurrentFrame(const UINT32 Position)
{
    INT32 NewPosition = (INT32)Position;
    // check if the requested position is beyond the end of the list
    if (NewPosition >= m_BitmapListSize)
        NewPosition = 0;
    
    // Set the current selection to be correct
    SelectCurrentBitmap(NewPosition);

    // Set the slider position REM slider works backwards.
    m_SliderPosition = m_BitmapListSize - NewPosition;
    SetLongGadgetValue(_R(IDC_PREVIEW_SLIDER), m_SliderPosition);

    // Force the main display gadget to be repainted, 
    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
    InvalidateGadget(_R(IDC_REDRAW_ME));

    return TRUE;
}

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

>   BOOL PreviewDialog::StopPreviewing()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/6/97
    Returns:    True if worked ok, False otherwise
    Purpose:    Puts the dialog into a stopped state ready to grab the frames or frame.

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

BOOL PreviewDialog::StopPreviewing()
{
    // Stop the animation.
    PreviewDlgStop();

    // Force the gadget to be repainted, 
    // causes a DIM_REDRAW\_R(IDC_REDRAW_ME) message to be sent.
    InvalidateGadget(_R(IDC_REDRAW_ME));

    // Reset the loop count that we are currently on
    m_CurrentLoopCount = 0;

    return TRUE;
}

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

>   void PreviewDialog::RenderControl(ReDrawInfoType* pExtraInfo)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/4/97
    Inputs:     pExtraInfo - The structure that has the extra data we need to start rendering
    Purpose:    Renders the current bitmap into the control. This actually consists of:-
                    Render slabbed in border
                    Render items before present bitmap in list to set up background
                    Render current bitmap

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

void PreviewDialog::RenderControl(ReDrawInfoType* pExtraInfo)
{
    if (pExtraInfo == NULL)
        return;
    
    // Go get a render region
    DocRect VirtualSize(0, 0, pExtraInfo->dx, pExtraInfo->dy);
    DocRect WholeRedrawSize = VirtualSize;
    
    // If we haven't already created our render region then go and create it
    BOOL StartedOk = TRUE;
    if (m_pRender == NULL)
    {
        // This will call start render for us
        m_pRender = CreateGRenderRegion(&VirtualSize, pExtraInfo);
    }
    else
    {
        // and delete the render region and its (dialog) view
        View * pDialogView = m_pRender->GetRenderView();
        
        if (pDialogView)
        {
            // Try and create the bitmap etc
            StartedOk = m_pRender->AttachDevice(pDialogView, pExtraInfo->pDC, NULL);

            // Try and start the render region
            StartedOk = StartedOk && m_pRender->StartRender();
        }
        else
            StartedOk = FALSE;
    }

    // if we have a render region then go and use it
    if (m_pRender != NULL && StartedOk)
    {
        // Code stolen from ColourEditDlg::RenderControl
        DialogColourInfo RedrawColours;             // Get a supplier for default dlg colours
        INT32 PixelSize = 72000 / pExtraInfo->Dpi;  // Size of output pixel in millipoints

        GridLockRect(&VirtualSize, PixelSize);

        // Render the attributes and then a rectangle
        m_pRender->SaveContext();

        // Get the current bitmap and try and display it
        KernelBitmap * pBitmapToUse = GetCurrentBitmap();
        if (pBitmapToUse)
        {
            // Using this method we don't get flicker on the backdrop as we draw the background rectangle
            // followed by the white new background
            // Draw single pixel black line left and top and single pixel background colour 1 pixel in
            m_pRender->SetLineWidth(0);
            m_pRender->SetFillColour(RedrawColours.DialogBack());
            m_pRender->SetLineColour(COLOUR_BLACK); //RedrawColours.ButtonShadow());
            m_pRender->DrawLine(DocCoord(VirtualSize.lo.x, VirtualSize.hi.y - PixelSize),
                                DocCoord(VirtualSize.hi.x, VirtualSize.hi.y - PixelSize));
            m_pRender->DrawLine(DocCoord(VirtualSize.lo.x, VirtualSize.hi.y),
                                DocCoord(VirtualSize.lo.x, VirtualSize.lo.y));
            m_pRender->SetLineColour(RedrawColours.DialogBack());
            m_pRender->DrawLine(DocCoord(VirtualSize.lo.x + PixelSize, VirtualSize.hi.y - 2 * PixelSize),
                                DocCoord(VirtualSize.hi.x - PixelSize, VirtualSize.hi.y - 2 * PixelSize));
            m_pRender->DrawLine(DocCoord(VirtualSize.lo.x + PixelSize, VirtualSize.lo.y),
                                DocCoord(VirtualSize.lo.x + PixelSize, VirtualSize.hi.y - 2 * PixelSize));

            // Draw single pixel hightligh line right and bottom and single pixel background colour 1 pixel in
            m_pRender->SetLineColour(RedrawColours.ButtonHighlight());
            m_pRender->DrawLine(DocCoord(VirtualSize.hi.x - PixelSize, VirtualSize.hi.y - PixelSize),
                                DocCoord(VirtualSize.hi.x - PixelSize, VirtualSize.lo.y));
            m_pRender->DrawLine(DocCoord(VirtualSize.hi.x - PixelSize, VirtualSize.lo.y),
                                DocCoord(VirtualSize.lo.x + PixelSize, VirtualSize.lo.y));

            m_pRender->SetLineColour(RedrawColours.DialogBack());
            m_pRender->DrawLine(DocCoord(VirtualSize.hi.x - 2 * PixelSize, VirtualSize.hi.y - 2 * PixelSize),
                                DocCoord(VirtualSize.hi.x - 2 * PixelSize, VirtualSize.lo.y + 1 * PixelSize));
            m_pRender->DrawLine(DocCoord(VirtualSize.hi.x - 2 * PixelSize, VirtualSize.lo.y + 1 * PixelSize),
                                DocCoord(VirtualSize.lo.x + 2 * PixelSize, VirtualSize.lo.y + 1 * PixelSize));

            // And deflate the rect by 2 pixels
            VirtualSize.Inflate(-PixelSize * 2);

            // Ensure that we cannot redraw into the border that we have just redrawn
//          m_pRender->SetClipRect(VirtualSize);

            // Code stolen from BfxDlg::RenderBitmap
            m_pRender->SetLineColour(COLOUR_TRANS);

            // If we are playing then assume we need the quickest redraw and we will
            // be overlaying the correct frames.
/*          if (m_PlayAnimation)
            {
                // Check the GIFDisposalMethod for the previous bitmap. If necessary redraw the background.
                if (m_DisposalMethod == GDM_BACKTOBACK)
                {
                    // Draw a rectangle to fill in the background - Fill with Dialogue Background colour
                    //m_pRender->SetFillColour(RedrawColours.DialogBack()); // COLOUR_WHITE); //
                    m_pRender->SetFillColour(COLOUR_WHITE); 
                    m_pRender->DrawRect(&VirtualSize);
                }
                // This is REDRAW code and so noting the redraw method is very bad.
                // Should be done in the code which moves between frames.
                //m_DisposalMethod = pBitmapToUse->GetAnimationRestoreType();

                // redraw the specified bitmap into the render region
                RedrawBitmap(pBitmapToUse, &VirtualSize);
            }
            else */
            {
                // Try just redrawing everything we need to

                // Not playing so we must redraw everything that is required to make up
                // this frame. If the previous frame is restore background then we just
                // need to redraw this frame. If the previous frame is anything else then
                // we need to move back through the frames until we find the start or a
                // frame with restore background and then draw from this point.
                // If we encounter a bitmap which is restore previous and it is not this
                // one then we need do nothing.

                // Draw a rectangle to fill in the background
                m_pRender->SetFillColour(COLOUR_WHITE); 
                m_pRender->DrawRect(&VirtualSize);

//              INT32 ThisIndex = m_CurrentItem;
                INT32 StartIndex = m_CurrentItem;
                BOOL StartFrameFound = FALSE;
                // First, search out the first frame to redraw
                while (!StartFrameFound && StartIndex > 0)
                {
                    // Move to the previous item in the list
                    StartIndex--;
                    KernelBitmap * pBitmap = GetBitmapItem(StartIndex);
                    // Check the GIFDisposalMethod for the previous bitmap.
                    if (pBitmap == NULL)
                    {
                        // No previous frame so stop the search now
                        StartFrameFound = TRUE;
                        StartIndex++;
                    }
                    else if (pBitmap->GetAnimationRestoreType() == GDM_BACKTOBACK)
                    {
                        // Its a restore background so we have found our first frame
                        // to redraw, its StartIndex + 1
                        StartFrameFound = TRUE;
                        StartIndex++;
                    }
                }

                // I'm not sure why they were originally doing this, BUT I've taken it out
                // because it was causing problems with my new stuff ....

                // Now redraw all the bitmaps from the start frame onwards
                // up to the frame before the current one
        /*      for (INT32 i = StartIndex; i < ThisIndex; i++)
                {
                    KernelBitmap * pBitmap = GetBitmapItem(i);
                    if (pBitmap && pBitmap->GetAnimationRestoreType() != GDM_PREVIOUS)
                    {
                        RedrawBitmap(pBitmap, &VirtualSize);
                    }
                }*/

                // Lastly, redraw the present bitmap into the render region
                RedrawBitmap(pBitmapToUse, &VirtualSize);
            }
        }
        else
        {
            // draw a cross to show we do not have a bitmap
            RedrawCross(&VirtualSize, &RedrawColours, PixelSize);
        }

        // Now that we have drawn everything, reset the cliprect back to the whole
        // size, otherwise it seems to stop redrawing the border.
        m_pRender->SetClipRect(WholeRedrawSize);

        m_pRender->RestoreContext();

        // Get rid of the render region, now done in the destructor
        //DestroyGRenderRegion(m_pRender);
        
        // Blit to the screen
        m_pRender->StopRender();
    }
}

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

>   BOOL PreviewDialog::RedrawBitmap(KernelBitmap * pBitmapToUse, DocRect * pVirtualSize)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/6/97
    Inputs:     pBitmap             the bitmap to redraw
                pVirtualSize        the size of the area to redraw into
    Purpose:    Redraws th