clipext.cpp

Go to the documentation of this file.

// $Id: clipext.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============================
 */
// External clipboard interface - classes for encapsulating clipboard data mappings
// and for managing data transfers between the internal and external clipboards

#include "camtypes.h"

#include "stdafx.h"
//#include "clipdlg.h"
#include "clipext.h"
#include "clipint.h"
#include "clipmap.h"
#include "natclipm.h"
//#include "jason.h"

// **** TEMPORARY BODGE includes for crappy bitmap export
//#include "ccobject.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "node.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "grndbmp.h"
#include "layer.h"
//#include "spread.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "dlgview.h"
#include "vstate.h"
#include "wbitmap.h"

#include "mainfrm.h"
#include "camvw.h"
// ****

#if (_OLE_VER >= 0x200)
#include "camdoc.h"
#include "camelot.h"
#include "srvritem.h"
//#include "filters.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#endif

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

// --- Support for node types used in scanning the document tree for KeepClipboardOnExit
#include "nodeblnd.h"
#include "nodebmp.h"
#include "bitmpinf.h"
//#include "fillattr.h" - in camtypes.h [AUTOMATICALLY REMOVED]
// ---

// --- OLE clipboard
#if (_OLE_VER >= 0x200)
#include "dataobj.h"
#endif

//#include "richard2.h" // For resource strings
//#include "justin3.h"
//#include "mario.h"

CC_IMPLEMENT_MEMDUMP(ExternalClipboard, CC_CLASS_MEMDUMP)
CC_IMPLEMENT_DYNCREATE(OpClipboardExport, Operation)
CC_IMPLEMENT_DYNCREATE(OpClipboardImport, SelOperation)
CC_IMPLEMENT_DYNAMIC(ClipboardView, View)
CC_IMPLEMENT_DYNCREATE(PasteSpecialDlg, DialogOp)


#define new CAM_DEBUG_NEW


// define this symbol as 1 to enable paste-special behaviour (this makes a paste show
// the paste-special dialogue box) or 0 to get "normal" simple paste behaviour.
#if _DEBUG
#define DO_PASTE_SPECIAL 1
#else
#define DO_PASTE_SPECIAL 1
#endif


// Statics ----------------------------------------------------------------------------------
ExternalClipboard* ExternalClipboard::pInstance = NULL;

// This value is the (rough) number of nodes in the clipboard tree before we think it's worth
// asking the user about whether they want the clipboard contents retained on exit. This is
// a very rough guide, mainly to eliminate this question when there is only trivial data
// (a sentence or a couple of blobs) on the clipboard.
// Note that this is not a strict node count. For example, blends and grad fill attributes
// cause a large count to be added, as these nodes can produce much larger output in
// standard clipboard formats such as WMF, while text characters cause a lower value.
// Each other node generally adds about 10 to the value, so 2000 corresponds roughly
// to 2000 characters, 200 nodes in the tree, or 10 grad-filled objects.
const INT32 KeepClipboardThreshold = 4000;
// ------------------------------------------------------------------------------------------


BOOL ExternalClipboard::m_fUpdateSystemClipboard = TRUE;


/********************************************************************************************
    Preference: DontExportCMXInIDataObject
    Section:    OLE Local Server
    Range:      0 .. 1 (FALSE .. TRUE)
    Purpose:    If TRUE then don't offer to render CorelXARA documents in Corel CMX format
                for transfer via the clipboard or drag'n'drop.  Setting this pref. to TRUE
                overcomes a bug when embedding CorelXARA documents into CorelDRAW.  By
                default this setting is TRUE.  Making it FALSE will allow you to transfer
                CorelXARA documents to CorelDRAW via the clipboard or drag'n'drop in the
                CMX format, but embedding CorelXARA documents in CorelDRAW will no longer#
                work properly.
********************************************************************************************/
static BOOL fNoCMXDataExport = TRUE;


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

>   ExternalClipboard::ExternalClipboard()

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

    Purpose:    constructor

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

ExternalClipboard::ExternalClipboard()
{
    if (pInstance == NULL)
        pInstance = this;
    else
    {
        ERROR3("Oy! You can't have more than one instance of the ExternalClipboard!");
    }

    KeepFormatsOnExit = TRUE;

#if (_OLE_VER >= 0x200)
    m_fIgnoreChange = FALSE;
#endif
}



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

>   virtual ExternalClipboard::~ExternalClipboard()

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

    Purpose:    Destructor. Cleans up our lists and wotnot.

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

ExternalClipboard::~ExternalClipboard()
{
    Mappings.DeleteAll();

    if (pInstance == this)
        pInstance = NULL;
    else
    {
        ERROR3("Oy! You can't have more than one instance of the ExternalClipboard!");
    }
}



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

