//+------------------------------------------------------------------------- // // 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 // Note: Enable including native user APIs // for stack switching #include #pragma SEG(drag) #include #include #include #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; }