menudd.c File Reference

#include "precomp.h"
#include "callback.h"

Go to the source code of this file.

Functions
NTSTATUS	xxxClientLoadOLE (void)
NTSTATUS	xxxClientRegisterDragDrop (HWND hwnd)
NTSTATUS	xxxClientRevokeDragDrop (HWND hwnd)
void	xxxMNSetGapState (ULONG_PTR uHitArea, UINT uIndex, UINT uFlags, BOOL fSet)
BOOL	xxxMNDragOver (POINT *ppt, PMNDRAGOVERINFO pmndoi)
BOOL	xxxMNDragLeave (VOID)
void	xxxMNUpdateDraggingInfo (PMENUSTATE pMenuState, ULONG_PTR uHitArea, UINT uIndex)

---

Function Documentation

NTSTATUS xxxClientLoadOLE (  void   )

Definition at line 24 of file menudd.c. References NT_SUCCESS, NTSTATUS(), NULL, PpiCurrent, Status, and xxxUserModeCallback(). Referenced by xxxMNStartMenu(). { NTSTATUS Status; PPROCESSINFO ppiCurrent = PpiCurrent(); if (ppiCurrent->W32PF_Flags & W32PF_OLELOADED) { return STATUS_SUCCESS; } Status = xxxUserModeCallback(FI_CLIENTLOADOLE, NULL, 0, NULL, 0); if (NT_SUCCESS(Status)) { ppiCurrent->W32PF_Flags |= W32PF_OLELOADED; } return Status; }

NTSTATUS xxxClientRegisterDragDrop (  HWND  hwnd  )

Definition at line 44 of file menudd.c. References NTSTATUS(), NULL, and xxxUserModeCallback(). Referenced by xxxMNOpenHierarchy(), and xxxTrackPopupMenuEx(). { return xxxUserModeCallback(FI_CLIENTREGISTERDRAGDROP, &hwnd, sizeof(&hwnd), NULL, 0); }

NTSTATUS xxxClientRevokeDragDrop (  HWND  hwnd  )

Definition at line 53 of file menudd.c. References NTSTATUS(), NULL, and xxxUserModeCallback(). Referenced by xxxMenuWindowProc(), and xxxMNCloseHierarchy(). { return xxxUserModeCallback(FI_CLIENTREVOKEDRAGDROP, &hwnd, sizeof(&hwnd), NULL, 0); }

BOOL xxxMNDragLeave (  VOID   )

Definition at line 237 of file menudd.c. References BOOL, FALSE, tagMENUSTATE::fInDoDragDrop, LockMenuState(), MFMWFP_NOITEM, NULL, PtiCurrent, TRUE, tagMENUSTATE::uDraggingFlags, tagMENUSTATE::uDraggingHitArea, tagMENUSTATE::uDraggingIndex, UnlockMFMWFPWindow(), xxxMNSetGapState(), and xxxUnlockMenuState(). Referenced by NtUserMNDragLeave(). { PMENUSTATE pMenuState; pMenuState = PtiCurrent()->pMenuState; if (pMenuState == NULL) { RIPMSG0(RIP_WARNING, "xxxMNDragLeave: Not in menu mode"); return FALSE; } LockMenuState(pMenuState); /* * Clean up any present insertion bar state */ xxxMNSetGapState(pMenuState->uDraggingHitArea, pMenuState->uDraggingIndex, pMenuState->uDraggingFlags, FALSE); /* * Forget the last dragging area */ UnlockMFMWFPWindow(&pMenuState->uDraggingHitArea); pMenuState->uDraggingIndex = MFMWFP_NOITEM; pMenuState->uDraggingFlags = 0; /* * The DoDragDrop loop has left our window. */ pMenuState->fInDoDragDrop = FALSE; xxxUnlockMenuState(pMenuState); return TRUE; }

BOOL xxxMNDragOver (  POINT *  ppt, PMNDRAGOVERINFO  pmndoi )