>   static BOOL ExternalClipboard::Init(void)

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

    Purpose:    Initialises the ExternalClipboard ready for operation

    SeeAlso:    ExternalClipboard::Deinit

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

BOOL ExternalClipboard::Init(void)
{
    if (!OpClipboardExport::Init())
        return(FALSE);

    if (!OpClipboardImport::Init())
        return(FALSE);

    if (!PasteSpecialDlg::Init())
        return(FALSE);

    ExternalClipboard *TheClipboard = new ExternalClipboard();
    if (TheClipboard == NULL)
        return(FALSE);


    // **** !!!! DEBUG BODGE - add export mapping for text characters - ideally this
    // clipboard mapping should be provided by a proper text import/export filter,
    // but one does not exist yet.
    // Add a UNICODE filter - this only works under NT, as nobody else supports unicode
    BodgeUnicodeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, CF_UNICODETEXT);

    // 8-bit text (windows implicitly converts between these for us)
    // The first one is the filter, while the second one is an 'alias' for import
    // which will make windows convert the OEMTEXT into TEXT and then we put this through
    // our normal TEXT mapping...
    BodgeTextClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, CF_TEXT);
    BodgeTextClipMap::CreateAndRegister(CLIPMAP_IMPORTONLY, CF_OEMTEXT);

    // Add bitmap/DIB import/export mappings
    // Note that if we export WMF and DIB, there is no need to bother with Bitmap
    // (Corel don't, probably because there is no way of getting a quality image via Bitmaps,
    // and also because some programs are stupid and corrupt the DIB by using the palette
    // which we supply for the Bitmap! Arrgh!)
//  BitmapClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT);
    BitmapClipMap::CreateAndRegister(CLIPMAP_IMPORTONLY);

    DIBClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT);

    // CMX import and export stuff to make commicating with Corel happier
    CMX16ClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, ::RegisterClipboardFormat("Corel Presentation Exchange Data"));
    CMX32ClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT, ::RegisterClipboardFormat("Corel 32-bit Presentation Exchange Data"));

    // native clipboard thing -- for OLE stuff
    //
    // this is export only (although functional code does exist for import)
    // as there are several technical problems with getting the native filter
    // to import into the clipboard document. See the comment near the
    // NativeClipMap::HandleImport() function for more details.
    NativeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT /*CLIPMAP_EXPORTONLY*/, ::RegisterClipboardFormat("CorelXARA Document"));
//  NativeClipMap::CreateAndRegister(CLIPMAP_IMPORTEXPORT /*CLIPMAP_EXPORTONLY*/, ::RegisterClipboardFormat("XaraX Document"));

    // Add a palette export mapping - used in conjunction with Bitmap exporter, it provides
    // the palette for the given bitmap. (not needed now we don't export BMPs)
//  PaletteClipMap::CreateAndRegister();

#if FALSE
    // And add our Quark EPS import filter
    QuarkPictureClipMap::CreateAndRegister();
#endif

    // Read the bug-fix preference for CMX.
    if (!GetApplication()->DeclareSection(TEXT("OLE Local Server"), 5) ||
        !GetApplication()->DeclarePref(TEXT("OLE Local Server"),
                                       TEXT("DontExportCMXInIDataObject"),
                                       &fNoCMXDataExport, FALSE, TRUE))
    {
        TRACEUSER( "JustinF", _T("Couldn't read CMX pref in ExternalClipboard::Init\n"));
        return FALSE;
    }

    return(TRUE);
}



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

>   static void ExternalClipboard::Deinit(void)

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

    Purpose:    De-Initialises the ExternalClipboard when you're shutting down

    SeeAlso:    ExternalClipboard::Init

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

void ExternalClipboard::Deinit(void)
{
    if (pInstance != NULL)
        delete pInstance;
    pInstance = NULL;
}



//
//  The OLE clipboard
//

#if (_OLE_VER >= 0x200)

/********************************************************************************************
>   void ExternalClipboard::SetRenderMemory(HGLOBAL hMem)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/96
    Inputs:     hMem        ---     the global memory to delay-render into, or null if
                                    the rendering functions themselves should allocate
                                    it.
    Purpose:    Sets the memory that the delay-render functions will render into.
    SeeAlso:    CCamDataSource::OnRenderGlobalData
********************************************************************************************/

void ExternalClipboard::SetRenderMemory(HGLOBAL hMem)
{
    // Record the handle and its size, if any.
    m_hMem = hMem;
    m_cbMemSize = (m_hMem != 0) ? ::GlobalSize(m_hMem) : 0;
}




