idraganddrop.h

Go to the documentation of this file.

/* 
 *    iDragAndDrop.h - SDK API to desktop drag-and-drop services in MAX
 *
 *       Copyright (c) Autodesk, Inc, 2000.  John Wainwright.
 *
 */

#pragma once

#include "maxheap.h"
#include "iFnPub.h"
#include "iMacroScript.h"
#include "GetCOREInterface.h"

// forward declarations
class IDragAndDropMgr; 
class DragAndDropHandler;
class DropType;

// Core interface to the OLE drag-and-drop manager

// utility Tab<> specialization to hold URL strings
class URLTab : public Tab<MCHAR*>
{
public:
   BOOL downloaded;  // set to indicate URL module has been downloaded & names now reflect local copies

   URLTab()  { downloaded = FALSE; }
   ~URLTab() { Clear(); }
   CoreExport URLTab& operator=(const Tab<MCHAR*>& tb);
   CoreExport URLTab& operator=(const URLTab& tb);
   CoreExport void Add(MCHAR* url);
   CoreExport void Change(int i, MCHAR* url);
   CoreExport void Clear();
};

// drag and drop Manager interface ID
#define DND_MGR_INTERFACE   Interface_ID(0x51163ddb, 0x2a4f1619)

inline IDragAndDropMgr* GetDragAndDropMgr() { return (IDragAndDropMgr*)GetCOREInterface(DND_MGR_INTERFACE); }


enum
{
    dndmgr_enableDandD, 
    dndmgr_globalEnableDnD, 
    dndmgr_isEnabled, 
    dndmgr_dropPackage, 
    dndmgr_downloadDirectory, 
    dndmgr_downloadPackage,
    dndmgr_downloadUrlToDisk,
    dndmgr_importContextNode,
}; 

class IDragAndDropMgr : public FPStaticInterface 
{
public:
    virtual void    EnableDandD(BOOL flag)=0;

    virtual BOOL   IsEnabled()=0;


    virtual BOOL   EnableDandD(HWND hwnd, BOOL flag, DragAndDropHandler* handler = NULL)=0;

    virtual BOOL   DropPackage(HWND hwnd, POINT& point, URLTab& module)=0; 
    
    virtual BOOL   DownloadPackage(URLTab& module, MCHAR* directory, HWND hwnd = NULL, bool showProgress = false)=0; 

    virtual MCHAR* GetDownloadDirectory()=0;
    
    virtual int    NumHandlers(HWND hwnd)=0;        // iterate handlers for given window
    
    virtual DragAndDropHandler* GetHandler(HWND hwnd, int i)=0;

    virtual bool   DownloadUrlToDisk(HWND hwnd, MCHAR* url, MCHAR* fileName, DWORD dlgflags=0)=0;

    virtual INode* ImportContextNode()=0;
}; 

#pragma warning(push)
#pragma warning(disable:4100)

/*  Instances of these classes can be registered with the drag and drop manager 
    when enabling a window for drag and drop activity. Virtual methods on these
    instances called to handle the various drag and drop events. Use 
    \code 
    IDragAndDropMgr::EnableDnD(hwnd, flag, &myHandler)
    \endcode 
    to enable drag and drop in a window and specify the DragAndDropHandler instance
    that will handle drag and drop events for that window. Note that one 
    DragAndDropHandler instance can potentially be shared among many HWND windows. 
    Further, a parent window can be enabled for drag and drop and this effectively
    causes all child windows to be enabled and handled by the given handler (unless 
    overriden by an explicit <b>EnableDnD</b> with a different handler on a child).\n\n
    
    There are actually two sets of drag and drop event handler virtual methods in the base
    class, a low-level set that equates to the methods on the OLE IDropTarget
    interface that take raw IDataObject drop data and a high-level set that take
    fully-parsed DropType drop data. The low-level methods have default implementations
    provided that do this parsing and call the corresponding high-level method, 
    so in most cases you only need to provide implementations for the high-level methods. 
    You would provide implementations of the low-level methods if custom parsing of the 
    IDataObject is required.
    \sa  Class IDragAndDropMgr, Class DropType
*/
class DragAndDropHandler : public InterfaceServer
{
public:
    DragAndDropHandler() 
        : current_droptype(NULL)
    {
        if (dndMgr == NULL)
            dndMgr = GetDragAndDropMgr();
    }

    CoreExport virtual HRESULT DragEnter(HWND window, IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect);

    CoreExport virtual HRESULT Drop(HWND window, IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect);
    CoreExport virtual HRESULT DragOver(HWND window, DWORD grfKeyState, POINTL pt, DWORD * pdwEffect);
    CoreExport virtual HRESULT DragLeave(HWND window) { return E_FAIL; }

