BOOL COleDropTarget::Register(CWnd* pWnd)
{
ASSERT_VALID(this);
ASSERT(m_hWnd == NULL); // registering drop target twice?
ASSERT_VALID(pWnd);
LPUNKNOWN lpUnknown = (LPUNKNOWN)GetInterface(&IID_IUnknown);
ASSERT(lpUnknown != NULL);
// the object must be locked externally to keep LRPC connections alive
if (CoLockObjectExternal(lpUnknown, TRUE, FALSE) != S_OK)
return FALSE;
// connect the HWND to the IDropTarget implementation
if (RegisterDragDrop(pWnd->m_hWnd,
(LPDROPTARGET)GetInterface(&IID_IDropTarget)) != S_OK)
{
CoLockObjectExternal(lpUnknown, FALSE, FALSE);
return FALSE;
}
// connect internal data
m_hWnd = pWnd->m_hWnd;
ASSERT(pWnd->m_pDropTarget == NULL);
pWnd->m_pDropTarget = this;
return TRUE;
}
bool LLDragDropWin32::init( HWND hWnd )
{
if ( NOERROR != OleInitialize( NULL ) )
return FALSE;
mDropTarget = new LLDragDropWin32Target( hWnd );
if ( mDropTarget )
{
HRESULT result = CoLockObjectExternal( mDropTarget, TRUE, FALSE );
if ( S_OK == result )
{
result = RegisterDragDrop( hWnd, mDropTarget );
if ( S_OK != result )
{
// RegisterDragDrop failed
return false;
};
// all ok
mDropWindowHandle = hWnd;
}
else
{
// Unable to lock OLE object
return false;
};
};
// success
return true;
}
void MCStack::stop_externals()
{
Boolean oldlock = MClockmessages;
MClockmessages = True;
MCPlayer *tptr = MCplayers;
while (tptr != NULL)
{
if (tptr->getstack() == this)
{
if (tptr->playstop())
tptr = MCplayers; // was removed, start search over
}
else
tptr = tptr->getnextplayer();
}
if (!MCnoui && window != DNULL)
{
RevokeDragDrop((HWND)window->handle.window);
CoLockObjectExternal(droptarget, FALSE, TRUE);
droptarget->setstack(NULL);
delete droptarget;
droptarget = nil;
}
destroywindowshape();
MClockmessages = oldlock;
unloadexternals();
}
void QWindowsWindow::registerDropSite()
{
if (m_data.hwnd && !m_dropTarget) {
m_dropTarget = new QWindowsOleDropTarget(window());
RegisterDragDrop(m_data.hwnd, m_dropTarget);
CoLockObjectExternal(m_dropTarget, true, true);
}
}
void QWindowsWindow::unregisterDropSite()
{
if (m_data.hwnd && m_dropTarget) {
m_dropTarget->Release();
CoLockObjectExternal(m_dropTarget, false, true);
RevokeDragDrop(m_data.hwnd);
m_dropTarget = 0;
}
}
void CEdit::DoDragDrop()
{
int nStartCol, nStartRow, nEndCol, nEndRow;
ASSERT( !m_Selection.IsEmpty() );
// Drag and drop does not currently support column selection. Convert
// the column selection to a paragraph selection as a fallback.
if ( m_Selection.IsColumnSel() )
{
m_Selection.EnableColumnSel( FALSE );
DamageSelection( TRUE );
}
m_Selection.GetNormalizedBufferSelection( nStartCol, nStartRow, nEndCol, nEndRow );
HGLOBAL hGlobal;
if ( m_Buffer.GetText( nStartRow, nStartCol, nEndRow, nEndCol, hGlobal, FALSE ) )
{
CDataObject DataObj( hGlobal );
CDropSource DropSource;
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) ( LPVOID ) &DataObj, TRUE, FALSE ) ) );
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) &DropSource, TRUE, FALSE ) ) );
DWORD dwEffect;
m_bDroppedHere = FALSE;
if ( ::DoDragDrop( &DataObj, &DropSource, DROPEFFECT_COPY | ( m_Buffer.IsReadOnly() ? 0 : DROPEFFECT_MOVE ), &dwEffect ) == DRAGDROP_S_DROP )
{
// text was dropped successfully -- The OnDrop() method of the drop target freed the memory
// because CDataObject::GetData() set pUnkForRelease = NULL.
// if moved text to another window, delete the selection here
if ( !m_bDroppedHere && HAS_FLAG( dwEffect, DROPEFFECT_MOVE ) )
{
DeleteSelection( FALSE, FALSE );
}
}
else
{
// cleanup clip data since target window didn't drop the text
GlobalFree( hGlobal );
}
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) &DropSource, FALSE, TRUE ) ) );
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) ( LPVOID ) &DataObj, FALSE, TRUE ) ) );
DataObj.Release();
}
SetMode( eIdle );
}
void LLDragDropWin32::reset()
{
if ( mDropTarget )
{
RevokeDragDrop( mDropWindowHandle );
CoLockObjectExternal( mDropTarget, FALSE, TRUE );
mDropTarget->Release();
};
OleUninitialize();
}
void MCStack::start_externals()
{
loadexternals();
if (!MCnoui && window != DNULL)
{
droptarget = new CDropTarget;
droptarget->setstack(this);
CoLockObjectExternal(droptarget, TRUE, TRUE);
RegisterDragDrop((HWND)window->handle.window, droptarget);
}
}
/***********************************************
Enables / disables drag and drop for widget w
************************************************/
void qt_olednd_unregister( QWidget* widget, QOleDropTarget *dst )
{
#ifdef DEBUG_QDND_WIN
qDebug("qt_olednd_unregister( %p ) winID: %08x", widget, widget ? widget->winId() : 0 );
#endif
dst->releaseQt();
dst->Release();
#ifndef Q_OS_TEMP
CoLockObjectExternal( dst, false, true );
RevokeDragDrop( widget->winId() );
#endif
}
QOleDropTarget* qt_olednd_register( QWidget* widget )
{
#ifdef DEBUG_QDND_WIN
qDebug("qt_olednd_register( %p ) winID: %08x", widget, widget ? widget->winId() : 0 );
#endif
QOleDropTarget * dst = new QOleDropTarget( widget );
#ifndef Q_OS_TEMP
HRESULT ret = RegisterDragDrop( widget->winId(), dst );
#ifdef DEBUG_QDND_WIN
qDebug("ret RegisterDragDrop = %x", ret );
#endif
CoLockObjectExternal( dst, true, true );
#endif
return dst;
}
void COleDropTarget::Revoke()
{
ASSERT_VALID(this);
ASSERT(m_lpDataObject == NULL);
if (m_hWnd == NULL)
{
ASSERT(m_nTimerID == 0xffff);
return;
}
// disconnect from OLE
RevokeDragDrop(m_hWnd);
CoLockObjectExternal((LPUNKNOWN)GetInterface(&IID_IUnknown), FALSE, TRUE);
// disconnect internal data
CWnd::FromHandle(m_hWnd)->m_pDropTarget = NULL;
m_hWnd = NULL;
}
static BOOL CALLBACK
sSplitKeyDlgProc (HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PSPLITKEYSTRUCT psks;
CHAR sz[8];
NMHDR* pnmh;
UINT u;
switch (uMsg) {
case WM_INITDIALOG :
{
CHAR szTitle[kPGPMaxUserIDSize + 32];
// save address of struct
SetWindowLong (hDlg, GWL_USERDATA, lParam);
psks = (PSPLITKEYSTRUCT)lParam;
psks->hwndDlg = hDlg;
// if we have a function to call to add hwnd to list, then call it
if (psks->pKM->lpfnHwndListFunc)
(psks->pKM->lpfnHwndListFunc)(hDlg, TRUE, NULL, NULL);
// initialize shareholder list
psks->hwndList = GetDlgItem (hDlg, IDC_SHAREHOLDERS);
sInitKeyList (psks);
// initialize name of key to split
SetDlgItemText (hDlg, IDC_KEYTOSPLIT, psks->szUserIDToSplit);
LoadString (g_hInst, IDS_SPLITKEYTITLE, szTitle, sizeof(szTitle));
lstrcat (szTitle, psks->szUserIDToSplit);
SetWindowText (hDlg, szTitle);
// limit number of shares
SendDlgItemMessage (hDlg, IDC_SHARES, EM_SETLIMITTEXT,
(WPARAM)MAX_SHARES_LEN, 0);
SendDlgItemMessage (hDlg, IDC_THRESHOLD, EM_SETLIMITTEXT,
(WPARAM)MAX_SHARES_LEN, 0);
// initialize spin controls
SendDlgItemMessage (hDlg, IDC_SHARESSPIN, UDM_SETRANGE,
0, (LPARAM)MAKELONG (MAX_SHARES, 1));
SetDlgItemText (hDlg, IDC_SHARES, "");
EnableWindow (GetDlgItem (hDlg, IDC_SHARES), FALSE);
SendDlgItemMessage (hDlg, IDC_THRESHOLDSPIN, UDM_SETRANGE,
0, (LPARAM)MAKELONG (MAX_SHARES, 1));
SendDlgItemMessage (hDlg, IDC_THRESHOLDSPIN, UDM_SETPOS,
0, (LPARAM)MAKELONG (psks->uThreshold, 0));
// initialize total number of shares
SetDlgItemInt (hDlg, IDC_TOTALSHARES, psks->uTotalShares, FALSE);
// "split key" and "remove" buttons initially disabled
EnableWindow (GetDlgItem (hDlg, IDC_REMOVESHAREHOLDER), FALSE);
EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
// initialize drag/drop
psks->pDropTarget = KMCreateDropTarget (psks->hwndList, NULL, psks);
CoLockObjectExternal ((IUnknown*)psks->pDropTarget, TRUE, TRUE);
RegisterDragDrop (psks->hwndList, psks->pDropTarget);
KMEnableDropTarget (psks->pDropTarget, TRUE);
return TRUE;
}
case WM_HELP:
{
WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile,
HELP_WM_HELP, (DWORD) (LPSTR) aSplitIds);
break;
}
case WM_CONTEXTMENU:
{
WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU,
(DWORD) (LPVOID) aSplitIds);
break;
}
case WM_NOTIFY :
pnmh = (NMHDR*)lParam;
switch (pnmh->code) {
case NM_CLICK :
case LVN_KEYDOWN :
if (pnmh->idFrom == IDC_SHAREHOLDERS) {
INT iIndex;
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
iIndex =
ListView_GetNextItem (psks->hwndList, -1, LVNI_SELECTED);
if (iIndex > -1) {
LV_ITEM lvI;
PSHAREHOLDERSTRUCT pshs;
lvI.mask = LVIF_PARAM;
lvI.iItem = iIndex;
lvI.iSubItem = 0;
ListView_GetItem(psks->hwndList, &lvI);
pshs = (PSHAREHOLDERSTRUCT)lvI.lParam;
psks->pshsCurrent = pshs;
psks->iIndexCurrent = iIndex;
SetDlgItemText (hDlg, IDC_CURRENTSHAREHOLDER,
pshs->szUserID);
SendDlgItemMessage (hDlg, IDC_SHARESSPIN, UDM_SETPOS,
0, (LPARAM)MAKELONG (pshs->uShares, 0));
EnableWindow (GetDlgItem (hDlg, IDC_SHARES), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_SHARESSPIN), TRUE);
EnableWindow (
GetDlgItem (hDlg, IDC_REMOVESHAREHOLDER), TRUE);
}
else {
psks->iIndexCurrent = -1;
psks->pshsCurrent = NULL;
SetDlgItemText (hDlg, IDC_SHARES, "");
SetDlgItemText (hDlg, IDC_CURRENTSHAREHOLDER, "");
EnableWindow (GetDlgItem (hDlg, IDC_SHARES), FALSE);
EnableWindow (
GetDlgItem (hDlg, IDC_REMOVESHAREHOLDER), FALSE);
}
}
break;
}
break;
case WM_DESTROY :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
// terminate drag/drop
RevokeDragDrop (psks->hwndList);
KMReleaseDropTarget (psks->pDropTarget);
CoLockObjectExternal ((IUnknown*)psks->pDropTarget, FALSE, TRUE);
// call function to remove hwnd from list
if (psks->pKM->lpfnHwndListFunc)
(psks->pKM->lpfnHwndListFunc)(hDlg, FALSE, NULL, NULL);
// destroy data objects
ImageList_Destroy (psks->hIml);
sDestroyShareHolders (psks);
sDestroySplitKeyStruct (psks);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL :
DestroyWindow (hDlg);
break;
case IDOK :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
EnableWindow (psks->pKM->hWndParent, FALSE);
if (sSplitKey (psks))
{
EnableWindow (psks->pKM->hWndParent, TRUE);
DestroyWindow (hDlg);
}
else
EnableWindow (psks->pKM->hWndParent, TRUE);
break;
case IDHELP :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
WinHelp (hDlg, psks->pKM->szHelpFile, HELP_CONTEXT,
IDH_PGPCLSPLIT_SPLITDIALOG);
break;
case IDC_ADDSHAREHOLDER :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
EnableWindow (psks->pKM->hWndParent, FALSE);
sAddShareHolderToList (hDlg, psks);
EnableWindow (psks->pKM->hWndParent, TRUE);
SetFocus (GetDlgItem (hDlg, IDC_ADDSHAREHOLDER));
break;
case IDC_REMOVESHAREHOLDER :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
sRemoveShareHolderFromList (hDlg, psks);
psks->iIndexCurrent = -1;
psks->pshsCurrent = NULL;
SetDlgItemText (hDlg, IDC_SHARES, "");
SetDlgItemText (hDlg, IDC_CURRENTSHAREHOLDER, "");
EnableWindow (GetDlgItem (hDlg, IDC_SHARES), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_REMOVESHAREHOLDER), FALSE);
break;
case IDC_THRESHOLD :
switch (HIWORD(wParam)) {
case EN_CHANGE :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
if (psks) {
GetDlgItemText (hDlg, IDC_THRESHOLD, sz, sizeof(sz));
if (lstrcmp (sz, "0")) {
UINT u =
GetDlgItemInt (hDlg, IDC_THRESHOLD, NULL, FALSE);
if (u != 0) {
psks->uThreshold = u;
if (psks->uTotalShares >= psks->uThreshold)
EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);
else
EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
}
}
}
break;
case EN_KILLFOCUS :
u = GetDlgItemInt (hDlg, IDC_THRESHOLD, NULL, FALSE);
if (u == 0) u = 1;
SetDlgItemInt (hDlg, IDC_THRESHOLD, u, FALSE);
break;
}
break;
case IDC_SHARES :
psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
switch (HIWORD(wParam)) {
case EN_CHANGE :
if (psks) {
PSHAREHOLDERSTRUCT pshs;
GetDlgItemText (hDlg, IDC_SHARES, sz, sizeof(sz));
pshs = psks->pshsCurrent;
if (pshs && (lstrcmp (sz, "0"))) {
UINT u =
GetDlgItemInt (hDlg, IDC_SHARES, NULL, FALSE);
if (u != 0) {
psks->uTotalShares -= pshs->uShares;
pshs->uShares = u;
psks->uTotalShares += pshs->uShares;
SetDlgItemInt (hDlg, IDC_TOTALSHARES,
psks->uTotalShares, FALSE);
wsprintf (sz, "%i", pshs->uShares);
ListView_SetItemText (psks->hwndList,
psks->iIndexCurrent, 1, sz);
if ((psks->uTotalShares >= psks->uThreshold) &&
(psks->uTotalShares <= MAX_TOTAL_SHARES))
EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);
else
EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
}
}
}
break;
case EN_KILLFOCUS :
u = GetDlgItemInt (hDlg, IDC_SHARES, NULL, FALSE);
if (u == 0) {
u = 1;
MessageBeep (MB_ICONASTERISK);
}
else if (psks->uTotalShares-psks->pshsCurrent->uShares+u >
MAX_TOTAL_SHARES) {
u = MAX_TOTAL_SHARES - (psks->uTotalShares -
psks->pshsCurrent->uShares);
MessageBeep (MB_ICONASTERISK);
}
SetDlgItemInt (hDlg, IDC_SHARES, u, FALSE);
break;
}
break;
}
return TRUE;
}
return FALSE;
}
void Win32DropTarget::unregisterWithOS()
{
RevokeDragDrop(mHWnd);
CoLockObjectExternal(this, FALSE, FALSE);
}
IFACEMETHODIMP LockServer(BOOL fLock) final
{
CoLockObjectExternal(this, fLock, TRUE);
return S_OK;
}
// MW-2006-03-20: Bug 3316 - There seems absolutely no way of preventing flicker
// when transitioning from no alpha to alpha. Therefore, we need to create a new
// window opened *behind* the current window; show it; redraw it; then delete
// the existing window.
void MCStack::setopacity(uint1 p_level)
{
// If the stack is not ours to open, then we do nothing ('runtime' mode/remoteable
// window).
if (!MCModeMakeLocalWindows())
return;
// Do nothing if not NT
if (MCmajorosversion < 0x0500)
return;
if (m_window_shape != NULL && !m_window_shape -> is_sharp)
composite();
else if (window != NULL)
{
HWND t_old_window;
t_old_window = NULL;
DWORD t_old_long, t_new_long;
t_old_long = GetWindowLong((HWND)window -> handle . window, GWL_EXSTYLE);
if (p_level == 255)
t_new_long = t_old_long & ~WS_EX_LAYERED;
else
t_new_long = t_old_long | WS_EX_LAYERED;
if (t_new_long != t_old_long)
{
if (IsWindowVisible((HWND)window -> handle . window) && (t_new_long & WS_EX_LAYERED) != 0)
t_old_window = (HWND)window -> handle . window;
else
SetWindowLong((HWND)window -> handle . window, GWL_EXSTYLE, t_new_long);
}
if (t_old_window != NULL)
{
uint32_t t_style, t_ex_style;
getstyle(t_style, t_ex_style);
// MW-2006-07-27: [[ Bug 3690 ]] - Make sure layered attribute is set if we need it
t_ex_style = (t_ex_style & ~WS_EX_LAYERED) | (t_new_long & WS_EX_LAYERED);
RECT t_rect;
t_rect = getwrect(rect, t_style, t_ex_style);
Bool t_is_xp_menu;
t_is_xp_menu = (mode == WM_PULLDOWN || mode == WM_POPUP || mode == WM_CASCADE) && (MCcurtheme && MCcurtheme->getthemeid() == LF_NATIVEWIN);
if (!t_is_xp_menu && mode < WM_PULLDOWN)
window -> handle . window = (MCSysWindowHandle)CreateWindowExW(t_ex_style, MC_WIN_CLASS_NAME_W, WideCString(getname_cstring()), t_style | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, t_rect . left, t_rect . top, t_rect . right - t_rect . left, t_rect . bottom - t_rect . top, NULL, NULL, MChInst, NULL);
else
window -> handle . window = (MCSysWindowHandle)CreateWindowExA(t_ex_style, t_is_xp_menu ? MC_MENU_WIN_CLASS_NAME : mode >= WM_PULLDOWN ? MC_POPUP_WIN_CLASS_NAME : MC_WIN_CLASS_NAME, getname_cstring(), t_style | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, t_rect . left, t_rect . top, t_rect . right - t_rect . left, t_rect . bottom - t_rect . top, NULL, NULL, MChInst, NULL);
// MW-2010-10-22: [[ Bug 8151 ]] Make sure we update the title string.
if (titlestring != nil)
MCscreen -> setname(window, titlestring);
SetWindowLongA((HWND)window->handle.window, GWL_USERDATA, mode);
if (flags & F_DECORATIONS && !(decorations & WD_SHAPE) && !(decorations & WD_CLOSE))
EnableMenuItem(GetSystemMenu((HWND)window->handle.window, False), SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
if (m_window_shape != nil && m_window_shape -> is_sharp)
{
MCRegionRef t_region;
t_region = (MCRegionRef)m_window_shape -> handle;
MCRegionOffset(t_region, rect . x - t_rect . left, rect . y - t_rect . top);
MCRegionSetAsWindowShape(t_region, window->handle.window);
// The window now owns the region.
m_window_shape -> handle = nil;
}
RevokeDragDrop(t_old_window);
CoLockObjectExternal(droptarget, FALSE, TRUE);
droptarget -> setstack(NULL);
droptarget -> setstack(this);
CoLockObjectExternal(droptarget, TRUE, TRUE);
RegisterDragDrop((HWND)window -> handle . window, droptarget);
SetWindowPos((HWND)window -> handle . window, t_old_window, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_SHOWWINDOW);
MCPlayer *t_player;
for(t_player = MCplayers; t_player != NULL; t_player = t_player -> getnextplayer())
if (t_player -> getstack() == this)
t_player -> changewindow((MCSysWindowHandle)t_old_window);
}
if (p_level < 255)
SetLayeredWindowAttributes((HWND)window -> handle . window, 0, p_level, LWA_ALPHA);
if (t_old_window != NULL)
{
RedrawWindow((HWND)window -> handle . window, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATENOW);
DestroyWindow(t_old_window);
}
}
}
void Win32DropTarget::registerWithOS()
{
CoLockObjectExternal(this, TRUE, FALSE);
RegisterDragDrop(mHWnd, this);
}
CDataObject::~CDataObject()
{
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) &m_XEnumFORMATETC, FALSE, TRUE ) ) );
}
STDMETHODIMP
tLuaCOMClassFactory::LockServer(BOOL fLock)
{
CoLockObjectExternal(object, fLock, TRUE);
return NOERROR;
}
CDataObject::CDataObject( HGLOBAL hGlobal )
{
m_hGlobal = hGlobal;
m_XEnumFORMATETC.SetOuterUnknown( this );
VERIFY( SUCCEEDED( CoLockObjectExternal( ( LPUNKNOWN ) ( LPVOID ) &m_XEnumFORMATETC, TRUE, FALSE ) ) );
}