/********************************************************************************************
>   HGLOBAL ExternalClipboard::GetRenderMemory() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/96
    Returns:    The global memory block that was delay-rendered into.
    Purpose:    
    SeeAlso:    ExternalClipboard::SetRenderMemory
********************************************************************************************/

HGLOBAL ExternalClipboard::GetRenderMemory() const
{
    return m_hMem;
}

#endif



/********************************************************************************************
>   BOOL ExternalClipboard::IsOurs() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    16/9/96
    Returns:    TRUE if Camelot currently owns the clipboard, FALSE if it doesn't or the
                clipboard is empty.
    SeeAlso:    COleDataSource::GetClipboardOwner; CWnd::GetClipboardOwner
********************************************************************************************/

BOOL ExternalClipboard::IsOurs() const
{
#if (_OLE_VER >= 0x200)
    // OLE does it with data sources (but paste still does it with window handles).
    return CCamDataSource::GetClipboardOwner() != 0 ||
           CWnd::GetClipboardOwner() == GetOwnerWindow();
#else
    // Windows does it with window handles.
    return CWnd::GetClipboardOwner() == GetOwnerWindow();
#endif
}






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

>   static void ExternalClipboard::PrepareForShutdown()

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

    Purpose:    Asks the user if they want to keep the clipboard content and renders the
                formats immeidately if they said yes. This is called on exit, BEFORE any
                windows close etc, so that the user is aware that Camelot is still running
                and that it is busy exporting the clipboard.

                The user may not be asked at all (e.g. if we don't own the clipboard)

    SeeAlso:    ExternalClipboard::RenderAllFormats; ExternalClipboard::CheckKeepClipboardOnExit

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

BOOL fBodgeNoCMX = FALSE;

void ExternalClipboard::PrepareForShutdown()
{
    // Is there a clipboard?
    if (InternalClipboard::IsEmpty(FALSE)) return;

    ExternalClipboard* pClipboard = GetExternalClipboard();
    if (pClipboard == NULL) return;

    pClipboard->CheckKeepClipboardOnExit();

#if (_OLE_VER >= 0x200)

    if (pClipboard->KeepFormatsOnExit)
    {
        // Render all the clipboard formats now (except CMX cos it may crash if there's a
        // bitmap or a fractal about - doh-doh-double-doh?!?!?)
//      TRACEUSER( "JustinF", _T("Rendering clipboard formats now ...\n"));
        fBodgeNoCMX = TRUE;
        CCamDataSource::FlushClipboard();
        fBodgeNoCMX = FALSE;
    }
    else
    {
        // Discard the clipboard contents now.
//      TRACEUSER( "JustinF", _T("Discarding clipboard formats ...\n"));
        COleDataSource* pSource = CCamDataSource::GetClipboardOwner();
        if (pSource) pSource->Empty();
    }

#else

    // This member var. will have been set by someone calling CheckKeepClipboardOnExit()
    if (!pClipboard->KeepFormatsOnExit)
    {
        // They don't want to keep the clipboard formats, so wipe the clipboard.
        CWnd* pParent = GetOwnerWindow();
        if (pParent->OpenClipboard() != NULL)
        {
            ::EmptyClipboard(); 
            ::CloseClipboard();
        }
        return;
    }

    // They do want to keep the clipboard contents, so render all formats to it now
    pClipboard->RenderAllFormats();

#endif

    // And make sure that we ignore any further attempt to make us render formats
    pClipboard->KeepFormatsOnExit = FALSE;
}



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

>   void ExternalClipboard::CheckKeepClipboardOnExit(void)

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

    Purpose:    Called once on exit to check if the user wants the contents of the clipboard
                to be available after camelot is gone. This is supposed to be done when
                RenderAllFormats is called, but this happens after the main frame window has
                departed, so we want someone to call this method sometime between the last
                document being closed and the main frame being removed.

                It flags the user's choice, and this result will be used if/when we get
                a render-all-formats request.

                The user may not be asked at all (e.g. if we don't own the clipboard)

    SeeAlso:    ExternalClipboard::RenderAllFormats

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

void ExternalClipboard::CheckKeepClipboardOnExit(void)
{
    if (InternalClipboard::IsEmpty(FALSE))                  // No clipboard!
        return;

    // Do we own the clipboard?
    if (!IsOurs()) return;

    // OK, Now let's determine just how complicated the data is. If it looks like it
    // will take an INT32 time or a lot of memory to leave it on the CB, then we'll
    // ask the user - if not, we'll just stay quiet about it and lump it all onto
    // the CB without asking permission.
    // This is done with a very rough guide: A node count of the clipboard content,
    // modified slightly to take account of the fact that blends and grad fills usually
    // cause a lot more output (in WMF format etc). 
    Node *pRoot = InternalClipboard::GetInsertionLayer();
    if (pRoot == NULL)
    {
        KeepFormatsOnExit = TRUE;
        return;
    }

    Node *pNode = pRoot->FindFirstDepthFirst();
    INT32 RoughNodeCount = 0;

    while (pNode != NULL && RoughNodeCount < KeepClipboardThreshold)
    {
        if (pNode->IsAVisibleTextNode())
        {
            RoughNodeCount += 1;            // Text chars export small, so count as 1
        }
        else if (IS_A(pNode, NodeBlend))
        {
                                            // Each blend step counts as another 8
            RoughNodeCount += 128 * (((NodeBlend *)pNode)->GetNumBlendSteps());
        }
        else if (pNode->IsAnAttribute())
        {
                                            // Each fill counts as 64 (in case it's a grad fill)
            if (pNode->IsKindOf(CC_RUNTIME_CLASS(AttrFillGeometry)))
                RoughNodeCount += 64;
        }
        else if (IS_A(pNode, NodeBitmap))
        {
                                            // Add Bitmap memory size to the count
                                            // This will hit the threshold at about 128kB
            KernelBitmapRef *BmpRef = ((NodeBitmap*)pNode)->GetBitmapRef();
            if (BmpRef != NULL)
            {
                KernelBitmap *KernelBmp = BmpRef->GetBitmap();
                if (KernelBmp != NULL)
                {
                    OILBitmap *OilBmp = KernelBmp->ActualBitmap;
                    if (OilBmp != NULL)
                    {
                        BitmapInfo BmpInfo;
                        OilBmp->GetInfo(&BmpInfo);
                        RoughNodeCount += BmpInfo.MemoryUsed / 32;
                    }
                }
            }
            
        }
        else
            RoughNodeCount += 10;           // All other nodes count as 10

        pNode = pNode->FindNextDepthFirst(pRoot);
    }

    // Default to saving the clipboard content on exit...
    KeepFormatsOnExit = TRUE;

    if (RoughNodeCount >= KeepClipboardThreshold)
    {
        // It looks a bit complicated, so maybe we'd better ask the user if they want the
        // clipboard contents to stick around once Camelot has quit.
        INT32 ButtonPressed = AskQuestion(_R(IDS_CLIPBOARD_KEEPONQUIT),
                                        _R(IDS_CLIPBOARD_KEEP), _R(IDS_CLIPBOARD_DISCARD));

        // Then remember whether we should render all available formats to the clipboard
        KeepFormatsOnExit = (ButtonPressed == 1);
    }
}


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

>   static BOOL ExternalClipboard::CanImport(UINT32 WindowsFormat)

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

    Inputs:     WindowsFormat - the windows format (e.g. CF_ constant) which you wish to check

    Returns:    TRUE if it can import that data type

    Purpose:    Determines if there is an import mapping that can cope with the given format

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

BOOL ExternalClipboard::CanImport(UINT32 WindowsFormat)
{
    if (pInstance == NULL)
        return(FALSE);

    ClipboardMapping *Mapping = (ClipboardMapping *) pInstance->Mappings.GetHead();
    while (Mapping != NULL)
    {
        if (Mapping->Type != CLIPMAP_EXPORTONLY && Mapping->ExternalDataType == WindowsFormat)
            return(TRUE);

        Mapping = (ClipboardMapping *) pInstance->Mappings.GetNext(Mapping);
    }

    return(FALSE);
}



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

>   static void ExternalClipboard::RegisterDataType(ClipboardMapping *Mapping)

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

    Inputs:     TypeInfo - info describing the import/export mapping to add

    Purpose:    Called by filters to add import/export mappings to the external clipboard.
                Each mapping indicates which filter to call in order to convert data 
                between a particular internal and external clipboard format.

    Notes:      The Mapping is NOW OWNED by the ExternalClipboard. DO NOT DELETE IT.

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

void ExternalClipboard::RegisterDataType(ClipboardMapping *Mapping)
{
    ERROR3IF(Mapping == NULL, "Illegal NULL param");

    if (pInstance == NULL)
    {
        ERROR3("Attempt to register a clipboard mapping when there is no ExternalClipboard");
        delete Mapping;
        return;
    }

    List *TheList = &pInstance->Mappings;
    ClipboardMapping *Ptr = (ClipboardMapping *) TheList->GetHead();

    while (Ptr != NULL)
    {
        if (Ptr->Priority < Mapping->Priority)
        {
            TheList->InsertBefore(Ptr, Mapping);
            return;
        }

        Ptr = (ClipboardMapping *) TheList->GetNext(Ptr);
    }       

    // Haven't found a lower-priority entry, so this one belongs at the tail
    TheList->AddTail(Mapping);
}



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

>   static void ExternalClipboard::DescribeContents(String_64 *Result)

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

    Outputs:    Result will be returned with a string describing the current clipboard
                format. This may be the format of the internal clipboard (quickshape,
                line, etc) or could be from the external clipboard (metafile, text, bitmap)

                If no special information can be given, or if the clipboard is empty, Result
                will contain an empty string

    Purpose:    To get the textual description of the clipboard format which will be pasted
                if a paste operation is to be applied now.

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

void ExternalClipboard::DescribeContents(String_64 *Result)
{
    ERROR3IF(Result == NULL, "Illegal null param");

    // Ensure a safe return value
    *Result = TEXT("");

    if (pInstance == NULL)          // There ain't no clipboard hereabouts, mac!
        return;

    if (pInstance->IsOurs() || !InternalClipboard::IsEmpty(FALSE))
    {
        // We own the clipboard, or have a cached result - Use the internal one
        ERROR3IF(InternalClipboard::IsEmpty(FALSE),
                "We own the clipboard but the internal clipboard is empty!!");

        InternalClipboard::DescribeContentsInternal(Result);
        return;
    }

    if (GetOwnerWindow()->OpenClipboard() == NULL)
        return;                 // Can't open the clipboard

    UINT32 ThisFormat = 0;
    UINT32 DefaultImportFormat = 0;
    INT32 NumExternalFormats = 0;
    BOOL IncludesTextFormat = FALSE;
    do
    {
        ThisFormat = EnumClipboardFormats(ThisFormat);
        if (ThisFormat != 0 && ExternalClipboard::CanImport(ThisFormat))
        {
            // Bodge - text can be on the clipboard in 3 forms, but we only want to treat
            // it as a single format for the 'paste special' count
            if (ThisFormat == CF_TEXT || ThisFormat == CF_UNICODETEXT || ThisFormat == CF_OEMTEXT)
            {
                if (!IncludesTextFormat)
                    NumExternalFormats++;

                IncludesTextFormat = TRUE;
            }
            else
                NumExternalFormats++;

            // Remember which format we will import by default
            if (DefaultImportFormat == 0)
                DefaultImportFormat = ThisFormat;
        }
    } while (ThisFormat != 0);

    ::CloseClipboard();

    if (NumExternalFormats > 1)
    {
        // if there are 2 or more external formats, then we'll paste special ("Paste...")
        *Result = _R(IDS_CLIPFORMAT_ELIPSES); // TEXT("...");
    }
    else
    {
        // There is no data, or only one format that we recognise. If there is something we
        // can paste, then lob its name on the end ("Paste blobby"), else leave result blank ("Paste")
        if (DefaultImportFormat != 0)
            GetExternalFormatName(DefaultImportFormat, Result);
    }
}



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

>   static void ExternalClipboard::GetExternalFormatName(UINT32 ExternalFormat, String_64 *Result)

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

    Inputs:     ExternalFormat - A windows clipboard format ID (e.g. a CF_ constant)

    Outputs:    Result will be returned with a string describing this format

    Purpose:    To get the textual description of a clipboard format

    Notes:      Microsoft, being in a particularly helpful frame of mind, have
                given us a function that does not provide the names of the default
                (CF_ constant) clipboard formats. We must therefore recognise all the
                likely formats and provide our own names. Thanks, guys.

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

void ExternalClipboard::GetExternalFormatName(UINT32 ExternalFormat, String_64 *Result)
{
    ERROR3IF(Result == NULL, "Illegal NULL param");

    if (ExternalFormat >= 0xC000 && ExternalFormat <= 0xFFFF)
    {
        GetClipboardFormatName(ExternalFormat, (LPTSTR)((TCHAR *)*Result), 63);
        if (*Result==String_64(_T("CorelXARA Document")))
            *Result = String(_R(IDS_CLIPFORMAT_NATIVE));
    }
    else
    {
        switch(ExternalFormat)
        {
            case CF_TEXT:
                *Result = String(_R(IDS_CLIPFORMAT_ATEXT));
                break;

            case CF_BITMAP:
                *Result = String(_R(IDS_CLIPFORMAT_BMP));
                break;

            case CF_METAFILEPICT:
                *Result = String(_R(IDS_CLIPFORMAT_WMF));
                break;

//          case CF_SYLK:
//              *Result = TEXT("Symbolic Link");
//              break;

//          case CF_DIF:
//              *Result = TEXT("Data Interchange Format");
//              break;

            case CF_TIFF:
                *Result = String(_R(IDS_CLIPFORMAT_TIFF));
                break;

            case CF_OEMTEXT:
                *Result = String(_R(IDS_CLIPFORMAT_ATEXT)); // Shares 'unformatted text' with CF_TEXT
                break;

            case CF_DIB:
                *Result = String(_R(IDS_CLIPFORMAT_DIB));
                break;

//          case CF_PALETTE:
//              *Result = TEXT("Palette");
//              break;

//          case CF_PENDATA:
//              *Result = TEXT("Pen data");
//              break;

//          case CF_RIFF:
//              *Result = TEXT("RIFF data");
//              break;

//          case CF_WAVE:
//              *Result = TEXT("WAVE sound");
//              break;

            case CF_UNICODETEXT:
                *Result = String(_R(IDS_CLIPFORMAT_UTEXT));
                break;

            case CF_ENHMETAFILE:
                *Result = String(_R(IDS_CLIPFORMAT_EMF));
                break;

            default:
                *Result = String(_R(IDS_CLIPFORMAT_UNRECOGNISED_FORMAT)); // "Unrecognised format"
                TRACE( _T("WARNING: Unrecognised 'standard' windows clipboard format (%ld), %s,%ld\n"),
                        (INT32)ExternalFormat, __FILE__, __LINE__);
                break;
        }
    }


// If you want to hack a clipboard format, this little baby knows
// how to dump it into the file c:\jason.tmp
#if FALSE
#if _DEBUG
/*
    if (!camStrncmp((TCHAR *)(*Result), "QuarkXPress", 10)) // A Quack XPress clipboard format?
    {
        HANDLE Bob = GetClipboardData(ExternalFormat);
        char *buff = (char *) GlobalLock(Bob);

        FILE *fp = _tfopen("c:\\jason.tmp", "wb");
        size_t Size = (size_t)GlobalSize(Bob);
        fwrite(buff, 1, Size, fp);
        fclose(fp);

        GlobalUnlock(Bob);

        ERROR3("Quack XPress data detected and saved!");
    }
*/
#endif
#endif
}



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

>   static BOOL ExternalClipboard::IsEmpty(void)

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

    Returns:    TRUE if the clipboard is ready to accept new data
                FALSE if the copy must be aborted

    Purpose:    To ready the clipboard for a cut/copy operation (copy data TO the clipboard).
                This will interact with the external clipboard in order to claim the global
                clipboard, and readies the clipboard for use.

    Notes:      After you have copied data to the clipboard, you MUST call CopyCompleted

    Scope:      protected (for friend class InternalClipboard only)

    SeeAlso:    ExternalClipboard::CopyCompleted; ExternalClipboard::PrepareForPaste

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

BOOL ExternalClipboard::IsEmpty(void)
{
    BOOL IsEmpty = TRUE;

    if (pInstance == NULL)
        return(TRUE);

    CWnd *Parent = GetOwnerWindow();
    if (Parent == NULL) return TRUE;

    if (pInstance->IsOurs())    // We own the clipboard! Use the internal one
    {
        if (InternalClipboard::IsEmpty(FALSE))
        {
            ERROR3("We own the clipboard but the internal clipboard is empty!!");
        }
        else
        {
            ERROR3("Why are you asking the External clipboard if it's empty when the internal one isn't?");
        }
        return(FALSE);
    }

    if (Parent->OpenClipboard() == NULL)
        return(TRUE);           // Can't open the clipboard, so we're empty

    ClipboardMapping *Mapping;
    UINT32 ThisFormat = 0;      // 0 makes EnumClipboardFormats start from the beginning
    do
    {
        ThisFormat = EnumClipboardFormats(ThisFormat);  

        if (ThisFormat != 0)
        {
            Mapping = (ClipboardMapping *) pInstance->Mappings.GetHead();
            while (Mapping != NULL && IsEmpty)
            {
                // If this mapping is an import mapping and can handle this external format,
                // then we need look no further - there is importable data on the clipboard
                if (Mapping->Type != CLIPMAP_EXPORTONLY && Mapping->ExternalDataType == ThisFormat)
                    IsEmpty = FALSE;

                Mapping = (ClipboardMapping *) pInstance->Mappings.GetNext(Mapping);
            }
        }
    } while (ThisFormat != 0 && IsEmpty);

    ::CloseClipboard();
    return(IsEmpty);
}



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

>   BOOL ExternalClipboard::PrepareForCopy(void)

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

    Returns:    TRUE if the clipboard is ready to accept new data
                FALSE if the copy must be aborted

    Purpose:    To ready the clipboard for a cut/copy operation (copy data TO the clipboard).
                This will interact with the external clipboard in order to claim the global
                clipboard, and readies the clipboard for use.

    Notes:      After you have copied data to the clipboard, you MUST call CopyCompleted

    Scope:      protected (for friend class InternalClipboard only)

    SeeAlso:    ExternalClipboard::CopyCompleted; ExternalClipboard::PrepareForPaste

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

BOOL ExternalClipboard::PrepareForCopy(void)
{
    // Do nothing

    return(TRUE);
}



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

>   BOOL ExternalClipboard::CopyCompleted(void)

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

    Returns:    TRUE if all went well
                FALSE if the copy failed in some way

    Purpose:    Tells the ExternalClipboard that you have finished copying data to it.
                This interacts with the external clipboard in order to make the new data
                available to the outside world.

    Notes:      Before starting to copy data to the clipboard you MUST call PrepareForCopy

                This is called AFTER have updated the internal clipboard. However, if we
                already own the Windows clipboard, Windows very kindly asks us to destroy
                our clipboard when we call EmptyClipboard. To avoid disembowling ourselves
                we thus have to check if we are the owner of the clipboard so that we only
                wipe the internal clipboard if someone else takes control of the
                external clipboard - see DestroyClipboard

    Scope:      protected (for friend class InternalClipboard only)

    SeeAlso:    ExternalClipboard::PrepareForCopy

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

BOOL ExternalClipboard::CopyCompleted(void)
{
//  TRACEUSER( "JustinF", _T("In ExternalClipboard::CopyCompleted\n"));
    InternalClipboardFormat VectorFormat(CLIPTYPE_VECTOR);

    ClipboardMapping *Mapping = (ClipboardMapping *) Mappings.GetHead();
    while (Mapping != NULL)
    {
        // Mark all "vector" mappings available for export
        Mapping->Available = Mapping->GetInternalDataType()->IsSameFormat(VectorFormat);
        Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping);
    }   

    // Scan the InternalClipboard document tree to determine which internal formats are available
    Node *pRoot = InternalClipboard::GetInsertionLayer();
    Node *pNode = pRoot->FindFirstDepthFirst();
    BOOL AllDone = FALSE;   // Becomes TRUE when there is no need to continue the scan

    while (pNode != NULL && !AllDone)
    {
        AllDone = TRUE;
        Mapping = (ClipboardMapping *) Mappings.GetHead();
        while (Mapping != NULL)
        {
            if (!Mapping->Available && Mapping->Type != CLIPMAP_IMPORTONLY)
            {
                // Check if this mapping can be used on this node to provide another
                // output data format that was previously unavailable
                Mapping->Available = pNode->SupportsClipboardFormat(Mapping->GetInternalDataType());
                if (!Mapping->Available) AllDone = FALSE;
            }

            Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping);
        }   
        
        pNode = pNode->FindNextDepthFirst(pRoot);
    }


#if (_OLE_VER >= 0x200)

    // Put the contents of the internal clipboard on the OLE clipboard, using the
    // associated CCamSrvrItem to do the hard stuff.
    
    m_fIgnoreChange = TRUE;
    
    // Only put stuff on the external clipboard if we are allowed to ...
    if (m_fUpdateSystemClipboard)
    {
        // If you have been using something like GIF construction set then this may
        // lock the clipboard. At this point, an exception will be thrown. This is an unknown
        // exception as far a Camelot is concerned and so is very bad. We should really stop
        // the main expection handler getting its claws on it and not knowing what to do with it.
        // Our exception handler can just pretend that nothing really happened.
        // Just mention to the user about the problem.
        TRY
        {
            // Get the oil form of the document and the associated server item
            CCamDoc * pCamDoc = InternalClipboard::Instance()->GetOilDoc();
            CCamSrvrItem* pServer = NULL;
            if (pCamDoc != NULL)
                pServer = pCamDoc->GetEmbeddedItem();
            // If that went well then ask it to copy the data to the clipboard
            if (pServer != NULL)
                pServer->CopyToClipboard();
        }
        CATCH(COleException, e)      // Handle all ole exceptions
        {
            // "e" contains information about the exception.
            TRACEUSER( "Neville", _T("ExternalClipboard::CopyCompleted exception handler\n"));

            // Do nothing special, as all this means is that the external clipboard
            // has had a problem. Just report a generic error to the user so that they
            // know that something is not working correctly.
            InformError(_R(IDE_CLIPBOARDCOPYPROBLEM)); // There was a problem copying to the Windows clipboard
        }
        END_CATCH
    }
    
    m_fIgnoreChange = FALSE;
    return TRUE;

#else

    CWnd *Parent = GetOwnerWindow();
    if (Parent->OpenClipboard() != NULL)
    {
        ::EmptyClipboard();                     // Clear the windows clipboard

        // Add all available export formats onto the clipboard
        Mapping = (ClipboardMapping *) Mappings.GetHead();
        while (Mapping != NULL)
        {

#if FALSE
#if _DEBUG
TRACEUSER( "Jason", _T("Mapping %s available (for ICF %ld)\n"),
  Mapping->Available?"is":"NOT", (INT32)(Mapping->GetInternalDataType()->GetFormatID()));
#endif
#endif

            if (Mapping->Available && Mapping->Type != CLIPMAP_IMPORTONLY)
                ::SetClipboardData(Mapping->ExternalDataType, NULL);

            Mapping = (ClipboardMapping *) Mappings.GetNext(Mapping);
        }   

        ::CloseClipboard();
    }
    // else another application/window has the clipboard open!

    return(TRUE);

#endif
}