    // high-level drag-and-drop operations, the dataObject has been decoded and the drop-type parsed
    virtual HRESULT DragEnter(HWND window, DropType* type, DWORD grfKeyState, POINT& pt, DWORD* pdwEffect) { return E_FAIL; }
    virtual HRESULT Drop(HWND window, DropType* type, DWORD grfKeyState, POINT& pt, DWORD* pdwEffect) { return E_FAIL; }
    virtual HRESULT DragOver(HWND window, DWORD grfKeyState, POINT& pt, DWORD * pdwEffect) { return E_FAIL; }

    virtual void Acquire() { }; 

    virtual void Release() { }; 

protected:
    DropType*  current_droptype;
    CoreExport static IDragAndDropMgr* dndMgr; 
};

// class DropClipFormat
// base class for the various supported clipboard formats.
// Distinguished instance of each subclass represents a
// particular IDataObject clip format or module of related formats
// that can be accepted by MAX's various windows.  Prime responsibility
// of each is to recognize its presence in a dropped (pasted?) IDataObject
// and to parse the data object into one of the acceptable DropTypes.
// 
class DropClipFormat : public InterfaceServer
{
protected:
   CoreExport static Tab<DropClipFormat*> clipFmts;  // table of supported clip formats
public:
   // each DropClimFormat instance created is kept in the clipFmts table
   DropClipFormat() { DropClipFormat* cf = this; clipFmts.Append(1, &cf); }

   // used primarily by the DragEnter() handler to find the DropClipFormat
   // corresponding to the currently dropping IDataObject
   CoreExport static DropClipFormat* FindClipFormat(IDataObject* pDataObject);

   // specialized by individual clipformats to detect its format(s) present in 
   // the given IDataObject
   virtual bool CheckClipFormat(IDataObject* pDataObject) { return false; }
   
   // specialized by individual clip format types to parse IDataObject
   // into appropriate DropType
   virtual DropType* ParseDataObject(IDataObject* pDataObject) { return NULL; }
};

// built-in clip formats

// iDrop module URL
class IDropPackageClipFmt : public DropClipFormat
{
public:
   bool CheckClipFormat(IDataObject* pDataObject);
   DropType* ParseDataObject(IDataObject* pDataObject);
};

// VIZable file URL
class VIZableClipFmt : public DropClipFormat
{
public:
   bool CheckClipFormat(IDataObject* pDataObject);
   DropType* ParseDataObject(IDataObject* pDataObject);
};

// internal dropScript
class DropScriptClipFmt : public DropClipFormat
{
public:
   bool CheckClipFormat(IDataObject* pDataObject);
   DropType* ParseDataObject(IDataObject* pDataObject);
};


// class DropType
// base class for dropable content types
// Distinguished instances of subclasses represent different types of drop content, 
// such as a file distinguished by file suffix or a scene object
// The active DropClipFormat parses dropped IDataObject into one
// of these dropped types, filling its data members with appropriate
// guff from the data object.
class DropType : public MaxHeapOperators, public IDropSource, public IDataObject
{
protected:
   CoreExport static IDragAndDropMgr* dndMgr;   // cached pointer to drag and drop manager
   CoreExport static bool dragging;       // drop source state...
   CoreExport static POINT startPt;
   CoreExport static WPARAM startKeyState;
   CoreExport static HWND startWnd;
   CoreExport static bool loaded;            // flags if curent module already downloaded

public:
   // currently dropping data object
   CoreExport static IDataObject* current_dataobject;

   DropType() { if (dndMgr == NULL) dndMgr = GetDragAndDropMgr(); }
     CoreExport virtual ~DropType();
   
   // clears current parsed drop data
   static void Init() { current_dataobject = NULL; loaded = false; }

   // DropType code access, provides an integer code specific
   // to the droptype
   virtual int TypeCode()=0;
   virtual bool IsDropType(int code) { return code == TypeCode(); }
   
   // ------- drop target methods & members --------------

   // perform any droptype-specific load prior to using the data, eg 
   // downloading URLs to local machine
   virtual bool Load(bool showProgress = true) { return true; }

   // dropeffect currently supported by accepted dropping type
   virtual DWORD DropEffect() { return DROPEFFECT_MOVE; }

   // -------- drop source methods and members -----------------

   // from IUnknown
   CoreExport STDMETHODIMP QueryInterface(REFIID iid, void** ppvObject);
   CoreExport STDMETHODIMP_(ULONG) AddRef(void)  { return 1; }
   CoreExport STDMETHODIMP_(ULONG) Release(void) { return 1; }
   