Definition at line 156 of file menudd.c. References BOOL, tagMNDRAGOVERINFO::dwFlags, FALSE, tagMENUSTATE::fDragAndDrop, tagMENUSTATE::fInDoDragDrop, GetMenuStateWindow(), tagMNDRAGOVERINFO::hmenu, tagMNDRAGOVERINFO::hwndNotify, LockMenuState(), MFMWFP_NOITEM, MFMWFP_OFFMENU, NULL, PMNDRAGOVERINFO, PtiCurrent, PtoH, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndNotify, ThreadLockAlways, ThreadUnlock, TRUE, tagMENUSTATE::uDraggingFlags, tagMENUSTATE::uDraggingHitArea, tagMENUSTATE::uDraggingIndex, tagMNDRAGOVERINFO::uItemIndex, xxxCallHandleMenuMessages(), and xxxUnlockMenuState(). Referenced by NtUserMNDragOver(). { BOOL fRet; PMENUSTATE pMenuState; PWND pwnd; PPOPUPMENU ppopup; TL tlpwnd; /* * OLE always calls us in context (proxy/marshall stuff). So the * current thread must be in menu mode */ pMenuState = PtiCurrent()->pMenuState; if (pMenuState == NULL) { RIPMSG0(RIP_WARNING, "xxxMNDragOver: Not in menu mode"); return FALSE; } /* * This must be a drag and drop menu */ UserAssert(pMenuState->fDragAndDrop); /* * We might have not initiated this DoDragDrop so make sure * the internal flag is set. */ pMenuState->fInDoDragDrop = TRUE; /* * Get a window to call xxxCallHandleMenuMessages */ pwnd = GetMenuStateWindow(pMenuState); if (pwnd == NULL) { RIPMSG0(RIP_WARNING, "xxxMNDragOver: Failed to get MenuStateWindow"); return FALSE; } /* * We need this after calling back, so lock it */ LockMenuState(pMenuState); /* * Update the selection and the dragging info * Use WM_NCMOUSEMOVE because the point is in screen coordinates already. */ ThreadLockAlways(pwnd, &tlpwnd); xxxCallHandleMenuMessages(pMenuState, pwnd, WM_NCMOUSEMOVE, 0, MAKELONG(ppt->x, ppt->y)); ThreadUnlock(&tlpwnd); /* * If we're on a popup, propagate the hit test info */ if (pMenuState->uDraggingHitArea != MFMWFP_OFFMENU) { ppopup = ((PMENUWND)pMenuState->uDraggingHitArea)->ppopupmenu; pmndoi->hmenu = PtoH(ppopup->spmenu); pmndoi->uItemIndex = pMenuState->uDraggingIndex; pmndoi->hwndNotify = PtoH(ppopup->spwndNotify); pmndoi->dwFlags = pMenuState->uDraggingFlags; /* * Bottom gap of item N corresponds to N+1 gap */ if (pmndoi->dwFlags & MNGOF_BOTTOMGAP) { UserAssert(pmndoi->uItemIndex != MFMWFP_NOITEM); (pmndoi->uItemIndex)++; } fRet = TRUE; } else { fRet = FALSE; } xxxUnlockMenuState(pMenuState); return fRet;; }

void xxxMNSetGapState (  ULONG_PTR  uHitArea, UINT  uIndex, UINT  uFlags, BOOL  fSet )

Definition at line 63 of file menudd.c. References ClearMFS, tagITEM::cxItem, tagITEM::cyItem, IsMFMWFPWindow(), MNGetpItem(), MNGetToppItem(), NULL, SetMFS, tagPOPUPMENU::spmenu, SYSMET, ThreadLockAlways, ThreadUnlock, TRUE, tagITEM::xItem, xxxInvalidateRect(), and tagITEM::yItem. Referenced by xxxInsertMenuItem(), xxxMNDragLeave(), and xxxMNUpdateDraggingInfo(). { int yTop; PITEM pItem, pItemGap; PPOPUPMENU ppopup; RECT rc; TL tlHitArea; /* * Bail if there is nothing to do. */ if (!(uFlags & MNGOF_GAP) || !IsMFMWFPWindow(uHitArea)) { return; } ppopup = ((PMENUWND)uHitArea)->ppopupmenu; pItem = MNGetpItem(ppopup, uIndex); /* * The menu window might be destroyed by now so pItem could be NULL. */ if (pItem == NULL) { return; } /* * Mark the item and set the rectangle we need to redraw. * Drawing/erasing the insertion bar unhilites/hiltes the * item, so pItem needs to be redrawn completely. In additon, * we need to draw the insertion bar in the next/previous item. */ rc.left = pItem->xItem; rc.right = pItem->xItem + pItem->cxItem; rc.top = pItem->yItem; rc.bottom = pItem->yItem + pItem->cyItem; if (uFlags & MNGOF_TOPGAP) { pItemGap = MNGetpItem(ppopup, uIndex - 1); if (fSet) { SetMFS(pItem, MFS_TOPGAPDROP); if (pItemGap != NULL) { SetMFS(pItemGap, MFS_BOTTOMGAPDROP); } } else { ClearMFS(pItem, MFS_TOPGAPDROP); if (pItemGap != NULL) { ClearMFS(pItemGap, MFS_BOTTOMGAPDROP); } } if (pItemGap != NULL) { rc.top -= SYSMET(CYDRAG); } } else { pItemGap = MNGetpItem(ppopup, uIndex + 1); if (fSet) { SetMFS(pItem, MFS_BOTTOMGAPDROP); if (pItemGap != NULL) { SetMFS(pItemGap, MFS_TOPGAPDROP); } } else { ClearMFS(pItem, MFS_BOTTOMGAPDROP); if (pItemGap != NULL) { ClearMFS(pItemGap, MFS_TOPGAPDROP); } } if (pItemGap != NULL) { rc.bottom += SYSMET(CYDRAG); } } /* * Adjust to "menu" coordinates (for scrollable menus) */ yTop = MNGetToppItem(ppopup->spmenu)->yItem; rc.top -= yTop; rc.bottom -= yTop; /* * Invalidate this rect to repaint it later */ ThreadLockAlways((PWND)uHitArea, &tlHitArea); xxxInvalidateRect((PWND)uHitArea, &rc, TRUE); ThreadUnlock(&tlHitArea); }