#if (_OLE_VER >= 0x200)

/********************************************************************************************
>   void ExternalClipboard::DelayRenderData(CCamDataSource* pDataSource)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    17/10/96
    Inputs:     pDataSource     ---     the data source to render into
    Purpose:    Delay-renders the old-style Camelot clipboard formats into the given
                data source.
    SeeAlso:    CCamSrvrItem::OnRenderGlobalData; CCamDataSource
********************************************************************************************/

void ExternalClipboard::DelayRenderData(CCamDataSource* pDataSource)
{
    // JustinF says: bodge alert!  We don't want to export *any* proprietary formats, such
    // as the native format or OLE embeddables, when this bodgey flag is FALSE.  This finds
    // out the flag's value without changing it.
    BOOL fExportNative = CCamSrvrItem::RenderProprietaryFormats(TRUE);
    CCamSrvrItem::RenderProprietaryFormats(fExportNative);

    // Tell the data source that we can render some static formats.
    for (ClipboardMapping* pMap = (ClipboardMapping*) pInstance->Mappings.GetHead();
         pMap != 0;
         pMap = (ClipboardMapping*) pInstance->Mappings.GetNext(pMap))
    {
        // JustinF says: bodge alert!  We mustn't render CMX formats on shut-down because they
        // crash if the clipboard doc contains bitmaps or fractals.
        if (pMap->IS_KIND_OF(CMXClipMap) && (fBodgeNoCMX || fNoCMXDataExport))
        {
            TRACEUSER( "JustinF", _T("Skipping CMX mapping at 0x%p\n"), (LPVOID) pMap);
            continue;
        }

        // JustinF says: bodge alert!  Don't render the native format if this flag is FALSE.
        if (pMap->IS_KIND_OF(NativeClipMap) && !fExportNative)
        {
            TRACEUSER( "JustinF", _T("Skipping native mapping at 0x%p\n"), (LPVOID) pMap);
            continue;
        }       

        // Can we export this format?
        if (pMap->Available && pMap->Type != CLIPMAP_IMPORTONLY)
        {
            // Yes, tell the data source to make this format available.
            pDataSource->DelayRenderData(pMap->ExternalDataType);
/*          TRACEUSER( "JustinF", _T("\t- added format 0x%X to COleDataSource at 0x%p\n"),
                        (UINT32) pMap->ExternalDataType, (LPVOID) pSource);
*/      }
    }
}