   // from IDataObject
   CoreExport STDMETHODIMP GetData(FORMATETC* pFormatetc, STGMEDIUM* pmedium) { return E_UNEXPECTED; }
   CoreExport STDMETHODIMP GetDataHere(FORMATETC* pFormatetc, STGMEDIUM* pmedium) { return E_UNEXPECTED; }
   CoreExport STDMETHODIMP QueryGetData(FORMATETC* pFormatetc) { return E_UNEXPECTED; }
   CoreExport STDMETHODIMP GetCanonicalFormatEtc(FORMATETC* pFormatetcIn, FORMATETC* pFormatetcOut);
   CoreExport STDMETHODIMP SetData(FORMATETC* pFormatetc, STGMEDIUM* pmedium, BOOL fRelease);
   CoreExport STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC** ppenumFormatetc);
   CoreExport STDMETHODIMP DAdvise(FORMATETC* pFormatetc, DWORD advf, IAdviseSink* pAdvSink, DWORD* pdwConnection);
   CoreExport STDMETHODIMP DUnadvise(DWORD dwConnection);
   CoreExport STDMETHODIMP EnumDAdvise(IEnumSTATDATA** ppenumAdvise);

   // from IDropSource
   CoreExport STDMETHODIMP QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState);
   CoreExport STDMETHODIMP GiveFeedback(DWORD dwEffect) { return DRAGDROP_S_USEDEFAULTCURSORS; }

   // drop start checking methods 
   CoreExport virtual void InitDragDropCheck(LPARAM mousePt, WPARAM keyState, HWND hwnd);
   CoreExport virtual void CancelDragDropCheck();
   CoreExport virtual bool DragDropCheck(LPARAM mousePt, WPARAM keyState, DWORD allowedEffects);
   CoreExport virtual bool ReadyToDrag(){ return false; }
};

#define FILE_DROPTYPE            0x00000001     //!< A module of file names or URL's.
#define DROPSCRIPT_DROPTYPE         0x00000002  //!< A dropScript.
#define SCENEFILE_DROPTYPE       0x00000003     //!< The *.max scene file.
#define IMAGEFILE_DROPTYPE       0x00000004     //!< The image files (.bmp, .tga, etc.).
#define IMPORTFILE_DROPTYPE         0x00000005  //!< The importable files (.3ds, .dxf, etc.).
#define SCRIPTFILE_DROPTYPE         0x00000006  //!< The script files (.ms, .mse, .mcr).
#define DROPSCRIPTFILE_DROPTYPE     0x00000007  //!< The drop script files (.ds, .dse).
#define BITMAP_DROPTYPE          0x00000008     //!< The bitmap type.
#define MSZIPFILE_DROPTYPE       0x00000009     //!< The script zip module files (.mzp).
#define PATHFILE_DROPTYPE        0x0000000a     //!< The path type.


class FileDropType : public DropType
{
protected:
   CoreExport static Tab<FileDropType*> fileDropTypes;  // table of supported file drop types
    CoreExport static MSTR download_directory;            // cache for default download directory

   // URL download utilities
   CoreExport static bool CheckForCachedFile(MCHAR* filename);
   CoreExport static bool IsInternetCachedFile(const MCHAR* filename);
   CoreExport static bool  AppendUrlFilename(const MCHAR* szUrl, MCHAR* szPathname, bool& is_URL);

public:
   CoreExport static URLTab current_package;

   FileDropType() { FileDropType* dt = this; fileDropTypes.Append(1, &dt); }
   static void Init() { current_package.Clear(); DropType::Init(); }

   // From DropType
   int TypeCode() { return FILE_DROPTYPE; }
   bool IsDropType(int code) { return code == TypeCode() || code == FILE_DROPTYPE; }

   // ------- drop target methods & members --------------

   CoreExport bool Load(bool showProgress = true);
   
   // global finder of assoicated droptype given filename (or pDataObject)
   CoreExport static FileDropType* FindDropType(MCHAR* filename, IDataObject* pDataObject = NULL);

   // specialize this for each droppable file type to provide type detector
   virtual bool     CheckDropType(MCHAR* filename) { return false; } 

   // module download utilities
   CoreExport static bool   DownloadPackage(URLTab& module, MCHAR* szDirectory, HWND hwnd = NULL, bool showProgress = true);
   CoreExport static MCHAR* GetDownloadDirectory();
   CoreExport static bool DownloadUrlToDisk(HWND hwnd, MCHAR* szUrl, MCHAR* szPathname, DWORD flags=0);

   // -------- drop source methods and members -----------------

