You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2538 lines
72 KiB
2538 lines
72 KiB
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996.
|
|
//
|
|
// File: drag.cpp
|
|
//
|
|
// Contents: Api's for doing drag'n'drop
|
|
//
|
|
// Classes: CPoint
|
|
// CDragOperation
|
|
// CDropTarget
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-94 alexgo converted to PrivDragDrop rpc
|
|
// for Drag Drop protocol
|
|
// 20-Oct-94 alexgo added Win3.1 style drag drop
|
|
// for Chicago/NT shell
|
|
// 30-Sep-94 ricksa Drag/Drop optimization.
|
|
// 18-Jul-94 ricksa made cursors work in shared WOW
|
|
// 21-Apr-94 ricksa made drag/drop handle WM_CANCELMODE
|
|
// 04-Apr-94 ricksa rewrote DoDragDrop loop
|
|
// 11-Jan-94 alexgo added VDATEHEAP to every function
|
|
// 29-Dec-93 alexgo converted to RPC alogirithm for
|
|
// getting IDropTarget, etc.
|
|
// 06-Dec-93 alexgo commented, formatted
|
|
// 93/94 Johann Posch (JohannP) created Drag/Drop for Ole 16 bit
|
|
//
|
|
// Notes:
|
|
//
|
|
// RPC Drag Drop algorithm:
|
|
//
|
|
// During a drag drop operation, the user is moving the mouse around
|
|
// the screen, passing over many windows. For each window the mouse
|
|
// is over, we need to determine if the window is a drop target.
|
|
// If it is, then we remote the IDropTarget interface to the DropSource
|
|
// so that the correct visual feedbacks can be given.
|
|
//
|
|
// To accomplish this, RegisterDragDrop adds two properties to the
|
|
// drop target window: a public property, EndPoint ID (provided to
|
|
// us by compobj), and a private property (available only to the calling
|
|
// process), the IDropTarget pointer.
|
|
//
|
|
// During the DoDragDrop loop, we ask compobj to test each window for
|
|
// the EndpointID property. If it is there, compobj (via
|
|
// GetInterfaceFromWindowProp), then we will rpc to the drop target
|
|
// process, get the IDropTarget pointer and marshal it back to the
|
|
// drop source process. We also install a custom message filter to
|
|
// ensure that messages (particularly mouse move messages) are handled
|
|
// correctly.
|
|
//
|
|
// RevokeDragDrop simply removes the above mentioned properties from
|
|
// the window handle.
|
|
//
|
|
// Because in Win32, you can always switch windows and mouse capture
|
|
// depends on having the mouse button down, drag/drop processing
|
|
// is changed slightly. Whenever, the user does an operation that
|
|
// would switch windows, the clipboard window that we use for capture
|
|
// will get a WM_CANCELMODE. It will notify the drag operation and
|
|
// the drag operation will proceed as if the user aborted the operation.
|
|
//
|
|
//
|
|
// Win 3.1 DragDrop algorithm:
|
|
//
|
|
// Win3.1 apps can register a window as a drop target via DragAcceptFiles.
|
|
// This API sets the WS_EX_ACCEPTFILES bit in the window style.
|
|
//
|
|
// In Win3.1, these apps would get a WM_DROPFILES message when
|
|
// files where dropped on them. An hglobal with the filenames is
|
|
// sent in the wparam of WM_DROPFILES.
|
|
//
|
|
// In Chicago and NT3.5, CF_HDROP is a new clipboard format that is
|
|
// identical to the data sent in WM_DROPFILES. If we see this format
|
|
// available in a data object passed to DoDragDrop, then we enter
|
|
// into our Win31 compatibility mode (which affects finding a drop
|
|
// target).
|
|
//
|
|
// When finding a drop target for a given window, we check to
|
|
// see if a window in the hierarchy is registered as a Win31 drop
|
|
// target. If so, then we create a wrapper drop target. This wrapper
|
|
// drop target will forward calls to the real drop target (if available).
|
|
//
|
|
// With Win3.1 drag drop, we can do a COPY. If the OLE target indicates
|
|
// that no OLE drop can be performed (by returning DROPEFFECT_NONE),
|
|
// then we substitute in DROPEFFECT_COPY.
|
|
//
|
|
// On Drop, if the OLE target chooses not to accept the drop, then
|
|
// we will post the window a WM_DROPFILES message with the hglobal
|
|
// obtained from IDataObject::GetData(CF_HDROP).
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <le2int.h>
|
|
#pragma SEG(drag)
|
|
|
|
#include <getif.hxx>
|
|
#include <dragopt.h>
|
|
#include <resource.h>
|
|
#include "enumgen.h"
|
|
#include "clipbrd.h"
|
|
#include "drag.h"
|
|
|
|
|
|
NAME_SEG(Drag)
|
|
ASSERTDATA
|
|
|
|
ATOM g_aEndPointAtom;
|
|
|
|
// DROPFILES is the structure of data contained in the CF_HDROP format.
|
|
// However, this is private to the shell, so it is not declared in any
|
|
// header files.
|
|
|
|
typedef struct _DROPFILES {
|
|
DWORD pFiles; // offset of file list
|
|
POINTL pt; // drop point (client coords)
|
|
DWORD fNC; // is it on NonClient area
|
|
// and pt is in screen coords
|
|
DWORD fWide; // WIDE character switch
|
|
} DROPFILES, FAR * LPDROPFILES;
|
|
|
|
|
|
#define WM_NCMOUSEFIRST 0x00A0
|
|
#define WM_NCMOUSELAST 0x00A9
|
|
|
|
|
|
// From ido.cpp to create shared memory formats
|
|
HANDLE CreateSharedDragFormats(IDataObject *pIDataObject);
|
|
|
|
|
|
#define VK_ALT VK_MENU
|
|
|
|
static const struct {
|
|
int keyCode;
|
|
WPARAM keyFlag;
|
|
} vKeyMap [] = {
|
|
{ VK_LBUTTON, MK_LBUTTON },
|
|
{ VK_RBUTTON, MK_RBUTTON },
|
|
{ VK_MBUTTON, MK_MBUTTON },
|
|
{ VK_ALT , MK_ALT },
|
|
{ VK_SHIFT , MK_SHIFT },
|
|
{ VK_CONTROL, MK_CONTROL }
|
|
};
|
|
|
|
// This is the default cursor object for 32 bit apps. Only one such object
|
|
// is needed for 32 bit apps. 16 bit apps need one per shared WOW application
|
|
// that is running.
|
|
CDragDefaultCursors *cddcDefault32 = NULL;
|
|
|
|
extern ATOM g_aDropTarget;
|
|
extern ATOM g_aDropTargetMarshalHwnd;
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: DragDropProcessUninitialize
|
|
//
|
|
// Synopsis: Does any Unitialization necessary at OleUninitialize time.
|
|
// for the last Unitialize for the Process
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Algorithm:
|
|
|
|
// History: dd-mmm-yy Author Comment
|
|
// 18-Jul-94 rogerg Created
|
|
//
|
|
// Note: We need a per thread default cursor object in WOW because
|
|
// of the clean up that WOW does. For 32 bit apps, we just use
|
|
// one for the entire process.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
void DragDropProcessUninitialize(void)
|
|
{
|
|
|
|
if (NULL != cddcDefault32)
|
|
{
|
|
delete cddcDefault32;
|
|
cddcDefault32 = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDragDefaultCursors::GetDefaultCursorObject, static
|
|
//
|
|
// Synopsis: Get appropriate pointer to default cursor object
|
|
//
|
|
// Returns: NULL - error occurred
|
|
// ~NULL - pointer to appropriate default cursor table
|
|
//
|
|
// Algorithm: If we are in a 32 bit app, just get a pointer to the
|
|
// single cursor table. In 16 bit, get the per thread cursor
|
|
// table. If there is none, then allocate and initialize it.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 18-Jul-94 Ricksa Created
|
|
//
|
|
// Note: We need a per thread default cursor object in WOW because
|
|
// of the clean up that WOW does. For 32 bit apps, we just use
|
|
// one for the entire process.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CDragDefaultCursors *CDragDefaultCursors::GetDefaultCursorObject(void)
|
|
{
|
|
if (!IsWOWThread())
|
|
{
|
|
// If we aren't in WOW, we can use the single common default cursor
|
|
// object. We make sure that it is initialized before we use it.
|
|
|
|
if (NULL == cddcDefault32)
|
|
{
|
|
cddcDefault32 = new CDragDefaultCursors;
|
|
if (cddcDefault32)
|
|
{
|
|
if (!cddcDefault32->Init())
|
|
{
|
|
delete cddcDefault32;
|
|
cddcDefault32 = NULL;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return cddcDefault32;
|
|
}
|
|
|
|
COleTls tls;
|
|
|
|
// We are in WOW. Get the cursor object if it has already been allocated
|
|
CDragDefaultCursors *pccdc16 = (CDragDefaultCursors *) tls->pDragCursors;
|
|
|
|
if (pccdc16 == NULL)
|
|
{
|
|
// No cursor table so allocate it -- Please note that we take advantage
|
|
// of the fact that this object has only the default constructor by
|
|
// simply allocating it rather than "newing" it. The point is that
|
|
// we need to free the memory at thread release time and this happens
|
|
// in code that doesn't know about the the object.
|
|
pccdc16 = (CDragDefaultCursors *)
|
|
PrivMemAlloc(sizeof(CDragDefaultCursors));
|
|
|
|
if (pccdc16 != NULL)
|
|
{
|
|
// Successfully allocated so initialize it
|
|
if (!pccdc16->Init())
|
|
{
|
|
PrivMemFree(pccdc16);
|
|
return NULL;
|
|
}
|
|
|
|
tls->pDragCursors = pccdc16;
|
|
}
|
|
}
|
|
|
|
return pccdc16;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragDefaultCursors::Init
|
|
//
|
|
// Synopsis: Initialize object by loading all the default cursors.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 19-Apr-94 Ricksa Created
|
|
//
|
|
// Note: We continue the Win16 practice of ignoring possible failure
|
|
// cases when loading the cursors although we do put in a
|
|
// debug verification that they all loaded.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL CDragDefaultCursors::Init(void)
|
|
{
|
|
// Make sure table is set to NULLs.
|
|
memset(&ahcursorDefaults[0][0], 0, sizeof(ahcursorDefaults));
|
|
|
|
// Load cursors for operation
|
|
if ( !(ahcursorDefaults[NO_SCROLL] [NO_DROP]
|
|
= LoadCursor (g_hmodOLE2, MAKEINTRESOURCE(CURNONE))) )
|
|
return FALSE;
|
|
|
|
if (!(ahcursorDefaults[NO_SCROLL] [MOVE_DROP] =
|
|
LoadCursor (g_hmodOLE2, MAKEINTRESOURCE(CURMOVE))) )
|
|
return FALSE;
|
|
|
|
if (!(ahcursorDefaults[NO_SCROLL] [COPY_DROP] =
|
|
LoadCursor (g_hmodOLE2, MAKEINTRESOURCE(CURCOPY))) )
|
|
return FALSE;
|
|
|
|
if (!(ahcursorDefaults[NO_SCROLL] [LINK_DROP] =
|
|
LoadCursor(g_hmodOLE2, MAKEINTRESOURCE(CURLINK))) )
|
|
return FALSE;
|
|
|
|
|
|
// Load cursors for operation
|
|
ahcursorDefaults[SCROLL] [NO_DROP] =
|
|
ahcursorDefaults[NO_SCROLL] [NO_DROP];
|
|
|
|
ahcursorDefaults[SCROLL] [MOVE_DROP] =
|
|
ahcursorDefaults[NO_SCROLL] [MOVE_DROP];
|
|
|
|
ahcursorDefaults[SCROLL] [COPY_DROP] =
|
|
ahcursorDefaults[NO_SCROLL] [COPY_DROP];
|
|
|
|
ahcursorDefaults[SCROLL] [LINK_DROP] =
|
|
ahcursorDefaults[NO_SCROLL] [LINK_DROP];
|
|
|
|
|
|
#if DBG == 1
|
|
// For debug, verify that cursors were loaded correctly
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
AssertSz((ahcursorDefaults[i] [j] != NULL),
|
|
"Drag/Drop cursor initialization failed!");
|
|
}
|
|
}
|
|
#endif // DBG == 1
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragDefaultCursors::SetCursor
|
|
//
|
|
// Synopsis: Set cursor to appropriate value
|
|
//
|
|
// Algorithm: We use the input effect to calculate the appropriate offset
|
|
// into the table for the cursor to use.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 19-Apr-94 Ricksa Created
|
|
//
|
|
// Note: We use the table approach so we to make consistent behavior
|
|
// between scroll and non-scroll cursors.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void CDragDefaultCursors::SetCursor(DWORD dwEffect)
|
|
{
|
|
// Get Scroll index
|
|
int iScroll = (dwEffect & DROPEFFECT_SCROLL) ? SCROLL : NO_SCROLL;
|
|
|
|
int iCursorType = NO_DROP;
|
|
|
|
if (dwEffect & DROPEFFECT_LINK)
|
|
{
|
|
iCursorType = LINK_DROP;
|
|
}
|
|
else if (dwEffect & DROPEFFECT_COPY)
|
|
{
|
|
iCursorType = COPY_DROP;
|
|
}
|
|
else if (dwEffect & DROPEFFECT_MOVE)
|
|
{
|
|
iCursorType = MOVE_DROP;
|
|
}
|
|
|
|
::SetCursor(ahcursorDefaults[iScroll] [iCursorType]);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Drag/Drop Operation Statics
|
|
//
|
|
LONG CDragOperation::s_wScrollInt = -1;
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: GetControlKeysState
|
|
//
|
|
// Synopsis: queries the current status of the control keys
|
|
//
|
|
// Arguments: [fAll] -- if true, the just query the keys, not mouse
|
|
// buttons too
|
|
//
|
|
// Returns: the MK flags for each key pressed
|
|
//
|
|
// Algorithm: Get key state either for all keys and mouse buttons in
|
|
// the vKeyMap table or simply for the key portion of the table
|
|
// and translate it to the WPARAM form as returned in mouse
|
|
// messages.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 06-Dec-93 alexgo 32bit port
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
WORD GetControlKeysState(BOOL fAll)
|
|
{
|
|
WORD grfKeyState = 0;
|
|
|
|
int i = (fAll) ? 0 : 3;
|
|
|
|
for (; i < sizeof(vKeyMap) / sizeof(vKeyMap[0]); i++)
|
|
{
|
|
if (GetKeyState(vKeyMap[i].keyCode) < 0) // Key down
|
|
{
|
|
grfKeyState |= vKeyMap[i].keyFlag;
|
|
}
|
|
}
|
|
|
|
return grfKeyState;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: GetControlKeysStateOfParam
|
|
//
|
|
// Synopsis: gets the key/button state of wparam (used with mouse messages)
|
|
//
|
|
// Arguments: [wParam] -- the wParam to parse apart
|
|
//
|
|
// Returns: the key's set in wParam
|
|
//
|
|
// Algorithm: First determine if keys we are interested in are set
|
|
// in the wParam message. Then go check the state of the
|
|
// ALT key and record that in the key state. We then return
|
|
// that to the caller.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 06-Dec-93 alexgo 32bit port
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
WORD GetControlKeysStateOfParam(WPARAM wParam)
|
|
{
|
|
// Check all the buttons we are interested in at once.
|
|
WORD grfKeyState = (WORD) wParam
|
|
& (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON | MK_SHIFT | MK_CONTROL);
|
|
|
|
// get the alt key
|
|
if (GetKeyState(VK_ALT) < 0) // Key down
|
|
{
|
|
grfKeyState |= MK_ALT;
|
|
}
|
|
|
|
return grfKeyState;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: IsWin31DropTarget
|
|
//
|
|
// Synopsis: determines whether the given hwnd is a valid drop target
|
|
// for Win31 style drag drop
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [hwnd] -- the window to check
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: TRUE/
|
|
// FALSE
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Algorithm: checks the WS_EX_ACCEPTFILES style bit. If this bit is
|
|
// set and the window is not disabled, then it is a valid
|
|
// Win3.1 drop target.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 25-Jan-95 alexgo added check for WS_DISABLED
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL IsWin31DropTarget( HWND hwnd )
|
|
{
|
|
LONG exstyle;
|
|
|
|
exstyle = GetWindowLong(hwnd, GWL_EXSTYLE);
|
|
|
|
|
|
if( (exstyle & WS_EX_ACCEPTFILES) )
|
|
{
|
|
LONG style;
|
|
style = GetWindowLong(hwnd, GWL_STYLE);
|
|
|
|
if( !(style & WS_DISABLED) )
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: UseWin31DragDrop
|
|
//
|
|
// Synopsis: tests the given data object to see if enough data is offered
|
|
// to perform Win3.1 style drag drop
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pDataObject] -- pointer to the data object
|
|
//
|
|
// Requires: pdataobj must not be NULL
|
|
//
|
|
// Returns: TRUE/FALSE
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Algorithm: does an IDataObject::QueryGetData for CF_HDROP
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 30-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL UseWin31DragDrop(IDataObject *pDataObject)
|
|
{
|
|
FORMATETC formatetc;
|
|
|
|
INIT_FORETC(formatetc);
|
|
formatetc.cfFormat = CF_HDROP;
|
|
formatetc.tymed = TYMED_HGLOBAL;
|
|
|
|
if( pDataObject->QueryGetData(&formatetc) == NOERROR )
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: IsNCDrop
|
|
//
|
|
// Synopsis: are we dropping into the non-client area of the window or
|
|
// on an iconic window?
|
|
//
|
|
// Effects: *DOES A SEND MESSAGE*!!!
|
|
//
|
|
// Arguments: [hwnd] -- the window to ask
|
|
// [pt] -- the point in screen coords
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: TRUE/FALSE (TRUE if in non-client area)
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 25-Jan-95 alexgo borrowed from Win95 shell sources
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL IsNCDrop(HWND hwnd, POINT pt)
|
|
{
|
|
return (!IsIconic(hwnd) &&
|
|
HTCLIENT!=SendMessage(hwnd, WM_NCHITTEST, 0, MAKELPARAM(pt.x, pt.y)));
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: GetDropTarget
|
|
//
|
|
// Synopsis: Gets the IDropTarget * from the closest window in the
|
|
// hierachy up from the given window (if available, of
|
|
// course ;-)
|
|
//
|
|
// Arguments: [hwndCur] -- the window to the cursor is currently over
|
|
// [hwndDropTarget] -- the window that contains a valid DropTarget
|
|
//
|
|
// Returns: Result of drag enter operation at Target
|
|
//
|
|
// Algorithm: Loop calling PrivDragDrop until we get a drop target or
|
|
// we run out of windows that are parent to the window that
|
|
// the mouse is currently on.
|
|
//
|
|
// If a window in the hierarchy has registered itself for
|
|
// Win3.1 drag drop, then we create a drop target wrapper
|
|
// (CDropTarget) to handle the Win3.1 protocol. Note
|
|
// that a window hierarchy may be both OLE *and* Win3.1
|
|
// targets.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-94 alexgo converted to use PrivDragDrop
|
|
// 20-Oct-94 alexgo added Win31 drop target support
|
|
// 30-Sep-94 ricksa Drag/Drop optimization.
|
|
// 21-Jul-94 alexgo removed GetDropTargetFromWindow
|
|
// optimization and put that functionality
|
|
// in GetInterfaceFromWindowProp (to
|
|
// help make clipboard faster).
|
|
// 06-Apr-94 Ricksa Modified to call GetDropTargetFromWindow
|
|
// to optimize local calls
|
|
// 11-Jan-94 alexgo changed name from GetTopStm to
|
|
// GetDropTarget, converted to the RPC-style
|
|
// drag drop, added a VDATEHEAP macro
|
|
// 06-Dec-93 alexgo commented
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
HRESULT CDragOperation::GetDropTarget(HWND hwnd31,HWND hwndDropTarget)
|
|
{
|
|
IDropTarget *ptarget = NULL;
|
|
DDInfo hDDInfo = NULL;
|
|
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN GetDropTarget ( %x,%x)\n", this, hwnd31,hwndDropTarget));
|
|
|
|
_pDropTarget = NULL;
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
|
|
if (hwndDropTarget)
|
|
{
|
|
HWND hwndClipWindow;
|
|
|
|
Assert(GetProp(hwndDropTarget, (LPCWSTR)g_aDropTarget));
|
|
|
|
// If the DropTarget hasn't been marshaled, Marshal it now.
|
|
if (hwndClipWindow = (HWND) GetProp(hwndDropTarget,(LPCWSTR) g_aDropTargetMarshalHwnd))
|
|
{
|
|
SSSendMessage(hwndClipWindow,WM_OLE_CLIPBRD_MARSHALDROPTARGET,0,(LPARAM) hwndDropTarget);
|
|
}
|
|
|
|
hr = PrivDragDrop(hwndDropTarget,
|
|
DRAGOP_ENTER,
|
|
_DOBuffer,
|
|
_pDataObject,
|
|
_grfKeyState,
|
|
_cpt.GetPOINTL(),
|
|
_pdwEffect,
|
|
NULL,
|
|
&hDDInfo);
|
|
|
|
if (hr != NOERROR)
|
|
{
|
|
hwndDropTarget = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
Assert( (NULL == hwnd31) || IsWin31DropTarget(hwnd31));
|
|
|
|
if( hwndDropTarget || hwnd31 )
|
|
{
|
|
ptarget = new CDropTarget(hwnd31, hwndDropTarget, *_pdwEffect, this, hDDInfo);
|
|
|
|
if( ptarget == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = NOERROR;
|
|
}
|
|
|
|
// if we have a Win31 drop target AND the OLE drop target returned
|
|
// DROPEFFECT_NONE, then we should return DROPEFFECT_COPY
|
|
|
|
if( hr == NOERROR && *_pdwEffect == DROPEFFECT_NONE && hwnd31 )
|
|
{
|
|
*_pdwEffect = DROPEFFECT_COPY;
|
|
}
|
|
|
|
_pDropTarget = ptarget;
|
|
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT GetDropTarget ( %lx ) [ %p ]\n",
|
|
this, hr, _pDropTarget));
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::CDragOperation
|
|
//
|
|
// Synopsis: Initialize the object to start the operation
|
|
//
|
|
// Arguments: [pDataObject] - pointer to data object to drop
|
|
// [pDropSource] - pointer to source for drop operation
|
|
// [dwOKEffects] - effects allowed in drag operation
|
|
// [pdwEffect] - how operation affected source data
|
|
// [hr] - whether constructor succeeded
|
|
//
|
|
// Algorithm: Initialize data in object. Make sure that static data
|
|
// is initialized. Wait for first mouse message to begin.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 20-Oct-94 alexgo added support for Win31 drag drop
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CDragOperation::CDragOperation(
|
|
LPDATAOBJECT pDataObject,
|
|
LPDROPSOURCE pDropSource,
|
|
DWORD dwOKEffects,
|
|
DWORD FAR *pdwEffect,
|
|
HRESULT& hr)
|
|
:
|
|
_pDataObject(pDataObject),
|
|
_DOBuffer(NULL),
|
|
_pDropSource(pDropSource),
|
|
_pDropTarget(NULL),
|
|
_pRealDropTarget(NULL),
|
|
_hFormats(NULL),
|
|
_dwOKEffects(dwOKEffects),
|
|
_pdwEffect(pdwEffect),
|
|
_fEscapePressed(FALSE),
|
|
_curOld(GetCursor()),
|
|
_hwndLast((HWND) -1),
|
|
_grfKeyState(0),
|
|
_hrDragResult(S_OK),
|
|
_fReleasedCapture(FALSE),
|
|
_pcddcDefault(NULL),
|
|
_fUseWin31(FALSE)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
// Set the default scroll interval
|
|
if (s_wScrollInt < 0)
|
|
{
|
|
InitScrollInt();
|
|
}
|
|
|
|
hr = GetMarshalledInterfaceBuffer(IID_IDataObject, pDataObject,
|
|
&_DOBuffer);
|
|
|
|
if( hr != NOERROR )
|
|
{
|
|
Assert(NULL == _DOBuffer);
|
|
return;
|
|
}
|
|
|
|
// Get appropriate default cursor table object
|
|
if ((_pcddcDefault = CDragDefaultCursors::GetDefaultCursorObject()) == NULL)
|
|
{
|
|
// Some error occurred while we were trying to initialize the
|
|
// so return an error. This should be highly unusual.
|
|
DDDebugOut((DEB_ERROR,
|
|
"CDragDefaultCursors::GetDefaultCursorObject Failed!\n"));
|
|
hr = E_FAIL;
|
|
return;
|
|
}
|
|
|
|
// We will use the clipboard window to capture the mouse but we
|
|
// must have a clipboard window so we make sure it is created
|
|
// if it is not already there.
|
|
hr = ClipSetCaptureForDrag(this);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_hFormats = CreateSharedDragFormats(pDataObject);
|
|
|
|
// it's OK for _hFormats to be NULL (indicates an empty or non-existant
|
|
// formatetc enumertor
|
|
|
|
// For following peek
|
|
MSG msg;
|
|
|
|
// Busy wait until a mouse or escape message is in the queue
|
|
while (!PeekMessage(&msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE))
|
|
{
|
|
// Note: all keyboard messages except escape are tossed. This is
|
|
// fairly reasonable since the user has to be holding the left
|
|
// mouse button down at this point. They can't really be doing
|
|
// too much data input one handed.
|
|
if ((PeekMessage(&msg, 0, WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE)
|
|
|| PeekMessage(&msg, 0, WM_SYSKEYDOWN, WM_SYSKEYDOWN, PM_REMOVE))
|
|
&& msg.wParam == VK_ESCAPE)
|
|
{
|
|
_fEscapePressed = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// get mouse pos and key state
|
|
if (!_fEscapePressed)
|
|
{
|
|
_cpt.Set(msg.pt.x, msg.pt.y);
|
|
_grfKeyState = GetControlKeysStateOfParam(msg.wParam);
|
|
}
|
|
else
|
|
{
|
|
// We ask the cursor for its position since we didn't get a
|
|
// position from the mouse.
|
|
GetCursorPos(_cpt.GetAddressOfPOINT());
|
|
_grfKeyState = GetControlKeysState(TRUE);
|
|
}
|
|
|
|
// Check to see if we need to do Win3.1 style drag drop.
|
|
// If we do, then set a flag so we can construct a fake drop target as
|
|
// needed
|
|
|
|
if( UseWin31DragDrop(pDataObject) )
|
|
{
|
|
_fUseWin31 = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: ~CDragOperation
|
|
//
|
|
// Synopsis: Clean up object
|
|
//
|
|
// Algorithm: Release mouse capture. Restore ole cursor. Remove enum
|
|
// formats.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CDragOperation::~CDragOperation(void)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
AssertSz((_pDropTarget == NULL), "CDragOperation::~CDragOperation");
|
|
|
|
// Stop the mouse capture
|
|
ReleaseCapture();
|
|
|
|
// Restore the cursor if it got changed
|
|
SetCursor(_curOld);
|
|
|
|
// Close the handle to the shared memory
|
|
if (_hFormats)
|
|
{
|
|
CloseHandle(_hFormats);
|
|
_hFormats = NULL;
|
|
}
|
|
|
|
if( _DOBuffer )
|
|
{
|
|
ReleaseMarshalledInterfaceBuffer(_DOBuffer);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::InitScrollInt
|
|
//
|
|
// Synopsis: Initialize the scroll interval
|
|
//
|
|
// Algorithm: Look in profile for defined interval. If none set, then
|
|
// default to zero.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void CDragOperation::InitScrollInt(void)
|
|
{
|
|
DWORD dw;
|
|
OLECHAR szBuffer[20];
|
|
|
|
s_wScrollInt = DD_DEFSCROLLDELAY;
|
|
|
|
dw = sizeof(szBuffer);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(HKEY_CURRENT_USER,
|
|
OLESTR("Control Panel\\Mouse\\DragScrollDelay"),
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)szBuffer,
|
|
&dw))
|
|
{
|
|
s_wScrollInt = wcstol(szBuffer, NULL, 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::UpdateTarget
|
|
//
|
|
// Synopsis: Update the target window based on mouse location
|
|
//
|
|
// Returns: TRUE - continue drag operation
|
|
// FALSE - error or time to drop
|
|
//
|
|
// Algorithm: First, we query the source to see if it wants to continue
|
|
// with the drop. If so, we get current window for mouse. If
|
|
// it is different than the previous window check to see whether
|
|
// the targets are different. If they are different, then notify
|
|
// the current target that we are leaving and then notify the
|
|
// new target that we have arrived.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
// 10-Jul-94 AlexT Allow same IDropTarget on different HWNDs
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL CDragOperation::UpdateTarget(void)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDragOperation::UpdateTarget ( )\n", this));
|
|
|
|
// Assume this operation will continue the drag drop
|
|
BOOL fResult = TRUE;
|
|
HRESULT hr;
|
|
LPDROPTARGET lpCurDropTarget = NULL,
|
|
lpOldDropTarget = NULL;
|
|
HWND hWndTemp = NULL;
|
|
|
|
HWND hwndCur = WindowFromPoint(_cpt.GetPOINT());
|
|
|
|
// Query continue can return telling us one of four things:
|
|
// (1) Keep going (S_OK), (2) Drop operation should occur
|
|
// (DRAGDROP_S_DROP), (3) Drop operation is canceled
|
|
// (DRAGDROP_S_CANCEL) or (4) An unexpected error has occurred.
|
|
|
|
HRESULT hrQuery = _pDropSource->QueryContinueDrag(_fEscapePressed,
|
|
_grfKeyState);
|
|
|
|
if (FAILED(hrQuery) || (hrQuery == ResultFromScode(DRAGDROP_S_CANCEL)))
|
|
{
|
|
// Unexpected error or the operation has been cancelled so give up.
|
|
_hrDragResult = hrQuery;
|
|
fResult = FALSE;
|
|
goto UpdateTarget_exit;
|
|
}
|
|
|
|
// walk up the window list to find the actual pointer values for the current
|
|
// and old IDropTarget interfaces
|
|
if (hwndCur != _hwndLast)
|
|
{
|
|
hWndTemp = _hwndLast;
|
|
|
|
BOOL fChangedWin31 = FALSE;
|
|
|
|
HWND hWndOldDrop = NULL;
|
|
HWND hWndNewDrop = NULL;
|
|
HWND hWndWin31Drop = NULL;
|
|
|
|
LPDROPTARGET lpRealDropTarget = NULL;
|
|
HANDLE hTemp = NULL;
|
|
|
|
DWORD dwCurrentProcessId = 0;
|
|
|
|
if (hWndTemp != (HWND)-1)
|
|
GetWindowThreadProcessId(hWndTemp, &dwCurrentProcessId);
|
|
|
|
DWORD dwTempProcessID = dwCurrentProcessId;
|
|
|
|
while (hWndTemp && !lpRealDropTarget && hWndTemp != (HWND)-1 && dwTempProcessID == dwCurrentProcessId)
|
|
{
|
|
if (lpRealDropTarget = (IDropTarget *)GetProp(hWndTemp, (LPCWSTR)g_aDropTarget))
|
|
{
|
|
hWndOldDrop = hWndTemp;
|
|
}
|
|
|
|
hWndTemp = GetParent(hWndTemp);
|
|
|
|
if (hWndTemp)
|
|
{
|
|
GetWindowThreadProcessId(hWndTemp, &dwTempProcessID);
|
|
}
|
|
}
|
|
|
|
hWndTemp = hwndCur;
|
|
|
|
if (hWndTemp != (HWND)-1)
|
|
GetWindowThreadProcessId(hWndTemp, &dwCurrentProcessId);
|
|
|
|
dwTempProcessID = dwCurrentProcessId;
|
|
|
|
while (hWndTemp && dwTempProcessID == dwCurrentProcessId)
|
|
{
|
|
// If we haven't found the DropTarget yet, check this window.
|
|
if (!lpCurDropTarget)
|
|
{
|
|
if (lpCurDropTarget = (IDropTarget *)GetProp(hWndTemp, (LPCWSTR)g_aDropTarget))
|
|
{
|
|
hWndNewDrop = hWndTemp;
|
|
}
|
|
}
|
|
|
|
// if the current window is a win31 drop target, update the win31 window
|
|
// handle in our DropTarget Class. NOTE: Beware, this code relies on the
|
|
// fact that we can party on the CDropTarget Class directly, knowing that
|
|
// the class is reconstructed below as a result of the GetDropTarget()
|
|
// when the real IDropTarget ptrs change.
|
|
|
|
if (!fChangedWin31 &&
|
|
IsWin31DropTarget(hWndTemp) &&
|
|
_fUseWin31)
|
|
{
|
|
fChangedWin31 = TRUE;
|
|
|
|
hWndWin31Drop = hWndTemp;
|
|
|
|
if (_pDropTarget)
|
|
{
|
|
((CDropTarget*)_pDropTarget)->_hwnd31 = hWndTemp;
|
|
}
|
|
}
|
|
|
|
|
|
// if have a droptarget, and handle Win31 break.
|
|
if (lpCurDropTarget && (!_fUseWin31 || fChangedWin31))
|
|
{
|
|
break;
|
|
}
|
|
|
|
hWndTemp = GetParent(hWndTemp);
|
|
|
|
if (hWndTemp)
|
|
{
|
|
GetWindowThreadProcessId(hWndTemp, &dwTempProcessID);
|
|
}
|
|
}
|
|
|
|
// only update the drop target if the target has actually changed.
|
|
|
|
// HACK ALERT: We must explicitly check _hwndLast for -1 because Excel does not
|
|
// use OLE drag drop internally. When the cursor is moved outside the Overlapped
|
|
// Excel window, DoDragDrop is called. At this point _pRealDropTarget == NULL
|
|
// and lpCurDropTarget == NULL, and the no-smoking cursor does not appear.
|
|
|
|
// the _pRealDropTarget==NULL relies on the fact that lpCurDropTarget==NULL. This
|
|
// is true because the first case would short-circuit the rest of the condition
|
|
// otherwise
|
|
if ( (lpCurDropTarget != _pRealDropTarget) ||
|
|
(_hwndLast == (HWND)-1) ||
|
|
(hWndNewDrop != hWndOldDrop) ||
|
|
(_pRealDropTarget == NULL))
|
|
{
|
|
DDDebugOut((DEB_ITRACE, "%p lpCurDropTarget != lpOldDropTarget\n", this));
|
|
|
|
// The window that we are working on has changed
|
|
_hwndLast = hwndCur;
|
|
_pRealDropTarget = lpCurDropTarget;
|
|
|
|
//Allow the owner of the window to take foreground if it tries to.
|
|
if (dwCurrentProcessId)
|
|
AllowSetForegroundWindow(dwCurrentProcessId);
|
|
|
|
// Assume that neither current or previous window are drop aware
|
|
BOOL fCurAndLastNotDropAware = TRUE;
|
|
|
|
if (_pDropTarget != NULL)
|
|
{
|
|
// There was a previous drop target
|
|
|
|
// Last window was drag/drop aware
|
|
fCurAndLastNotDropAware = FALSE;
|
|
|
|
// Tell the drop target we are leaving & release it
|
|
_pDropTarget->DragLeave();
|
|
_pDropTarget->Release();
|
|
_pDropTarget = NULL;
|
|
}
|
|
|
|
// Set up effects for query of target
|
|
*_pdwEffect = _dwOKEffects;
|
|
|
|
hr = GetDropTarget(hWndWin31Drop,hWndNewDrop);
|
|
|
|
if (_pDropTarget != NULL)
|
|
{
|
|
// This window is drop awarre
|
|
fCurAndLastNotDropAware = FALSE;
|
|
|
|
// Errors from this call are ignored. We interpret them
|
|
// as the drop being disallowed. Since we don't really
|
|
// use this information here but in the DragOver call
|
|
// we make shortly, we just use this call to notify
|
|
// the application that we are beginning a drag operation.
|
|
|
|
if (!HandleFeedBack(hr))
|
|
{
|
|
goto UpdateTarget_exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Tell the source that nothing happened
|
|
|
|
// only use DROPEFFECT_NONE if there is no new drop target.
|
|
hr = _pDropSource->GiveFeedback(*_pdwEffect = DROPEFFECT_NONE);
|
|
|
|
if (hr != NOERROR)
|
|
{
|
|
if (DRAGDROP_S_USEDEFAULTCURSORS == GetScode(hr))
|
|
{
|
|
_pcddcDefault->SetCursorNone();
|
|
}
|
|
else
|
|
{
|
|
// Unexpected error -- we will give up drag/drop.
|
|
DDDebugOut((DEB_ERROR,
|
|
"CDragOperation::UpdateTarget 1st GiveFeedback FAILED %x\n",
|
|
hr));
|
|
_hrDragResult = hr;
|
|
fResult = FALSE;
|
|
goto UpdateTarget_exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fCurAndLastNotDropAware)
|
|
{
|
|
// Neither new or old window know about drag/drop so set
|
|
// cursor accordingly.
|
|
_pcddcDefault->SetCursorNone();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The window that we are working on has changed
|
|
_hwndLast = hwndCur;
|
|
}
|
|
}
|
|
|
|
|
|
if (hrQuery != NOERROR)
|
|
{
|
|
// Query asked for a drop
|
|
fResult = FALSE;
|
|
_hrDragResult = hrQuery;
|
|
}
|
|
|
|
UpdateTarget_exit:
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDragOperation::UpdateTarget ( %lx )\n",
|
|
this, fResult));
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::HandleFeedBack
|
|
//
|
|
// Synopsis: Handle feedback and update of cursor
|
|
//
|
|
// Arguments: [hr] - hresult from previous operation on drop target.
|
|
//
|
|
// Returns: TRUE - continue drag operation
|
|
// FALSE - error
|
|
//
|
|
// Algorithm: If previous operation on the target failed, map this to a
|
|
// disallowed drop. Then ask the source for feedback. If it
|
|
// so requests, then update the cursor. If an unexpected
|
|
// error occurs, let caller know that loop should break.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 19-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL CDragOperation::HandleFeedBack(HRESULT hr)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDragOperation::HandleFeedBack ( %x )\n",
|
|
this, hr));
|
|
|
|
BOOL fResult = TRUE;
|
|
|
|
if (hr != NOERROR)
|
|
{
|
|
|
|
// target not responding for some reason; treat
|
|
// as if drop not possible, but don't preserve
|
|
// the reason why.
|
|
*_pdwEffect = DROPEFFECT_NONE;
|
|
}
|
|
|
|
// If bogus return from drag over, then make sure results are appropriate.
|
|
// However, if we are in a WOW we need to do things a little differently
|
|
// to maintain complete compatability with Win 3.1. In 16-bit OLE 2.0,
|
|
// the *_pdwEffect value is not changed when displaying feedback (i.e.,
|
|
// the result of the & is not stored back into *_pdwEffect in Win 3.1...
|
|
// in straight NT we do). Not storing the results back into *_pdwEffect
|
|
// when InWow() is a hack specifically for Visio, and even more
|
|
// specifically, for dragging from Visio's palette of "items" to an
|
|
// Excel spreadsheet.
|
|
|
|
if (IsWOWThread())
|
|
{
|
|
hr = _pDropSource->GiveFeedback( *_pdwEffect & (_dwOKEffects | DROPEFFECT_SCROLL));
|
|
}
|
|
else
|
|
{
|
|
*_pdwEffect &= (_dwOKEffects | DROPEFFECT_SCROLL);
|
|
|
|
hr = _pDropSource->GiveFeedback(*_pdwEffect);
|
|
}
|
|
|
|
if(hr != NOERROR)
|
|
{
|
|
// Either we want to change the cursor or some unexpected
|
|
// error has occurred.
|
|
|
|
if (DRAGDROP_S_USEDEFAULTCURSORS == GetScode(hr))
|
|
{
|
|
_pcddcDefault->SetCursor(*_pdwEffect);
|
|
}
|
|
else
|
|
{
|
|
DDDebugOut((DEB_ERROR,
|
|
"CDragOperation::HandleFeedBack Feedback FAILED %x\n", hr));
|
|
|
|
fResult = FALSE;
|
|
|
|
_hrDragResult = hr;
|
|
}
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDragOperation::HandleFeedBack ( %lx )\n",
|
|
this, fResult));
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::DragOver
|
|
//
|
|
// Synopsis: Tell the target we are dragging over and process the result
|
|
//
|
|
// Returns: TRUE - continue drag operation
|
|
// FALSE - error or time to drop
|
|
//
|
|
// Algorithm: Call the target's drag over if there is one and then
|
|
// get the sources feedback to update the cursor accordingly.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL CDragOperation::DragOver(void)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDragOperation::DragOver ( )\n", this));
|
|
|
|
// Default the result of the function to continue the loop for
|
|
// drag and drop.
|
|
BOOL fResult = TRUE;
|
|
|
|
// Local holder for errors.
|
|
HRESULT hr;
|
|
|
|
if (_pDropTarget != NULL)
|
|
{
|
|
// Keep effect in a local variable to save indirections
|
|
// in this routine.
|
|
*_pdwEffect = _dwOKEffects;
|
|
|
|
hr = _pDropTarget->DragOver(_grfKeyState, _cpt.GetPOINTL(), _pdwEffect);
|
|
|
|
// Get feedback from source & update cursor if necessary
|
|
fResult = HandleFeedBack(hr);
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDragOperation::DragOver ( %lx )\n",
|
|
this, fResult));
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::HandleMessages
|
|
//
|
|
// Synopsis: Handle windows messages
|
|
//
|
|
// Returns: TRUE - continue drag operation
|
|
// FALSE - error or time to drop
|
|
//
|
|
// Algorithm: Check for any windows message. If the message is a mouse
|
|
// message then record the new position of the mouse. If it
|
|
// is a key message, the record whether escape has been pushed.
|
|
// If this is any other message, then dispatch it. Repeat this
|
|
// process until the scroll interval has been exceeded.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL CDragOperation::HandleMessages(void)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDragOperation::HandleMessages ( )\n",
|
|
this));
|
|
|
|
|
|
// Message buffer
|
|
MSG msg;
|
|
|
|
// Default result of function to continue
|
|
BOOL fResult = TRUE;
|
|
|
|
// Capture all messages (i.e. modal loop).
|
|
// Process all input messages, dispatch other messages
|
|
//
|
|
// Note:we must NOT loop here until a hardware message comes in
|
|
// scrolling will not work.
|
|
// * yielding is important since other apps need to run
|
|
// * look for mouse messages first since these are the most
|
|
// impotant
|
|
|
|
// Flag for whether we peeked a message
|
|
BOOL fMsg;
|
|
|
|
//
|
|
// Sundown - The SetTimer return value can be truncated.
|
|
// We are passing NULL as HWND and Win32 will returned
|
|
// a value not greater than 4GB...
|
|
// If a check is required we could consider a temporary
|
|
// UINT_PTR value and do an ASSERT on its value...
|
|
//
|
|
|
|
UINT uTimer = (UINT)SetTimer(NULL, 0, s_wScrollInt, NULL);
|
|
|
|
do
|
|
{
|
|
fMsg = FALSE;
|
|
|
|
// Note: the order of peek is important - further messages can show up
|
|
// in the last peek
|
|
|
|
// If we looked for mouse messages first, we might never pick up
|
|
// WM_QUIT or keyboard messages (because by the time we finished
|
|
// processing the mouse message another might be on the queue).
|
|
// So, we check for WM_QUIT and keyboard messages first.
|
|
|
|
if (PeekMessage(&msg, 0, WM_QUIT, WM_QUIT, PM_REMOVE | PM_NOYIELD) ||
|
|
PeekMessage(&msg, 0, WM_KEYFIRST, WM_KEYLAST,
|
|
PM_REMOVE | PM_NOYIELD) ||
|
|
PeekMessage(&msg, 0, WM_SYSKEYDOWN, WM_SYSKEYUP,
|
|
PM_REMOVE | PM_NOYIELD) ||
|
|
PeekMessage(&msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE) ||
|
|
PeekMessage(&msg, 0, WM_NCMOUSEFIRST, WM_NCMOUSELAST,
|
|
PM_REMOVE | PM_NOYIELD) ||
|
|
PeekMessage(&msg, 0, 0, 0, PM_REMOVE | PM_NOYIELD))
|
|
{
|
|
fMsg = TRUE;
|
|
|
|
|
|
|
|
if (msg.message == WM_QUIT)
|
|
{
|
|
// Quit message so we are done.
|
|
PostQuitMessage((int) msg.wParam);
|
|
|
|
// We are going exiting so the error doesn't matter too much
|
|
_hrDragResult = ResultFromScode(E_UNSPEC);
|
|
|
|
// Make sure we break out of the loop
|
|
fResult = FALSE;
|
|
}
|
|
else if ((msg.message >= WM_KEYFIRST &&
|
|
msg.message <= WM_KEYLAST) ||
|
|
(msg.message >= WM_SYSKEYDOWN &&
|
|
msg.message <= WM_SYSKEYUP))
|
|
{
|
|
// Pull all keyboard messages from the queue - this keeps
|
|
// the keyboard state in sync with the user's actions
|
|
|
|
// We use a do/while so that we process the message we've
|
|
// already peeked.
|
|
|
|
do
|
|
{
|
|
// We only really pay attention to the escape key and dump
|
|
// any other key board messages.
|
|
if ((msg.message == WM_KEYDOWN
|
|
|| msg.message == WM_SYSKEYDOWN)
|
|
&& msg.wParam == VK_ESCAPE)
|
|
{
|
|
// Esc pressed: Cancel
|
|
_fEscapePressed = TRUE;
|
|
}
|
|
}
|
|
while (PeekMessage(&msg, 0, WM_KEYFIRST, WM_KEYLAST,
|
|
PM_REMOVE | PM_NOYIELD) ||
|
|
PeekMessage(&msg, 0, WM_SYSKEYDOWN, WM_SYSKEYUP,
|
|
PM_REMOVE | PM_NOYIELD));
|
|
|
|
DWORD grfKeyState; // temp variable for key state
|
|
|
|
// get the key state don't change the button states!!
|
|
grfKeyState = GetControlKeysState(FALSE) |
|
|
(_grfKeyState &
|
|
(MK_LBUTTON | MK_RBUTTON | MK_MBUTTON));
|
|
|
|
// if the keyboard state is unchanged, then don't exit
|
|
// this loop (as that will result in DragOver being called).
|
|
// If we call DragOver for each keyboard message, then
|
|
// performance is unacceptably slow.
|
|
|
|
if ((grfKeyState == _grfKeyState) && !_fEscapePressed)
|
|
{
|
|
fMsg = FALSE;
|
|
}
|
|
else
|
|
{
|
|
DDDebugOut((DEB_ITRACE, "Updating key state\n"));
|
|
_grfKeyState = grfKeyState;
|
|
}
|
|
}
|
|
else if (msg.message >= WM_MOUSEFIRST &&
|
|
msg.message <= WM_MOUSELAST)
|
|
{
|
|
// we may not have the focus (e.g. if we are the Chicago
|
|
// shell). Therefore, we won't ever get any WM_KEYDOWN
|
|
// messages. Double check the esc key status here
|
|
|
|
if( GetKeyState(VK_ESCAPE) < 0 )
|
|
{
|
|
_fEscapePressed = TRUE;
|
|
}
|
|
|
|
// We got a mouse move message - we skip all the mouse messages
|
|
// till we get to the last one. The point here is that
|
|
// because of the length of DragOver calls, we can get behind
|
|
// in processing messages which causes odd things to happen
|
|
// on the screen.
|
|
if (WM_MOUSEMOVE == msg.message)
|
|
{
|
|
MSG msg2;
|
|
|
|
// Keep processing mouse move messages till there
|
|
// aren't any more.
|
|
// if PeekMessage returns true update the original msg.
|
|
while(PeekMessage(&msg2, 0, WM_MOUSEMOVE, WM_MOUSEMOVE,
|
|
PM_REMOVE))
|
|
{
|
|
msg = msg2;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// Record position of the mouse
|
|
_cpt.Set(msg.pt.x, msg.pt.y);
|
|
|
|
// set mouse button state here
|
|
_grfKeyState = GetControlKeysStateOfParam(msg.wParam);
|
|
|
|
}
|
|
else if (msg.message >= WM_NCMOUSEFIRST &&
|
|
msg.message <= WM_NCMOUSELAST)
|
|
{
|
|
// Nothing we need to do for these NC mouse actions
|
|
NULL;
|
|
}
|
|
else if ( (msg.message == WM_TIMER) && (msg.wParam == uTimer) )
|
|
{
|
|
// Our timer was triggered. We need to recheck the keyboard
|
|
// state just in case it has changed. This is important for
|
|
// the Chicago shell--if it doesn't have focus, then we won't
|
|
// get any WM_KEYDOWN message (just mouse moves).
|
|
|
|
_grfKeyState = GetControlKeysState(FALSE) | (_grfKeyState &
|
|
(MK_LBUTTON | MK_RBUTTON | MK_MBUTTON));
|
|
|
|
if( GetKeyState(VK_ESCAPE) < 0 )
|
|
{
|
|
_fEscapePressed = TRUE;
|
|
}
|
|
|
|
// go ahead and fall out of the loop so we call DragOver
|
|
// (our timeout expired).
|
|
}
|
|
else
|
|
{
|
|
// Dispatch all other messages
|
|
DispatchMessage(&msg);
|
|
fMsg = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WaitMessage();
|
|
}
|
|
|
|
// we have to leave the loop periodicially since apps
|
|
// might rely on on it the DragOver is called freqeuntly.
|
|
} while (!fMsg);
|
|
|
|
// Get rid of the timer we created for the loop
|
|
KillTimer(NULL, uTimer);
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDragOperation::HandleMessages ( %lx )\n",
|
|
this, fResult));
|
|
|
|
|
|
return fResult;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CDragOperation::CompleteDrop
|
|
//
|
|
// Synopsis: Complete the drag/drop operation
|
|
//
|
|
// Returns: Result of operation
|
|
//
|
|
// Algorithm: If there is a target and we have decided to drop, then
|
|
// drop. Otherwise, release the target and return whatever
|
|
// the other result of the operation was.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 04-Apr-94 Ricksa Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CDragOperation::CompleteDrop(void)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDragOperation::CompleteDrop ( )\n",
|
|
this));
|
|
|
|
// Stop the mouse capture in case a dialog box is thrown up.
|
|
ReleaseCapture();
|
|
|
|
if (_pDropTarget != NULL)
|
|
{
|
|
// Caller is Drag/Drop aware
|
|
// and indicated it might accept drop
|
|
|
|
// The drop source replies DRAG_S_DROP if the user has
|
|
// released the left mouse button. However, we may be over
|
|
// a drop target which has refused a drop (via the feedback
|
|
// DROPEFFECT_NONE). Thus, both the drop source and drop
|
|
// target need to agree before we commit the drop.
|
|
|
|
if ((DRAGDROP_S_DROP == GetScode(_hrDragResult))
|
|
&& (*_pdwEffect != DROPEFFECT_NONE))
|
|
{
|
|
// We are going to try to drop
|
|
*_pdwEffect = _dwOKEffects;
|
|
|
|
HRESULT hr = _pDropTarget->Drop(_pDataObject, _grfKeyState,
|
|
_cpt.GetPOINTL(), _pdwEffect);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// If drop actually failed in the last stage, let the
|
|
// caller know that this happened.
|
|
_hrDragResult = hr;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
*_pdwEffect = DROPEFFECT_NONE;
|
|
_pDropTarget->DragLeave();
|
|
|
|
}
|
|
|
|
_pDropTarget->Release();
|
|
_pDropTarget = NULL;
|
|
}
|
|
else
|
|
{
|
|
*_pdwEffect = DROPEFFECT_NONE;
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDragOperation::CompleteDrop ( %lx )\n",
|
|
this, _hrDragResult));
|
|
|
|
return _hrDragResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: RegisterDragDrop
|
|
//
|
|
// Synopsis: Registers a drop target
|
|
//
|
|
// Arguments: [hwnd] -- a handle to the drop target window
|
|
// [pDropTarget] -- the IDropTarget interface for the window
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Algorithm: We ask compobj (via AssignEndpoinProperty) to put an
|
|
// endpoint ID publicly available on the window handle. Then
|
|
// we put the IDropTarget pointer on the window as a private
|
|
// property (see the notes at the beginning of this file).
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 06-Apr-94 ricksa Added tracing
|
|
// 16-Jan-94 alexgo pDropTarget is now AddRef'ed
|
|
// 11-Jan-94 alexgo added VDATEHEAP, converted to RPC-style
|
|
// drag drop.
|
|
// 06-Dec-93 alexgo commented
|
|
//
|
|
// Notes: By AddRef'ing the pDropTarget pointer, we are changing
|
|
// the semantics of the 16bit code (which did not do an
|
|
// AddRef).
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#pragma SEG(RegisterDragDrop)
|
|
STDAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
|
|
{
|
|
HRESULT hresult = NOERROR;
|
|
BOOL fDelayDrop = FALSE;
|
|
|
|
VDATEHEAP();
|
|
|
|
OLETRACEIN((API_RegisterDragDrop, PARAMFMT("hwnd= %h, pDropTarget= %p"),
|
|
hwnd, pDropTarget));
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN RegisterDragDrop ( %lx %p )\n",
|
|
NULL, hwnd, pDropTarget));
|
|
|
|
|
|
if (!IsValidInterface(pDropTarget))
|
|
{
|
|
hresult = E_INVALIDARG;
|
|
}
|
|
else if (!IsWindow(hwnd))
|
|
{
|
|
hresult = DRAGDROP_E_INVALIDHWND;
|
|
}
|
|
else
|
|
{
|
|
CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IDropTarget,(IUnknown **)&pDropTarget);
|
|
|
|
if (GetProp(hwnd, (LPCWSTR)g_aDropTarget))
|
|
{
|
|
hresult = DRAGDROP_E_ALREADYREGISTERED;
|
|
}
|
|
else if (!SetProp(hwnd, (LPCWSTR)g_aDropTarget, (HANDLE)pDropTarget))
|
|
{
|
|
hresult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwAssignAptID;
|
|
|
|
Win4Assert(NOERROR == hresult);
|
|
|
|
// HACK: We need to add this atom every time RegisterDragDrop
|
|
// is called because 16-bit Word does not call RevokeDragDrop
|
|
// and user will automatically clean-up this atom if Word is the
|
|
// first app run, and then exited before another app calls
|
|
// RegisterDragDrop.
|
|
g_aEndPointAtom = GlobalAddAtom(ENDPOINT_PROP_NAME);
|
|
|
|
|
|
// See if Delayed Drop can be set up.
|
|
fDelayDrop = FALSE;
|
|
|
|
if (g_aDropTargetMarshalHwnd && IsApartmentInitialized())
|
|
{
|
|
HWND hwndClipboard = GetPrivateClipboardWindow(CLIP_CREATEIFNOTTHERE);
|
|
|
|
if (hwndClipboard)
|
|
{
|
|
fDelayDrop = SetProp(hwnd,(LPCWSTR) g_aDropTargetMarshalHwnd,hwndClipboard);
|
|
}
|
|
}
|
|
|
|
// if can't delay marshal then marshal immediately.
|
|
if (!fDelayDrop)
|
|
{
|
|
hresult = AssignEndpointProperty(hwnd);
|
|
}
|
|
|
|
if (NOERROR == hresult)
|
|
{
|
|
pDropTarget->AddRef();
|
|
}
|
|
else
|
|
{
|
|
// We don't free h. It's not a handle at all.
|
|
HANDLE h = RemoveProp(hwnd, (LPCWSTR)g_aDropTarget);
|
|
}
|
|
}
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT RegisterDragDrop ( %lx )\n",
|
|
NULL, hresult));
|
|
|
|
OLETRACEOUT((API_RegisterDragDrop, hresult));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: RevokeDragDrop
|
|
//
|
|
// Synopsis: Unregisters a window as a drop target
|
|
//
|
|
// Arguments: [hwnd] -- the window to unregister
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Algorithm: Removes the two window properties set by
|
|
// RegisterDragDrop
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 06-Apr-94 ricksa added tracing
|
|
// 16-Jan-94 alexgo added a Release to the drag drop
|
|
// pointer to match the AddRef in
|
|
// RegisterDragDrop.
|
|
// 11-Jan-94 alexgo converted to RPC-style drag drop,
|
|
// added VDATEHEAP macro
|
|
// 06-Dec-93 alexgo commented
|
|
//
|
|
// Notes: the DropTarget->Release call changes the semantics of
|
|
// this function from the 16bit version (see Notes: for
|
|
// RegisterDragDrop).
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#pragma SEG(RevokeDragDrop)
|
|
STDAPI RevokeDragDrop(HWND hwnd)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
LPDROPTARGET pDropTarget;
|
|
BOOL fReleaseDropTarget = TRUE;
|
|
|
|
VDATEHEAP();
|
|
|
|
|
|
OLETRACEIN((API_RevokeDragDrop, PARAMFMT("hwnd= %h"), hwnd));
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN RevokeDragDrop ( %lx )\n", NULL, hwnd));
|
|
|
|
if (!IsWindow(hwnd))
|
|
{
|
|
hr = DRAGDROP_E_INVALIDHWND;
|
|
}
|
|
else if ((pDropTarget = (LPDROPTARGET)RemoveProp(hwnd, (LPCWSTR)g_aDropTarget)) == NULL)
|
|
{
|
|
hr = DRAGDROP_E_NOTREGISTERED;
|
|
}
|
|
else
|
|
{
|
|
fReleaseDropTarget = TRUE;
|
|
|
|
if (GetProp(hwnd, (LPCWSTR) g_aEndPointAtom)) // see if there is an endpoint.
|
|
{
|
|
DWORD dwAssignAptID;
|
|
|
|
// Ask compobj to remove the endpoint ID it placed on the window.
|
|
if(SUCCEEDED(UnAssignEndpointProperty(hwnd,&dwAssignAptID)))
|
|
{
|
|
// Note: AptID == ThreadID in Apartment model.
|
|
if( (dwAssignAptID != GetCurrentThreadId()) && (IsApartmentInitialized()) )
|
|
{
|
|
fReleaseDropTarget = FALSE;
|
|
}
|
|
}
|
|
|
|
Win4Assert(NULL == GetProp(hwnd,(LPCWSTR) g_aDropTargetMarshalHwnd));
|
|
}
|
|
else
|
|
{
|
|
HWND hwndClipbrd;
|
|
|
|
hwndClipbrd = (HWND) RemoveProp(hwnd,(LPCWSTR) g_aDropTargetMarshalHwnd);
|
|
Win4Assert(hwndClipbrd);
|
|
|
|
fReleaseDropTarget = (IsApartmentInitialized() && (hwndClipbrd != GetPrivateClipboardWindow(CLIP_QUERY )) )
|
|
? FALSE : TRUE;
|
|
}
|
|
|
|
// Release our reference to the object since we are no longer using it.
|
|
// NOTE: AddRef came from RegisterDragDrop
|
|
|
|
// Warning: Only call Release if we are in the same thread that Registered the DropTarget
|
|
// Or we are FreeThreading.
|
|
|
|
// This mirrors the atom added in RegisterDragDrop
|
|
GlobalDeleteAtom(g_aEndPointAtom);
|
|
|
|
if (fReleaseDropTarget)
|
|
{
|
|
pDropTarget->Release();
|
|
hr = NOERROR; // Always return NOERROR even if UnAssignEndPoint Failed
|
|
}
|
|
else
|
|
{
|
|
LEDebugOut((DEB_WARN, "WARNING:Revoke Called on Different Thread than Register!!\n"));
|
|
hr = RPC_E_WRONG_THREAD;
|
|
}
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT RegisterDragDrop ( %lx )\n", NULL, hr));
|
|
|
|
OLETRACEOUT((API_RevokeDragDrop, hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: DoDragDrop
|
|
//
|
|
// Synopsis: The main drag'n'drop loop
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pDataObject] -- the object to drag
|
|
// [pDropSource] -- the drop source
|
|
// [dwOKEffects] -- effects flags (stuff to draw)
|
|
// [pdwEffect] -- what actually happened in
|
|
// the drag drop attempt
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Algorithm: See the notes at the beginning of the file
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 25-Nov-96 gopalk Fail the call if OleInitialize has not
|
|
// been called
|
|
// 05-Dec-94 JohannP added stack switching for WIN95
|
|
// 11-Jan-94 alexgo added VDATEHEAP macro, converted to
|
|
// the RPC-style drag drop.
|
|
// 31-Dec-93 erikgav chicago port
|
|
// 06-Dec-93 alexgo formatted
|
|
//
|
|
// Notes: Under Win95 SSAPI(DoDragDrop) gets expanded to SSDoDragDrop.
|
|
// This function is called by DoDragDrop (in stkswtch.cxx)
|
|
// which switches to the 16 bit stack first.
|
|
// IMPORTANT: this function has to be executed on the 16 bit
|
|
// since call back via USER might occur.
|
|
//--------------------------------------------------------------------------
|
|
#pragma SEG(DoDragDrop)
|
|
STDAPI SSAPI(DoDragDrop)(LPDATAOBJECT pDataObject, LPDROPSOURCE pDropSource,
|
|
DWORD dwOKEffects, DWORD *pdwEffect)
|
|
{
|
|
OLETRACEIN((API_DoDragDrop,
|
|
PARAMFMT("pDataObject=%p, pDropSource=%p, dwOKEffects=%x, pdwEffect=%p"),
|
|
pDataObject, pDropSource, dwOKEffects, pdwEffect));
|
|
DDDebugOut((DEB_ITRACE, "%p _IN DoDragDrop (%p %p %lx %p )\n",
|
|
NULL, pDataObject, pDropSource, dwOKEffects, pdwEffect));
|
|
|
|
HRESULT hr = NOERROR;
|
|
|
|
#ifndef _MAC
|
|
// Validation checks
|
|
VDATEHEAP();
|
|
CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IDataObject,(IUnknown **)&pDataObject);
|
|
CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IDropSource,(IUnknown **)&pDropSource);
|
|
if(!IsValidPtrOut(pdwEffect, sizeof(DWORD)) ||
|
|
!IsValidInterface(pDropSource) ||
|
|
!IsValidInterface(pDataObject))
|
|
hr = E_INVALIDARG;
|
|
|
|
// Check if the thread has called oleinitialize
|
|
if(!IsOleInitialized())
|
|
hr = CO_E_NOTINITIALIZED;
|
|
|
|
if(hr == NOERROR) {
|
|
// Create the object that does all the work.
|
|
CDragOperation drgop(pDataObject, pDropSource, dwOKEffects, pdwEffect, hr);
|
|
|
|
// Did the constructor succeeded?
|
|
if(SUCCEEDED(hr)) {
|
|
// Loop till worker object tells us to stop
|
|
for(;;) {
|
|
// Update target based on new window position
|
|
if(!drgop.UpdateTarget()) {
|
|
// Error so we are done
|
|
break;
|
|
}
|
|
|
|
// Notify
|
|
if(!drgop.DragOver()) {
|
|
break;
|
|
}
|
|
|
|
// Handle any messages we get in the mean time
|
|
if(!drgop.HandleMessages()) {
|
|
break;
|
|
}
|
|
|
|
} // end for loop
|
|
|
|
hr = drgop.CompleteDrop();
|
|
}
|
|
}
|
|
#endif // !_MAC
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT DoDragDrop ( %lx )\n", NULL, hr));
|
|
OLETRACEOUT((API_DoDragDrop, hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::CDropTarget
|
|
//
|
|
// Synopsis: constructor for the CDropTarget class
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [hwnd31] -- the hwnd of the Win3.1 drop target
|
|
// may be NULL
|
|
// [hwndOLE] -- the hwnd of the OLE drop target
|
|
// [dwEffectLast] -- the last effect given the the current
|
|
// drop target that we are to emulate
|
|
// [pdo] -- a pointer to the main drag drop class
|
|
// [hDDInfo] -- handle to cached drag drag info
|
|
//
|
|
//
|
|
// Requires: hwnd31 *must* be a handle to a valid Win3.1 drop source
|
|
//
|
|
// Returns: void
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation:
|
|
//
|
|
// Algorithm: initializes variables
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 20-Oct-94 alexgo author
|
|
// 08-Jan-95
|
|
//
|
|
// Notes: there are two ways of determining if a given hwnd is
|
|
// a valid Win3.1 drop target:
|
|
// 1. send a WM_QUERYDROPOBJECT message for a TRUE/FALSE
|
|
// reply
|
|
// 2. check the extended style bits for WS_EX_ACCEPTFILES
|
|
//
|
|
// if ptarget is non-NULL, then the specific window to which
|
|
// it belongs is *not* guaranteed to be the same window as
|
|
// hwndtarget. hwndtarget is the window that is registered as
|
|
// a Win3.1 target. All that is guaranteed is that the ole
|
|
// target and hwndtarget are in the same window hierarchy.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CDropTarget::CDropTarget( HWND hwnd31, HWND hwndOLE, DWORD dwEffectLast,
|
|
CDragOperation *pdo, DDInfo hDDInfo )
|
|
{
|
|
_crefs = 1;
|
|
|
|
_hwndOLE = hwndOLE;
|
|
_hwnd31 = hwnd31;
|
|
_hDDInfo = hDDInfo;
|
|
|
|
_dwEffectLast = dwEffectLast;
|
|
|
|
_pdo = pdo; // pointer to the current drag operation class
|
|
|
|
#if DBG ==1
|
|
|
|
// now do some checking (see Notes above)
|
|
|
|
if( hwnd31 )
|
|
{
|
|
LONG exstyle;
|
|
|
|
exstyle = GetWindowLong(hwnd31, GWL_EXSTYLE);
|
|
|
|
// strictly speaking, an app could process the WM_QUERYDROPOBJECT
|
|
// message itself (and thus, not set the extended style bits).
|
|
// However, this should be considered an application bug; the
|
|
// documentation states that apps should call DragAcceptFiles,
|
|
// which will set the WS_EX_ACCEPTFILES bit
|
|
|
|
Assert( (exstyle & WS_EX_ACCEPTFILES) );
|
|
}
|
|
|
|
#endif // DBG ==1
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::~CDropTarget
|
|
//
|
|
// Synopsis: frees the cached drag drop info handle
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: void
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation:
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Jan-95 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CDropTarget::~CDropTarget()
|
|
{
|
|
if( _hDDInfo )
|
|
{
|
|
FreeDragDropInfo(_hDDInfo);
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::QueryInterface
|
|
//
|
|
// Synopsis: returns available interfaces on this object
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [riid] -- the requested interface
|
|
// [ppv] -- where to put the interface
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: E_UNEXPECTED
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm: CDropTarget is only used internally by OLE's drag drop code.
|
|
// It should never do a QI.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDropTarget::QueryInterface( REFIID riid, LPVOID * ppv )
|
|
{
|
|
(void)riid; // unused;
|
|
(void)ppv; // unused;
|
|
|
|
AssertSz(0, "Unexpected QI to CDropTarget");
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::AddRef
|
|
//
|
|
// Synopsis: increments the reference count
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: ULONG, the new reference count
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CDropTarget::AddRef( void )
|
|
{
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDropTarget::AddRef ( )\n", this));
|
|
|
|
_crefs++;
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDropTarget::AddRef ( %ld )\n", this,
|
|
_crefs));
|
|
|
|
return _crefs;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::Release
|
|
//
|
|
// Synopsis: decrements the reference count
|
|
//
|
|
// Effects: may delete 'this' object
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: ULONG, the new reference count
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CDropTarget::Release( void )
|
|
{
|
|
ULONG crefs;
|
|
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDropTarget::Release ( )\n", this));
|
|
|
|
crefs = --_crefs;
|
|
|
|
if( crefs == 0)
|
|
{
|
|
DDDebugOut((DEB_ITRACE, "DELETING CDropTarget %p\n", this));
|
|
delete this;
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDropTarget::Release ( %ld )\n",
|
|
this, crefs));
|
|
|
|
return crefs;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::DragEnter
|
|
//
|
|
// Synopsis: sets the window up for drag drop
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pDataObject] -- the data object to drop
|
|
// [grfKeyState] -- the current keyboard state
|
|
// [pt] -- the cursor point
|
|
// [pdwEffect] -- where to return the drag drop effect
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm: should never be called. DragEnter is always called
|
|
// via GetDropTarget
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-93 alexgo eliminated
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDropTarget::DragEnter( IDataObject * pDataObject,
|
|
DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect )
|
|
{
|
|
AssertSz(0, "DragEnter unexpectedly called!");
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::DragOver
|
|
//
|
|
// Synopsis: called while the mouse is over a given window
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [grfKeyState] -- the state of the keyboard
|
|
// [ptl] -- the position of the cursor
|
|
// [pdwEffect] -- the drag drop effect
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: NOERROR
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm: If an OLE target is available, then we forward the call.
|
|
// If the target says DROPEFFECT_NONE, then we go ahead
|
|
// and return DROPEFFECT_COPY if a Win31 target window is
|
|
// available.
|
|
//
|
|
// If there is no OLE target and we have a Win3.1 target,
|
|
// then we go ahead and return DROPEFFECT_COPY.
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-94 alexgo converted to PrivDragDrop protocol
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDropTarget::DragOver( DWORD grfKeyState, POINTL ptl,
|
|
DWORD *pdwEffect)
|
|
{
|
|
HRESULT hresult = NOERROR;
|
|
|
|
VDATEHEAP();
|
|
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDropTarget::DragOver ( %lx , %lx "
|
|
", %lx )\n", this, grfKeyState, &ptl, *pdwEffect));
|
|
|
|
if( _hwndOLE )
|
|
{
|
|
hresult = PrivDragDrop(_hwndOLE, DRAGOP_OVER, NULL, NULL, grfKeyState,
|
|
ptl, pdwEffect, NULL, &_hDDInfo);
|
|
|
|
_dwEffectLast = *pdwEffect;
|
|
|
|
if( _hwnd31 )
|
|
{
|
|
// we only want to stomp on the effect if the DragOver call
|
|
// succeeded. If the call failed, then just assume that a
|
|
// Win3.1 drop would fail as well.
|
|
|
|
if( hresult == NOERROR && *pdwEffect == DROPEFFECT_NONE )
|
|
{
|
|
*pdwEffect = DROPEFFECT_COPY;
|
|
}
|
|
}
|
|
}
|
|
else if ( _hwnd31 )
|
|
{
|
|
*pdwEffect = DROPEFFECT_COPY;
|
|
}
|
|
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDropTarget::DragOver ( %lx ) [ "
|
|
"%lx ]\n", this, hresult, *pdwEffect));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::DragLeave
|
|
//
|
|
// Synopsis: called when the cursor leaves the current target window
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: NOERROR
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm: Forwards the DragLeave call to the OLE-drop target
|
|
// (if it exists).
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-94 alexgo converted to PrivDragDrop protocol
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDropTarget::DragLeave()
|
|
{
|
|
HRESULT hresult = NOERROR;
|
|
static POINTL ptl = {0, 0};
|
|
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDropTarget::DragLeave ( )\n",
|
|
this));
|
|
|
|
if( _hwndOLE )
|
|
{
|
|
hresult = PrivDragDrop(_hwndOLE, DRAGOP_LEAVE, NULL, NULL, NULL,
|
|
ptl, NULL, NULL, &_hDDInfo);
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDropTarget::DragLeave ( %lx )\n",
|
|
this, hresult));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CDropTarget::Drop
|
|
//
|
|
// Synopsis: called if the user lets go of the mouse button while
|
|
// over a drop target
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pDataObject] -- the data object to use
|
|
// [grfKeyState] -- the keyboard state
|
|
// [ptl] -- the current mouse position
|
|
// [pdwEffect] -- where to return cursor effect feedback
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IDropTarget
|
|
//
|
|
// Algorithm: If there is an OLE-target available, then we first forward
|
|
// the drop request to it. If the call fails
|
|
// (or DROPEFFECT_NONE is returned), then we try the Win31
|
|
// drop by posting a WM_DROPFILES message to the Win31 target
|
|
// window (ifit exists).
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 08-Nov-94 alexgo converted to PrivDragDrop protocol
|
|
// 20-Oct-94 alexgo author
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CDropTarget::Drop( IDataObject *pDataObject,
|
|
DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect )
|
|
{
|
|
STGMEDIUM medium;
|
|
FORMATETC formatetc;
|
|
HRESULT hresult = E_FAIL;
|
|
IFBuffer DOBuffer = _pdo->GetDOBuffer();
|
|
|
|
|
|
VDATEHEAP();
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p _IN CDropTarget::Drop ( %p , %lx , ",
|
|
"%p , %lx )\n", this, pDataObject, grfKeyState, &ptl, *pdwEffect));
|
|
|
|
|
|
// we don't forward Drop calls to the target if the last effect
|
|
// is DROPEFFECT_NONE. It is important that we check for this because
|
|
// to DoDragDrop 'normally' would not call Drop if the last effect
|
|
// was DROPEFFECT_NONE. However, this target wrapper will stomp
|
|
// pdwEffect and return DROPEFFECT_COPY instead of DROPEFFECT_NONE.
|
|
|
|
if( _hwndOLE && _dwEffectLast != DROPEFFECT_NONE )
|
|
{
|
|
hresult = PrivDragDrop(_hwndOLE, DRAGOP_DROP, DOBuffer, pDataObject,
|
|
grfKeyState, ptl, pdwEffect,
|
|
GetPrivateClipboardWindow(CLIP_QUERY), &_hDDInfo);
|
|
}
|
|
else if( _hwndOLE )
|
|
{
|
|
// if the 'real' drop effect is NONE, then we need to call
|
|
// DragLeave here before going on to post the WM_DROPFILES
|
|
// message. Otherwise, the app that is both an OLE and Win31
|
|
// and has been returning DROPEFFECT_NONE will never get a
|
|
// Drop or DragLeave call (which is necessary to terminate
|
|
// the OLE2 drag protocol). Capone in particular is sensitive
|
|
// to this.
|
|
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
hresult = DragLeave();
|
|
}
|
|
|
|
|
|
if( (hresult != NOERROR || *pdwEffect == DROPEFFECT_NONE) &&
|
|
(hresult != S_FALSE) &&
|
|
(_hwnd31) )
|
|
{
|
|
medium.tymed = TYMED_NULL;
|
|
INIT_FORETC(formatetc);
|
|
formatetc.cfFormat = CF_HDROP;
|
|
formatetc.tymed = TYMED_HGLOBAL;
|
|
|
|
hresult = pDataObject->GetData(&formatetc, &medium);
|
|
|
|
if( hresult == NOERROR )
|
|
{
|
|
// we need to fixup the mouse point coordinates in the CF_HDROP
|
|
// data. The point point should be in client coordinates
|
|
// (whereas IDropTarget::Drop takes screen coordinates)
|
|
|
|
DROPFILES *pdf = (DROPFILES *)GlobalLock(medium.hGlobal);
|
|
POINT pt;
|
|
|
|
pt.x = ptl.x;
|
|
pt.y = ptl.y;
|
|
|
|
if( pdf )
|
|
{
|
|
|
|
// we also need to set the non-client (NC) flag of the
|
|
// dropfile data. This lets the app do different behaviour
|
|
// depending on whether the drop point is in the client or
|
|
// non-client area (Word6, for example, opens the file if on
|
|
// non-client area, otherwise makes a package object).
|
|
|
|
pdf->fNC = IsNCDrop(_hwnd31, pt);
|
|
|
|
if( ScreenToClient(_hwnd31, &pt) )
|
|
{
|
|
pdf->pt.x = pt.x;
|
|
pdf->pt.y = pt.y;
|
|
}
|
|
else
|
|
{
|
|
LEDebugOut((DEB_WARN, "WARNING: CF_HDROP pt coords"
|
|
"not updated!!\n"));
|
|
; // don't do anything
|
|
}
|
|
|
|
|
|
GlobalUnlock(medium.hGlobal);
|
|
}
|
|
else
|
|
{
|
|
LEDebugOut((DEB_WARN, "WARNING: OUT OF MEMORY!\n"));
|
|
; // don't do anything
|
|
}
|
|
|
|
|
|
if( PostMessage(_hwnd31, WM_DROPFILES,
|
|
(WPARAM)medium.hGlobal, 0) )
|
|
{
|
|
*pdwEffect = DROPEFFECT_COPY;
|
|
}
|
|
else
|
|
{
|
|
// PostMessage failed, so free the data
|
|
ReleaseStgMedium(&medium);
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
}
|
|
}
|
|
}
|
|
|
|
DDDebugOut((DEB_ITRACE, "%p OUT CDropTarget::Drop ( %lx ) [ %lx ]\n",
|
|
this, hresult, *pdwEffect));
|
|
|
|
return hresult;
|
|
}
|