#endif



#if (_OLE_VER >= 0x200)

/********************************************************************************************
>   static CLIPFORMAT ExternalClipboard::GetBestPasteFormat(COleDataObject* pDataObject)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    11/10/96
    Inputs:     pDataObject     ---     the data object containing the data to be queried
    Returns:    The data format within the data object that is the most suitable for
                pasting, or zero if there isn't one.
    Purpose:    Works out what we would paste from the given data object.
    SeeAlso:    ExternalClipboard::PrepareForOlePaste
********************************************************************************************/

CLIPFORMAT ExternalClipboard::GetBestPasteFormat(COleDataObject* pDataObject)
{
    FORMATETC fmt;
    pDataObject->BeginEnumFormats();
    while (pDataObject->GetNextFormat(&fmt))
    {
        // Ask all the clipboard mappings if they can import this format.
        ClipboardMapping* pMap = (ClipboardMapping*) pInstance->Mappings.GetHead();
        while (pMap)
        {
            // Can this mapping import this type of data?
            if (pMap->Type != CLIPMAP_EXPORTONLY && pMap->ExternalDataType == fmt.cfFormat)
            {
                // Yes it can.  Check for implicit conversions between ANSI and Unicode text.
                if (pMap->ExternalDataType == pMap->RealExternalType ||
                    pDataObject->IsDataAvailable(pMap->RealExternalType))
                {
                    // We found a format.  Return it.
                    return pMap->RealExternalType;
                }
            }

            // Consider the next mapping.
            pMap = (ClipboardMapping*) pInstance->Mappings.GetNext(pMap);
        }
    }

    // No format is suitable, so sorry.
    return 0;
}



/********************************************************************************************
>   BOOL ExternalClipboard::PrepareForOlePaste(COleDataObject* pDataObject)

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    10/10/96