   // from IDataObject
   STDMETHODIMP GetData(FORMATETC* pFormatetc, STGMEDIUM* pmedium) { return E_UNEXPECTED; }
   STDMETHODIMP GetDataHere(FORMATETC* pFormatetc, STGMEDIUM* pmedium) { return E_UNEXPECTED; }
   STDMETHODIMP QueryGetData(FORMATETC* pFormatetc) { return E_UNEXPECTED; }

};

#pragma warning(pop)


// class DropScriptDropType
//   intermediate base class for drop content in the form of a 
//   dropScript 
class DropScriptDropType : public DropType
{
public:
   CoreExport static MacroEntry* current_dropscript;

   // From DropType
   int TypeCode() { return DROPSCRIPT_DROPTYPE; }
   bool IsDropType(int code) { return code == TypeCode() || code == DROPSCRIPT_DROPTYPE; }
   DWORD DropEffect() { return DROPEFFECT_MOVE; }
   
   // ------- drop target methods & members --------------

   // compile & run support methods
   CoreExport BOOL CompileDropScript(MCHAR* filename);
   CoreExport BOOL RunDropScriptDragEnter(FPParams* params);
   CoreExport BOOL RunDropScriptDragOver(FPParams* params);
   CoreExport BOOL RunDropScriptDrop(FPParams* params);

   // -------- drop source methods and members -----------------

   // from IDataObject
   CoreExport STDMETHODIMP GetData(FORMATETC* pFormatetc, STGMEDIUM* pmedium);
   CoreExport STDMETHODIMP GetDataHere(FORMATETC* pFormatetc, STGMEDIUM* pmedium);
   CoreExport STDMETHODIMP QueryGetData(FORMATETC* pFormatetc);

   // drop start checking methods 
   void InitDragDropCheck(MacroEntry* dropscript, LPARAM mousePt, WPARAM keyState, HWND hwnd)
   {
      DropType::InitDragDropCheck(mousePt, keyState, hwnd);
      current_dropscript = dropscript;
   }
   bool ReadyToDrag() { return current_dropscript != NULL; }
};

// the built-in type classes

// first the file types, usually sourced by the iDrop active-X control on a 
// web page or by draggin files from the Windows desktop/explorer...

// .max scene file
class SceneFileDropType : public FileDropType
{
public:
   // From DropType
   int TypeCode() { return SCENEFILE_DROPTYPE; }
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// image files (.bmp, .tga, etc.)
class ImageFileDropType : public FileDropType
{
public:
   // From DropType
   int TypeCode() { return IMAGEFILE_DROPTYPE; }
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// importable files (.3ds, .dxf, etc.)
class ImportFileDropType : public FileDropType
{
public:
   // From DropType
   int TypeCode() { return IMPORTFILE_DROPTYPE; }
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// script files (.ms, .mse, .mcr)
class ScriptFileDropType : public FileDropType
{
public:
   // From DropType
   int TypeCode() { return SCRIPTFILE_DROPTYPE; }
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// drop script files (.ds, .dse)
class DropScriptFileDropType : public FileDropType, public DropScriptDropType
{
public:
   // From DropType
   int TypeCode() { return DROPSCRIPTFILE_DROPTYPE; }
   bool Load(bool showProgress = true);
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// script zip module files (.mzp)
class MSZipPackageFileDropType : public FileDropType, public DropScriptDropType
{
public:
    MSTR extract_dir;
    MSTR drop_file; 
   DropType* drop_file_type;   // if drop_file is not a dropScript

   // From DropType
   int TypeCode() { return MSZIPFILE_DROPTYPE; }
   bool Load(bool showProgress = true);
   
   // From FileDropType
   CoreExport bool CheckDropType(MCHAR* filename);
};

// MAX-internal types

// bitmap
class BitmapDropType : public DropType
{
public:
   // From DropType
   int TypeCode() { return BITMAP_DROPTYPE; }
   
};


class PathConfigDropType : public FileDropType
{
public:

   int TypeCode() { return PATHFILE_DROPTYPE; }


   CoreExport bool CheckDropType(MCHAR* filename);
};

// built-in type instances
extern CoreExport SceneFileDropType sceneFileDropType; 
extern CoreExport ImageFileDropType imageFileDropType; 
extern CoreExport ScriptFileDropType scriptFileDropType; 
extern CoreExport DropScriptFileDropType dropScriptFileDropType; 
extern CoreExport DropScriptDropType dropScriptDropType; 
extern CoreExport BitmapDropType bitmapDropType; 
extern CoreExport MSZipPackageFileDropType msZipPackageFileDropType; 
extern CoreExport PathConfigDropType pathConfigDropType;