void xxxMNUpdateDraggingInfo (  PMENUSTATE  pMenuState, ULONG_PTR  uHitArea, UINT  uIndex )

Definition at line 279 of file menudd.c. References BOOL, tagITEM::cyItem, FALSE, IsMFMWFPWindow(), LockMFMWFPWindow(), MFMWFP_NOITEM, MFMWFP_OFFMENU, MNGetpItem(), MNGetToppItem(), NULL, tagMENUSTATE::ptMouseLast, tagPOPUPMENU::spmenu, SYSMET, ThreadLock, ThreadUnlock, TRUE, tagMENUSTATE::uDraggingFlags, tagMENUSTATE::uDraggingHitArea, tagMENUSTATE::uDraggingIndex, UINT, xxxMNSetGapState(), and tagITEM::yItem. Referenced by xxxMNMouseMove(). { BOOL fCross; int y, iIndexDelta; PITEM pItem; PPOPUPMENU ppopup; TL tlLastHitArea; ULONG_PTR uLastHitArea; UINT uLastIndex, uLastFlags; /* * Remember current dragging area so we can detected when * crossing item/gap boundries. */ UserAssert((pMenuState->uDraggingHitArea == 0) || IsMFMWFPWindow(pMenuState->uDraggingHitArea)); ThreadLock((PWND)pMenuState->uDraggingHitArea, &tlLastHitArea); uLastHitArea = pMenuState->uDraggingHitArea; uLastIndex = pMenuState->uDraggingIndex; uLastFlags = pMenuState->uDraggingFlags & MNGOF_GAP; /* * Store new dragging area. */ LockMFMWFPWindow(&pMenuState->uDraggingHitArea, uHitArea); pMenuState->uDraggingIndex = uIndex; /* * If we're not on a popup, done. */ if (!IsMFMWFPWindow(pMenuState->uDraggingHitArea)) { pMenuState->uDraggingHitArea = MFMWFP_OFFMENU; pMenuState->uDraggingIndex = MFMWFP_NOITEM; ThreadUnlock(&tlLastHitArea); return; } /* * Get the popup and item we're on */ ppopup = ((PMENUWND)pMenuState->uDraggingHitArea)->ppopupmenu; pItem = MNGetpItem(ppopup, pMenuState->uDraggingIndex); /* * Find out if we're on the gap, that is, the "virtual" space * between items. Some apps want to distinguish between a drop * ON the item and a drop BEFORE/AFTER the item; there is no * actual space between items so we define a virtual gap * */ pMenuState->uDraggingFlags = 0; if (pItem != NULL) { /* * Map the point to client coordinates and then to "menu" * coordinates (to take care of scrollable menus) */ y = pMenuState->ptMouseLast.y; y -= ((PWND)pMenuState->uDraggingHitArea)->rcClient.top; y += MNGetToppItem(ppopup->spmenu)->yItem; #if DBG if ((y < (int)pItem->yItem) || (y > (int)(pItem->yItem + pItem->cyItem))) { RIPMSG4(RIP_ERROR, "xxxMNUpdateDraggingInfo: y Point not in selected item. " "pwnd:%#lx ppopup:%#lx Index:%#lx pItem:%#lx", pMenuState->uDraggingHitArea, ppopup, pMenuState->uDraggingIndex, pItem); } #endif /* * Top/bottom gap check */ if (y <= (int)(pItem->yItem + SYSMET(CYDRAG))) { pMenuState->uDraggingFlags = MNGOF_TOPGAP; } else if (y >= (int)(pItem->yItem + pItem->cyItem - SYSMET(CYDRAG))) { pMenuState->uDraggingFlags = MNGOF_BOTTOMGAP; } } /* * Have we crossed an item/gap boundary? * We don't cross a boundary when we move from the bottom * of an item to the top of the next, or, from the top * of an item to the bottom of the previous. * (Item N is on top of and previous to item N+1). */ fCross = (uLastHitArea != pMenuState->uDraggingHitArea); if (!fCross) { iIndexDelta = (int)pMenuState->uDraggingIndex - (int)uLastIndex; switch (iIndexDelta) { case 0: /* * We're on the same item. */ fCross = (uLastFlags != pMenuState->uDraggingFlags); break; case 1: /* * We've moved to the next item */ fCross = !((pMenuState->uDraggingFlags == MNGOF_TOPGAP) && (uLastFlags == MNGOF_BOTTOMGAP)); break; case -1: /* * We've moved to the previous item */ fCross = !((pMenuState->uDraggingFlags == MNGOF_BOTTOMGAP) && (uLastFlags == MNGOF_TOPGAP)); break; default: /* * We've skipped more than one item. */ fCross = TRUE; } } if (fCross) { pMenuState->uDraggingFlags |= MNGOF_CROSSBOUNDARY; /* * Update the insertion bar state. */ xxxMNSetGapState(uLastHitArea, uLastIndex, uLastFlags, FALSE); xxxMNSetGapState(pMenuState->uDraggingHitArea, pMenuState->uDraggingIndex, pMenuState->uDraggingFlags, TRUE); } ThreadUnlock(&tlLastHitArea); }

---