|
|
#include "ctlspriv.h"
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
#include <shsemip.h> // SEN_* notifications
#include <commdlg.h> // CDN_* notifications
// Miscellaneous hackery needed in order to include shlobjp.h
#define CONTROLINFO OAIDL_CONTROLINFO
#define LPCONTROLINFO LPOAIDL_CONTROLINFO
#include <shlobj.h>
#include <shlobjp.h> // NMVIEWFOLDER structure
#undef CONTROLINFO
#undef LPCONTROLINFO
//
// Helper function for WOW on NT.
//
// WOW needs to know the size of the notify structure associated with a
// notification. If a 32-bit window has been subclassed by a 16-bit app,
// WOW needs to copy the notify structure into 16-bit space, and then when
// the 16-bit guy does a CallWindowProc(), they have to copy it back into
// 32-bit space. Without the size information, you fault on the
// 32-bit side because the notify structure is incomplete.
//
// Some notifications have multiple structures associated with them, in
// which case you should return the largest possible valid structure.
//
STDAPI_(UINT) WOWGetNotifySize(UINT code){ switch (code) {
// Generic comctl32 notifications
case NM_OUTOFMEMORY: return sizeof(NMHDR); // not used
case NM_CLICK: return max(max( sizeof(NMHDR), // tab, treeview
sizeof(NMCLICK)), // toolbar, statusbar
sizeof(NMITEMACTIVATE)); // listview
case NM_DBLCLK: return max(max( sizeof(NMHDR), // tab, treeview
sizeof(NMCLICK)), // toolbar, statusbar
sizeof(NMITEMACTIVATE)); // listview
case NM_RETURN: return sizeof(NMHDR);
case NM_RCLICK: return max(max( sizeof(NMHDR), // header, listview report mode, treeview
sizeof(NMCLICK)), // toolbar, statusbar
sizeof(NMITEMACTIVATE)); // listview icon mode
case NM_RDBLCLK: return max(max( sizeof(NMHDR), // treeview
sizeof(NMCLICK)), // toolbar, statusbar
sizeof(NMITEMACTIVATE)); // listview
case NM_SETFOCUS: return sizeof(NMHDR); case NM_KILLFOCUS: return sizeof(NMHDR); case NM_STARTWAIT: return sizeof(NMHDR); // not used
case NM_ENDWAIT: return sizeof(NMHDR); // not used
case NM_BTNCLK: return sizeof(NMHDR); // not used
case NM_CUSTOMDRAW: return sizeof(NMCUSTOMDRAW); case NM_HOVER: return sizeof(NMHDR); case NM_NCHITTEST: return sizeof(NMMOUSE); case NM_KEYDOWN: return sizeof(NMKEY); case NM_RELEASEDCAPTURE: return sizeof(NMHDR); case NM_SETCURSOR: return sizeof(NMMOUSE); case NM_CHAR: return sizeof(NMCHAR); case NM_TOOLTIPSCREATED: return sizeof(NMTOOLTIPSCREATED); case NM_LDOWN: return sizeof(NMCLICK); case NM_RDOWN: return sizeof(NMCLICK); // not used
// Listview notifications
case LVN_ITEMCHANGING: return sizeof(NMLISTVIEW); case LVN_ITEMCHANGED: return sizeof(NMLISTVIEW); case LVN_INSERTITEM: return sizeof(NMLISTVIEW); case LVN_DELETEITEM: return sizeof(NMLISTVIEW); case LVN_DELETEALLITEMS: return sizeof(NMLISTVIEW); case LVN_BEGINLABELEDITA: return sizeof(NMLVDISPINFOA); case LVN_BEGINLABELEDITW: return sizeof(NMLVDISPINFOW); case LVN_ENDLABELEDITA: return sizeof(NMLVDISPINFOA); case LVN_ENDLABELEDITW: return sizeof(NMLVDISPINFOW); case LVN_COLUMNCLICK: return sizeof(NMLISTVIEW); case LVN_BEGINDRAG: return sizeof(NMITEMACTIVATE); case LVN_BEGINRDRAG: return sizeof(NMITEMACTIVATE); // not used
case LVN_ENDDRAG: return sizeof(NMITEMACTIVATE); // not used
case LVN_ENDRDRAG: return sizeof(NMITEMACTIVATE); // not used
case LVN_ODCACHEHINT: return sizeof(NMLVCACHEHINT); case LVN_ODFINDITEMA: return sizeof(NMLVFINDITEMA); case LVN_ODFINDITEMW: return sizeof(NMLVFINDITEMW); case LVN_ITEMACTIVATE: return sizeof(NMITEMACTIVATE); case LVN_ODSTATECHANGED: return sizeof(NMLVODSTATECHANGE);// case LVN_PEN: // Pen Windows slackers
case LVN_HOTTRACK: return sizeof(NMLISTVIEW); case LVN_GETDISPINFOA: return sizeof(NMLVDISPINFOA); case LVN_GETDISPINFOW: return sizeof(NMLVDISPINFOW); case LVN_SETDISPINFOA: return sizeof(NMLVDISPINFOA); case LVN_SETDISPINFOW: return sizeof(NMLVDISPINFOW); case LVN_KEYDOWN: return sizeof(NMLVKEYDOWN); case LVN_MARQUEEBEGIN: return sizeof(NMITEMACTIVATE); case LVN_GETINFOTIPA: return sizeof(NMLVGETINFOTIPA); case LVN_GETINFOTIPW: return sizeof(NMLVGETINFOTIPW); case LVN_GETEMPTYTEXTA: return sizeof(NMLVDISPINFOA); case LVN_GETEMPTYTEXTW: return sizeof(NMLVDISPINFOW); case LVN_INCREMENTALSEARCHA:return sizeof(NMLVFINDITEMA); case LVN_INCREMENTALSEARCHW:return sizeof(NMLVFINDITEMW);
// Property sheet notifications
case PSN_SETACTIVE: return sizeof(PSHNOTIFY); case PSN_KILLACTIVE: return sizeof(PSHNOTIFY); case PSN_APPLY: return sizeof(PSHNOTIFY); case PSN_RESET: return sizeof(PSHNOTIFY); case PSN_HASHELP: return sizeof(PSHNOTIFY); // not used
case PSN_HELP: return sizeof(PSHNOTIFY); case PSN_WIZBACK: return sizeof(PSHNOTIFY); case PSN_WIZNEXT: return sizeof(PSHNOTIFY); case PSN_WIZFINISH: return sizeof(PSHNOTIFY); case PSN_QUERYCANCEL: return sizeof(PSHNOTIFY); case PSN_GETOBJECT: return sizeof(NMOBJECTNOTIFY); case PSN_LASTCHANCEAPPLY: return sizeof(PSHNOTIFY); case PSN_TRANSLATEACCELERATOR: return sizeof(PSHNOTIFY); case PSN_QUERYINITIALFOCUS: return sizeof(PSHNOTIFY);
// Header notifications
case HDN_ITEMCHANGINGA: return sizeof(NMHEADERA); case HDN_ITEMCHANGINGW: return sizeof(NMHEADERW); case HDN_ITEMCHANGEDA: return sizeof(NMHEADERA); case HDN_ITEMCHANGEDW: return sizeof(NMHEADERW); case HDN_ITEMCLICKA: return sizeof(NMHEADERA); case HDN_ITEMCLICKW: return sizeof(NMHEADERW); case HDN_ITEMDBLCLICKA: return sizeof(NMHEADERA); case HDN_ITEMDBLCLICKW: return sizeof(NMHEADERW); case HDN_DIVIDERDBLCLICKA: return sizeof(NMHEADERA); case HDN_DIVIDERDBLCLICKW: return sizeof(NMHEADERW); case HDN_BEGINTRACKA: return sizeof(NMHEADERA); case HDN_BEGINTRACKW: return sizeof(NMHEADERW); case HDN_ENDTRACKA: return sizeof(NMHEADERA); case HDN_ENDTRACKW: return sizeof(NMHEADERW); case HDN_TRACKA: return sizeof(NMHEADERA); case HDN_TRACKW: return sizeof(NMHEADERW); case HDN_GETDISPINFOA: return sizeof(NMHDDISPINFOA); case HDN_GETDISPINFOW: return sizeof(NMHDDISPINFOW); case HDN_BEGINDRAG: return sizeof(NMHEADER); // No strings
case HDN_ENDDRAG: return sizeof(NMHEADER); // No strings
case HDN_FILTERCHANGE: return sizeof(NMHEADER); // No strings
case HDN_FILTERBTNCLICK: return sizeof(NMHDFILTERBTNCLICK);
// Treeview notifications
case TVN_SELCHANGINGA: return sizeof(NMTREEVIEWA); case TVN_SELCHANGINGW: return sizeof(NMTREEVIEWW); case TVN_SELCHANGEDA: return sizeof(NMTREEVIEWA); case TVN_SELCHANGEDW: return sizeof(NMTREEVIEWW); case TVN_GETDISPINFOA: return sizeof(NMTVDISPINFOA); case TVN_GETDISPINFOW: return sizeof(NMTVDISPINFOW); case TVN_SETDISPINFOA: return sizeof(NMTVDISPINFOA); case TVN_SETDISPINFOW: return sizeof(NMTVDISPINFOW); case TVN_ITEMEXPANDINGA: return sizeof(NMTREEVIEWA); case TVN_ITEMEXPANDINGW: return sizeof(NMTREEVIEWW); case TVN_ITEMEXPANDEDA: return sizeof(NMTREEVIEWA); case TVN_ITEMEXPANDEDW: return sizeof(NMTREEVIEWW); case TVN_BEGINDRAGA: return sizeof(NMTREEVIEWA); case TVN_BEGINDRAGW: return sizeof(NMTREEVIEWW); case TVN_BEGINRDRAGA: return sizeof(NMTREEVIEWA); case TVN_BEGINRDRAGW: return sizeof(NMTREEVIEWW); case TVN_DELETEITEMA: return sizeof(NMTREEVIEWA); case TVN_DELETEITEMW: return sizeof(NMTREEVIEWW); case TVN_BEGINLABELEDITA: return sizeof(NMTVDISPINFOA); case TVN_BEGINLABELEDITW: return sizeof(NMTVDISPINFOW); case TVN_ENDLABELEDITA: return sizeof(NMTVDISPINFOA); case TVN_ENDLABELEDITW: return sizeof(NMTVDISPINFOW); case TVN_KEYDOWN: return sizeof(NMTVKEYDOWN); case TVN_GETINFOTIPA: return sizeof(NMTVGETINFOTIPA); case TVN_GETINFOTIPW: return sizeof(NMTVGETINFOTIPW); case TVN_SINGLEEXPAND: return sizeof(NMTREEVIEW); // No strings
// Rundll32 notifications
case RDN_TASKINFO: return sizeof(RUNDLL_NOTIFY);
// Tooltip notifications
case TTN_GETDISPINFOA: return sizeof(NMTTDISPINFOA); case TTN_GETDISPINFOW: return sizeof(NMTTDISPINFOW); case TTN_SHOW: return sizeof(NMTTSHOWINFO); case TTN_POP: return sizeof(NMHDR);
// Tab control notifications
// WE ARE SUCH HORRIBLE SLACKERS!
//
// Even though commctrl.h says that the shell reserved range is from
// -580 to -589, shsemip.h defines SEN_FIRST as -550, which conflicts
// with TCN_KEYDOWN, so now TCN_KEYDOWN and SEN_DDEEXECUTE have the
// same value.
#ifdef WINNT
case TCN_KEYDOWN: return max(sizeof(NMTCKEYDOWN), sizeof(NMVIEWFOLDERW));#else
case TCN_KEYDOWN: return max(sizeof(NMTCKEYDOWN), sizeof(NMVIEWFOLDERA));#endif
case TCN_SELCHANGE: return sizeof(NMHDR); case TCN_SELCHANGING: return sizeof(NMHDR); case TCN_GETOBJECT: return sizeof(NMOBJECTNOTIFY); case TCN_FOCUSCHANGE: return sizeof(NMHDR);
// Shell32 notifications
#if 0 // see comment at TCN_KEYDOWN
case SEN_DDEEXECUTE:#ifdef WINNT
return sizeof(NMVIEWFOLDERW);#else
return sizeof(NMVIEWFOLDERA);#endif
#endif
// Comdlg32 notifications
case CDN_INITDONE: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_SELCHANGE: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_FOLDERCHANGE: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_SHAREVIOLATION: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_HELP: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_FILEOK: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_TYPECHANGE: return max(sizeof(OFNOTIFYA), sizeof(OFNOTIFYW)); case CDN_INCLUDEITEM: return max(sizeof(OFNOTIFYEXA), sizeof(OFNOTIFYEXW));
// Toolbar notifications
case TBN_GETBUTTONINFOA: return sizeof(NMTOOLBARA); case TBN_GETBUTTONINFOW: return sizeof(NMTOOLBARW); case TBN_BEGINDRAG: return sizeof(NMTOOLBAR); // No strings
case TBN_ENDDRAG: return sizeof(NMTOOLBAR); // No strings
case TBN_BEGINADJUST: return sizeof(NMHDR); case TBN_ENDADJUST: return sizeof(NMHDR); case TBN_RESET: return sizeof(NMTBCUSTOMIZEDLG); case TBN_QUERYINSERT: return sizeof(NMTOOLBAR); // No strings
case TBN_QUERYDELETE: return sizeof(NMTOOLBAR); // No strings
case TBN_TOOLBARCHANGE: return sizeof(NMHDR); case TBN_CUSTHELP: return sizeof(NMHDR); case TBN_DROPDOWN: return sizeof(NMTOOLBAR); // No strings
case TBN_CLOSEUP: return sizeof(NMHDR); // not used
case TBN_GETOBJECT: return sizeof(NMOBJECTNOTIFY); case TBN_HOTITEMCHANGE: return sizeof(NMTBHOTITEM); case TBN_DRAGOUT: return sizeof(NMTOOLBAR); // No strings
case TBN_DELETINGBUTTON: return sizeof(NMTOOLBAR); // No strings
case TBN_GETDISPINFOA: return sizeof(NMTBDISPINFOA); case TBN_GETDISPINFOW: return sizeof(NMTBDISPINFOW); case TBN_GETINFOTIPA: return sizeof(NMTBGETINFOTIPA); case TBN_GETINFOTIPW: return sizeof(NMTBGETINFOTIPW); case TBN_RESTORE: return sizeof(NMTBRESTORE);
// WE ARE SUCH HORRIBLE SLACKERS!
//
// The TBN_FIRST/TBN_LAST range reserves 20 notifications for toolbar,
// and we overflowed that limit, so now UDN_DELTAPOS and
// TBN_SAVE have the same value.
case TBN_SAVE: return max(sizeof(NMTBSAVE), sizeof(NMUPDOWN));
case TBN_INITCUSTOMIZE: return sizeof(NMTBCUSTOMIZEDLG); case TBN_WRAPHOTITEM: return sizeof(NMTBWRAPHOTITEM); case TBN_DUPACCELERATOR: return sizeof(NMTBDUPACCELERATOR); case TBN_WRAPACCELERATOR: return sizeof(NMTBWRAPACCELERATOR); case TBN_DRAGOVER: return sizeof(NMTBHOTITEM); case TBN_MAPACCELERATOR: return sizeof(NMCHAR);
// Up-down control
#if 0 // see comment at TBN_SAVE
case UDN_DELTAPOS: return sizeof(NMUPDOWN);#endif
// Monthcal control
case MCN_SELCHANGE: return sizeof(NMSELCHANGE); case MCN_GETDAYSTATE: return sizeof(NMDAYSTATE); case MCN_SELECT: return sizeof(NMSELECT);
// Date/time picker control
case DTN_DATETIMECHANGE: return sizeof(NMDATETIMECHANGE); case DTN_USERSTRINGA: return sizeof(NMDATETIMESTRINGA); case DTN_USERSTRINGW: return sizeof(NMDATETIMESTRINGW); case DTN_WMKEYDOWNA: return sizeof(NMDATETIMEWMKEYDOWNA); case DTN_WMKEYDOWNW: return sizeof(NMDATETIMEWMKEYDOWNW); case DTN_FORMATA: return sizeof(NMDATETIMEFORMATA); case DTN_FORMATW: return sizeof(NMDATETIMEFORMATW); case DTN_FORMATQUERYA: return sizeof(NMDATETIMEFORMATQUERYA); case DTN_FORMATQUERYW: return sizeof(NMDATETIMEFORMATQUERYW); case DTN_DROPDOWN: return sizeof(NMHDR); case DTN_CLOSEUP: return sizeof(NMHDR);
// Comboex notifications
case CBEN_GETDISPINFOA: return sizeof(NMCOMBOBOXEXA); case CBEN_GETDISPINFOW: return sizeof(NMCOMBOBOXEXW); case CBEN_INSERTITEM: return sizeof(NMCOMBOBOXEX); // Random character set
case CBEN_DELETEITEM: return sizeof(NMCOMBOBOXEX); // No strings
case CBEN_ITEMCHANGED: return sizeof(NMCOMBOBOXEX); // Not used
case CBEN_BEGINEDIT: return sizeof(NMHDR); case CBEN_ENDEDITA: return sizeof(NMCBEENDEDITA); case CBEN_ENDEDITW: return sizeof(NMCBEENDEDITW); case CBEN_DRAGBEGINA: return sizeof(NMCBEDRAGBEGINA); case CBEN_DRAGBEGINW: return sizeof(NMCBEDRAGBEGINW);
// Rebar notifications
case RBN_HEIGHTCHANGE: return sizeof(NMHDR); case RBN_GETOBJECT: return sizeof(NMOBJECTNOTIFY); case RBN_LAYOUTCHANGED: return sizeof(NMHDR); case RBN_AUTOSIZE: return sizeof(NMRBAUTOSIZE); case RBN_BEGINDRAG: return sizeof(NMREBAR); case RBN_DELETINGBAND: return sizeof(NMREBAR); case RBN_DELETEDBAND: return sizeof(NMREBAR); case RBN_CHILDSIZE: return sizeof(NMREBARCHILDSIZE);
// IP address control notification
case IPN_FIELDCHANGED: return sizeof(NMIPADDRESS);
// Status bar notifications
case SBN_SIMPLEMODECHANGE: return sizeof(NMHDR);
// Pager control notifications
case PGN_SCROLL: return sizeof(NMPGSCROLL); case PGN_CALCSIZE: return sizeof(NMPGCALCSIZE);
default: break; }
//
// Categories of notifications we explicitly know nothing about.
//
if (code >= WMN_LAST && code <= WMN_FIRST) { // Internet Mail and News
return 0; }
if ((int)code >= 0) { // Application-specific notifications
return 0; }
//
// IF THIS ASSERT FIRES, YOU MUST FIX IT OR YOU WILL BREAK WOW!
//
AssertMsg(0, TEXT("Notification code %d must be added to WOWGetNotifySize")); return 0;}
#endif // NEED_WOWGETNOTIFYSIZE_HELPER
LRESULT WINAPI SendNotifyEx(HWND hwndTo, HWND hwndFrom, int code, NMHDR FAR* pnmhdr, BOOL bUnicode){ CONTROLINFO ci;
if (!hwndTo) { if (IsWindow(hwndFrom)) hwndTo = GetParent(hwndFrom); if (!hwndTo) return 0; }
ci.hwndParent = hwndTo; ci.hwnd = hwndFrom; ci.bUnicode = BOOLIFY(bUnicode); ci.uiCodePage = CP_ACP;
return CCSendNotify(&ci, code, pnmhdr);}
#ifdef UNICODE
void StringBufferAtoW(UINT uiCodePage, LPVOID pvOrgPtr, DWORD dwOrgSize, CHAR **ppszText){ if (pvOrgPtr == *ppszText) { // the pointer has not been changed by the callback...
// must convert from A to W in-place
if (dwOrgSize) { LPWSTR pszW = ProduceWFromA(uiCodePage, *ppszText); if (pszW) { lstrcpynW((WCHAR *)(*ppszText), pszW, dwOrgSize); // this becomes a W buffer
FreeProducedString(pszW); } } } else { // the pointer has been changed out from underneath us, copy
// unicode back into the original buffer.
ConvertAToWN(uiCodePage, pvOrgPtr, dwOrgSize, *ppszText, -1); *ppszText = pvOrgPtr; }}
typedef struct tagTHUNKSTATE { LPVOID ts_pvThunk1; LPVOID ts_pvThunk2; DWORD ts_dwThunkSize;} THUNKSTATE;
//
// InOutWtoA/InOutAtoW is for thunking INOUT string parameters.
//
// INOUT parameters always create a hassle.
//
// We need to save both the original ANSI and the
// original UNICODE strings, so that if the app doesn't
// change the ANSI string, we leave the original UNICODE
// string alone. That way, UNICODE item names don't get
// obliterated by the thunk.
//
// The original buffer is saved in pvThunk1.
// We allocate two ANSI buffers.
// pvThunk2 contains the original ANSIfied string.
// pvThunk2+cchTextMax is the buffer we pass to the app.
// On the way back, we compare pvThunk2 with pvThunk2+cchTextMax.
// If they are different, then we unthunk the string; otherwise,
// we leave the original UNICODE buffer alone.
BOOL InOutWtoA(CONTROLINFO *pci, THUNKSTATE *pts, LPWSTR *ppsz, DWORD cchTextMax){ pts->ts_pvThunk1 = *ppsz; // Save original buffer
pts->ts_dwThunkSize = cchTextMax;
if (!IsFlagPtr(pts->ts_pvThunk1)) { pts->ts_pvThunk2 = LocalAlloc(LPTR, cchTextMax * 2 * sizeof(char)); if (!ConvertWToAN(pci->uiCodePage, (LPSTR)pts->ts_pvThunk2, pts->ts_dwThunkSize, (LPWSTR)pts->ts_pvThunk1, -1)) { LocalFree(pts->ts_pvThunk2); return 0; } *ppsz = (LPWSTR)((LPSTR)pts->ts_pvThunk2 + cchTextMax); lstrcpyA((LPSTR)*ppsz, pts->ts_pvThunk2); } return TRUE;}
void InOutAtoW(CONTROLINFO *pci, THUNKSTATE *pts, LPSTR *ppsz){ if (!IsFlagPtr(pts->ts_pvThunk1)) { if (!IsFlagPtr(*ppsz) && lstrcmpA(pts->ts_pvThunk2, (LPSTR)*ppsz) != 0) StringBufferAtoW(pci->uiCodePage, pts->ts_pvThunk1, pts->ts_dwThunkSize, ppsz); LocalFree(pts->ts_pvThunk2); } *ppsz = pts->ts_pvThunk1;}
#endif // UNICODE
LRESULT WINAPI CCSendNotify(CONTROLINFO * pci, int code, LPNMHDR pnmhdr){ NMHDR nmhdr; LONG_PTR id;#ifdef UNICODE
THUNKSTATE ts = { 0 }; #define pvThunk1 ts.ts_pvThunk1
#define pvThunk2 ts.ts_pvThunk2
#define dwThunkSize ts.ts_dwThunkSize
LRESULT lRet; BOOL bSet = FALSE;#endif
HWND hwndParent = pci->hwndParent; DWORD dwParentPid;
// -1 means Requery on each notify
if ( hwndParent == (HWND)-1 ) { hwndParent = GetParent(pci->hwnd); }
// unlikely but it can technically happen -- avoid the rips
if ( hwndParent == NULL ) return 0;
//
// If pci->hwnd is -1, then a WM_NOTIFY is being forwared
// from one control to a parent. EG: Tooltips sent
// a WM_NOTIFY to toolbar, and toolbar is forwarding it
// to the real parent window.
//
if (pci->hwnd != (HWND) -1) {
//
// If this is a child then get its ID. We need to go out of our way to
// avoid calling GetDlgCtrlID on toplevel windows since it will return
// a pseudo-random number (those of you who know what this number is
// keep quiet). Anyway it's kinda hard to figure this out in Windows
// because of the following:
//
// - a window can SetWindowLong(GWL_STYLE, WS_CHILD) but this only
// does about half the work - hence checking the style is out.
// - GetParent will return your OWNER if you are toplevel.
// - there is no GetWindow(...GW_HWNDPARENT) to save us.
//
// Hence we are stuck with calling GetParent and then checking to see
// if it lied and gave us the owner instead. Yuck.
//
id = 0; if (pci->hwnd) { HWND hwndParent = GetParent(pci->hwnd);
if (hwndParent && (hwndParent != GetWindow(pci->hwnd, GW_OWNER))) { id = GetDlgCtrlID(pci->hwnd); } }
if (!pnmhdr) pnmhdr = &nmhdr;
pnmhdr->hwndFrom = pci->hwnd; pnmhdr->idFrom = id; pnmhdr->code = code; } else {
id = pnmhdr->idFrom; code = pnmhdr->code; }
// OLE in its massively componentized world sometimes creates
// a control whose parent belongs to another process. (For example,
// when there is a local server embedding.) WM_NOTIFY
// messages can't cross process boundaries, so stop the message
// from going there lest we fault the recipient.
if (!GetWindowThreadProcessId(hwndParent, &dwParentPid) || dwParentPid != GetCurrentProcessId()) { TraceMsg(TF_WARNING, "nf: Not sending WM_NOTIFY %08x across processes", code); return 0; }
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(code >= 0 || WOWGetNotifySize(code));#endif // NEED_WOWGETNOTIFYSIZE_HELPER
#ifdef UNICODE
/*
* All the thunking for Notify Messages happens here */ if (!pci->bUnicode) { BOOL fThunked = TRUE; switch( code ) { case LVN_ODFINDITEMW: pnmhdr->code = LVN_ODFINDITEMA; goto ThunkLV_FINDINFO;
case LVN_INCREMENTALSEARCHW: pnmhdr->code = LVN_INCREMENTALSEARCHA; goto ThunkLV_FINDINFO;
ThunkLV_FINDINFO: { LV_FINDINFO *plvfi;
// Hack Alert! This code assumes that all fields of LV_FINDINFOA and
// LV_FINDINFOW are exactly the same except for the string pointers.
COMPILETIME_ASSERT(sizeof(LV_FINDINFOA) == sizeof(LV_FINDINFOW));
// Since WCHARs are bigger than char, we will just use the
// wchar buffer to hold the chars, and not worry about the extra
// room at the end.
COMPILETIME_ASSERT(sizeof(WCHAR) >= sizeof(char));
plvfi = &((PNM_FINDITEM)pnmhdr)->lvfi; if (plvfi->flags & (LVFI_STRING | LVFI_PARTIAL | LVFI_SUBSTRING)) { pvThunk1 = (PVOID)plvfi->psz; dwThunkSize = lstrlen(pvThunk1) + 1; plvfi->psz = (LPWSTR)ProduceAFromW(pci->uiCodePage, plvfi->psz); } } break;
case LVN_GETDISPINFOW: { LV_ITEMW *pitem;
pnmhdr->code = LVN_GETDISPINFOA;
// Hack Alert! This code assumes that all fields of LV_DISPINFOA and
// LV_DISPINFOW are exactly the same except for the string pointers.
COMPILETIME_ASSERT(sizeof(LV_DISPINFOA) == sizeof(LV_DISPINFOW));
// Since WCHARs are bigger than char, we will just use the
// wchar buffer to hold the chars, and not worry about the extra
// room at the end.
COMPILETIME_ASSERT(sizeof(WCHAR) >= sizeof(char));
//
// Some sleazebag code (shell32.dll) just changes the pszText
// pointer to point to the name, so capture the original pointer
// so we can detect this and not smash their data.
//
pitem = &(((LV_DISPINFOW *)pnmhdr)->item); if (!IsFlagPtr(pitem) && (pitem->mask & LVIF_TEXT) && !IsFlagPtr(pitem->pszText)) { pvThunk1 = pitem->pszText; dwThunkSize = pitem->cchTextMax; } break; }
// LVN_ENDLABELEDIT uses an INOUT parameter, never explicitly
// documented as such, but it just happened to be that way,
// and I don't want to take the chance that somebody was relying
// on it.
case LVN_ENDLABELEDITW: pnmhdr->code = LVN_ENDLABELEDITA; goto ThunkLV_DISPINFO;
case LVN_BEGINLABELEDITW: pnmhdr->code = LVN_BEGINLABELEDITA; goto ThunkLV_DISPINFO;
case LVN_SETDISPINFOW: pnmhdr->code = LVN_SETDISPINFOA; goto ThunkLV_DISPINFO;
case LVN_GETEMPTYTEXTW: pnmhdr->code = LVN_GETEMPTYTEXTA; goto ThunkLV_DISPINFO;
ThunkLV_DISPINFO: { LV_ITEMW *pitem;
COMPILETIME_ASSERT(sizeof(LV_ITEMA) == sizeof(LV_ITEMW)); pitem = &(((LV_DISPINFOW *)pnmhdr)->item);
if (pitem->mask & LVIF_TEXT) { if (!InOutWtoA(pci, &ts, &pitem->pszText, pitem->cchTextMax)) return 0; } break; }
case LVN_GETINFOTIPW: { NMLVGETINFOTIPW *pgit = (NMLVGETINFOTIPW *)pnmhdr;
COMPILETIME_ASSERT(sizeof(NMLVGETINFOTIPA) == sizeof(NMLVGETINFOTIPW)); pnmhdr->code = LVN_GETINFOTIPA;
if (!InOutWtoA(pci, &ts, &pgit->pszText, pgit->cchTextMax)) return 0; } break;
case TVN_GETINFOTIPW: { NMTVGETINFOTIPW *pgit = (NMTVGETINFOTIPW *)pnmhdr;
pnmhdr->code = TVN_GETINFOTIPA;
pvThunk1 = pgit->pszText; dwThunkSize = pgit->cchTextMax; } break;
case TBN_GETINFOTIPW: { NMTBGETINFOTIPW *pgit = (NMTBGETINFOTIPW *)pnmhdr;
pnmhdr->code = TBN_GETINFOTIPA;
pvThunk1 = pgit->pszText; dwThunkSize = pgit->cchTextMax; } break;
case TVN_SELCHANGINGW: pnmhdr->code = TVN_SELCHANGINGA; bSet = TRUE; // fall through
case TVN_SELCHANGEDW: if (!bSet) { pnmhdr->code = TVN_SELCHANGEDA; bSet = TRUE; }
/*
* These msgs have a NM_TREEVIEW with both TV_ITEMs filled in * * FALL THROUGH TO TVN_DELETEITEM to thunk itemOld then go on for * the other structure. */ // fall through
case TVN_DELETEITEMW: { /*
* This message has a NM_TREEVIEW in lParam with itemOld filled in */ LPTV_ITEMW pitem;
if (!bSet) { pnmhdr->code = TVN_DELETEITEMA; bSet = TRUE; }
pitem = &(((LPNM_TREEVIEWW)pnmhdr)->itemOld);
// thunk itemOld
if ( (pitem->mask & TVIF_TEXT) && !IsFlagPtr(pitem->pszText)) { pvThunk2 = pitem->pszText; pitem->pszText = (LPWSTR)ProduceAFromW(pci->uiCodePage, pvThunk2); }
// if this is deleteitem then we are done
if (pnmhdr->code == TVN_DELETEITEMA) break;
/* FALL THROUGH TO TVN_ITEMEXPANDING to thunk itemNew */ } // fall through
case TVN_ITEMEXPANDINGW: if (!bSet) { pnmhdr->code = TVN_ITEMEXPANDINGA; bSet = TRUE; } // fall through
case TVN_ITEMEXPANDEDW: if (!bSet) { pnmhdr->code = TVN_ITEMEXPANDEDA; bSet = TRUE; } // fall through
case TVN_BEGINDRAGW: if (!bSet) { pnmhdr->code = TVN_BEGINDRAGA; bSet = TRUE; } // fall through
case TVN_BEGINRDRAGW: { /* these msgs have a NM_TREEVIEW with itemNew TV_ITEM filled in */ LPTV_ITEMW pitem;
if (!bSet) { pnmhdr->code = TVN_BEGINRDRAGA; }
pitem = &(((LPNM_TREEVIEWW)pnmhdr)->itemNew);
if ( (pitem->mask & TVIF_TEXT) && !IsFlagPtr(pitem->pszText)) { pvThunk1 = pitem->pszText; pitem->pszText = (LPWSTR)ProduceAFromW(pci->uiCodePage, pvThunk1); }
break; }
case TVN_SETDISPINFOW: pnmhdr->code = TVN_SETDISPINFOA; goto ThunkTV_DISPINFO;
case TVN_BEGINLABELEDITW: pnmhdr->code = TVN_BEGINLABELEDITA; goto ThunkTV_DISPINFO;
// TVN_ENDLABELEDIT uses an INOUT parameter, never explicitly
// documented as such, but it just happened to be that way,
// and I don't want to take the chance that somebody was relying
// on it.
case TVN_ENDLABELEDITW: pnmhdr->code = TVN_ENDLABELEDITA; goto ThunkTV_DISPINFO;
ThunkTV_DISPINFO: { /*
* All these messages have a TV_DISPINFO in lParam. */
LPTV_ITEMW pitem;
pitem = &(((TV_DISPINFOW *)pnmhdr)->item);
if (pitem->mask & TVIF_TEXT) { if (!InOutWtoA(pci, &ts, &pitem->pszText, pitem->cchTextMax)) return 0; } break; }
#if !defined(UNIX) || defined(ANSI_SHELL32_ON_UNIX)
/* UNIX shell32 TVN_GETDISPINFOA TVN_GETDISPINFOW does the same thing */ case TVN_GETDISPINFOW: { /*
* All these messages have a TV_DISPINFO in lParam. */ LPTV_ITEMW pitem;
pnmhdr->code = TVN_GETDISPINFOA;
pitem = &(((TV_DISPINFOW *)pnmhdr)->item);
if ((pitem->mask & TVIF_TEXT) && !IsFlagPtr(pitem->pszText) && pitem->cchTextMax) { pvThunk1 = pitem->pszText; dwThunkSize = pitem->cchTextMax; pvThunk2 = LocalAlloc(LPTR, pitem->cchTextMax * sizeof(char)); pitem->pszText = pvThunk2; pitem->pszText[0] = TEXT('\0'); }
break; }#endif
case HDN_ITEMCHANGINGW: pnmhdr->code = HDN_ITEMCHANGINGA; bSet = TRUE; // fall through
case HDN_ITEMCHANGEDW: if (!bSet) { pnmhdr->code = HDN_ITEMCHANGEDA; bSet = TRUE; } // fall through
case HDN_ITEMCLICKW: if (!bSet) { pnmhdr->code = HDN_ITEMCLICKA; bSet = TRUE; } // fall through
case HDN_ITEMDBLCLICKW: if (!bSet) { pnmhdr->code = HDN_ITEMDBLCLICKA; bSet = TRUE; } // fall through
case HDN_DIVIDERDBLCLICKW: if (!bSet) { pnmhdr->code = HDN_DIVIDERDBLCLICKA; bSet = TRUE; } // fall through
case HDN_BEGINTRACKW: if (!bSet) { pnmhdr->code = HDN_BEGINTRACKA; bSet = TRUE; } // fall through
case HDN_ENDTRACKW: if (!bSet) { pnmhdr->code = HDN_ENDTRACKA; bSet = TRUE; } // fall through
case HDN_TRACKW: { HD_ITEMW *pitem;
if (!bSet) { pnmhdr->code = HDN_TRACKA; }
pitem = ((HD_NOTIFY *)pnmhdr)->pitem;
if ( !IsFlagPtr(pitem) && (pitem->mask & HDI_TEXT) && !IsFlagPtr(pitem->pszText)) { pvThunk1 = pitem->pszText; dwThunkSize = pitem->cchTextMax; pitem->pszText = (LPWSTR)ProduceAFromW(pci->uiCodePage, pvThunk1); }
if ( !IsFlagPtr(pitem) && (pitem->mask & HDI_FILTER) && pitem->pvFilter ) { if ( !(pitem->type & HDFT_HASNOVALUE) && ((pitem->type & HDFT_ISMASK)==HDFT_ISSTRING) ) { LPHD_TEXTFILTER ptextFilter = (LPHD_TEXTFILTER)pitem->pvFilter; pvThunk2 = ptextFilter->pszText; dwThunkSize = ptextFilter->cchTextMax; ptextFilter->pszText = (LPWSTR)ProduceAFromW(pci->uiCodePage, pvThunk2); } }
break; }
case CBEN_ENDEDITW: { LPNMCBEENDEDITW peew = (LPNMCBEENDEDITW) pnmhdr; LPNMCBEENDEDITA peea = LocalAlloc(LPTR, sizeof(NMCBEENDEDITA));
if (!peea) return 0;
peea->hdr = peew->hdr; peea->hdr.code = CBEN_ENDEDITA;
peea->fChanged = peew->fChanged; peea->iNewSelection = peew->iNewSelection; peea->iWhy = peew->iWhy; ConvertWToAN(pci->uiCodePage, peea->szText, ARRAYSIZE(peea->szText), peew->szText, -1);
pvThunk1 = pnmhdr; pnmhdr = &peea->hdr; ASSERT((LPVOID)pnmhdr == (LPVOID)peea); break; }
case CBEN_DRAGBEGINW: { LPNMCBEDRAGBEGINW pdbw = (LPNMCBEDRAGBEGINW) pnmhdr; LPNMCBEDRAGBEGINA pdba = LocalAlloc(LPTR, sizeof(NMCBEDRAGBEGINA));
if (!pdba) return 0;
pdba->hdr = pdbw->hdr; pdba->hdr.code = CBEN_DRAGBEGINA; pdba->iItemid = pdbw->iItemid; ConvertWToAN(pci->uiCodePage, pdba->szText, ARRAYSIZE(pdba->szText), pdbw->szText, -1);
pvThunk1 = pnmhdr; pnmhdr = &pdba->hdr; ASSERT((LPVOID)pnmhdr == (LPVOID)pdba); break; }
case CBEN_GETDISPINFOW: { PNMCOMBOBOXEXW pnmcbe = (PNMCOMBOBOXEXW)pnmhdr;
pnmhdr->code = CBEN_GETDISPINFOA;
if (pnmcbe->ceItem.mask & CBEIF_TEXT && !IsFlagPtr(pnmcbe->ceItem.pszText) && pnmcbe->ceItem.cchTextMax) { pvThunk1 = pnmcbe->ceItem.pszText; dwThunkSize = pnmcbe->ceItem.cchTextMax; pvThunk2 = LocalAlloc(LPTR, pnmcbe->ceItem.cchTextMax * sizeof(char)); pnmcbe->ceItem.pszText = pvThunk2; pnmcbe->ceItem.pszText[0] = TEXT('\0'); }
break; }
case HDN_GETDISPINFOW: { LPNMHDDISPINFOW pHDDispInfoW;
pnmhdr->code = HDN_GETDISPINFOA;
pHDDispInfoW = (LPNMHDDISPINFOW) pnmhdr;
pvThunk1 = pHDDispInfoW->pszText; dwThunkSize = pHDDispInfoW->cchTextMax; pHDDispInfoW->pszText = LocalAlloc (LPTR, pHDDispInfoW->cchTextMax * sizeof(char));
if (!pHDDispInfoW->pszText) { pHDDispInfoW->pszText = (LPWSTR) pvThunk1; break; }
WideCharToMultiByte(pci->uiCodePage, 0, (LPWSTR)pvThunk1, -1, (LPSTR)pHDDispInfoW->pszText, pHDDispInfoW->cchTextMax, NULL, NULL); break; }
case TBN_GETBUTTONINFOW: { LPTBNOTIFYW pTBNW;
pnmhdr->code = TBN_GETBUTTONINFOA;
pTBNW = (LPTBNOTIFYW)pnmhdr;
pvThunk1 = pTBNW->pszText; dwThunkSize = pTBNW->cchText; pvThunk2 = LocalAlloc (LPTR, pTBNW->cchText * sizeof(char));
if (!pvThunk2) { break; } pTBNW->pszText = pvThunk2;
WideCharToMultiByte(pci->uiCodePage, 0, (LPWSTR)pvThunk1, -1, (LPSTR)pTBNW->pszText, pTBNW->cchText, NULL, NULL);
} break;
case TTN_NEEDTEXTW: { LPTOOLTIPTEXTA lpTTTA; LPTOOLTIPTEXTW lpTTTW = (LPTOOLTIPTEXTW) pnmhdr;
lpTTTA = LocalAlloc(LPTR, sizeof(TOOLTIPTEXTA));
if (!lpTTTA) return 0;
lpTTTA->hdr = lpTTTW->hdr; lpTTTA->hdr.code = TTN_NEEDTEXTA;
lpTTTA->lpszText = lpTTTA->szText; lpTTTA->hinst = lpTTTW->hinst; lpTTTA->uFlags = lpTTTW->uFlags; lpTTTA->lParam = lpTTTW->lParam;
WideCharToMultiByte(pci->uiCodePage, 0, lpTTTW->szText, -1, lpTTTA->szText, ARRAYSIZE(lpTTTA->szText), NULL, NULL); pvThunk1 = pnmhdr; pnmhdr = (NMHDR FAR *)lpTTTA; } break;
case DTN_USERSTRINGW: { LPNMDATETIMESTRINGW lpDateTimeString = (LPNMDATETIMESTRINGW) pnmhdr;
pnmhdr->code = DTN_USERSTRINGA;
pvThunk1 = ProduceAFromW(pci->uiCodePage, lpDateTimeString->pszUserString); lpDateTimeString->pszUserString = (LPWSTR) pvThunk1; } break;
case DTN_WMKEYDOWNW: { LPNMDATETIMEWMKEYDOWNW lpDateTimeWMKeyDown = (LPNMDATETIMEWMKEYDOWNW) pnmhdr;
pnmhdr->code = DTN_WMKEYDOWNA;
pvThunk1 = ProduceAFromW(pci->uiCodePage, lpDateTimeWMKeyDown->pszFormat); lpDateTimeWMKeyDown->pszFormat = (LPWSTR) pvThunk1; } break;
case DTN_FORMATQUERYW: { LPNMDATETIMEFORMATQUERYW lpDateTimeFormatQuery = (LPNMDATETIMEFORMATQUERYW) pnmhdr;
pnmhdr->code = DTN_FORMATQUERYA;
pvThunk1 = ProduceAFromW(pci->uiCodePage, lpDateTimeFormatQuery->pszFormat); lpDateTimeFormatQuery->pszFormat = (LPWSTR) pvThunk1; } break;
case DTN_FORMATW: { LPNMDATETIMEFORMATW lpDateTimeFormat = (LPNMDATETIMEFORMATW) pnmhdr;
pnmhdr->code = DTN_FORMATA;
pvThunk1 = ProduceAFromW(pci->uiCodePage, lpDateTimeFormat->pszFormat); lpDateTimeFormat->pszFormat = (LPWSTR) pvThunk1; } break;
default: fThunked = FALSE; break; }
#ifdef NEED_WOWGETNOTIFYSIZE_HELPER
ASSERT(code >= 0 || WOWGetNotifySize(code));#endif // NEED_WOWGETNOTIFYSIZE_HELPER
lRet = SendMessage(hwndParent, WM_NOTIFY, (WPARAM)id, (LPARAM)pnmhdr);
/*
* All the thunking for Notify Messages happens here */ if (fThunked) { switch(pnmhdr->code) { case LVN_ODFINDITEMA: case LVN_INCREMENTALSEARCHA: { LV_FINDINFO *plvfi = &((PNM_FINDITEM)pnmhdr)->lvfi; if (pvThunk1) { FreeProducedString((LPWSTR)plvfi->psz); plvfi->psz = pvThunk1; } } break;
case LVN_GETDISPINFOA: { LV_ITEMA *pitem = &(((LV_DISPINFOA *)pnmhdr)->item);
// BUGBUG what if pointer is to large buffer?
if (!IsFlagPtr(pitem) && (pitem->mask & LVIF_TEXT) && !IsFlagPtr(pitem->pszText)) { StringBufferAtoW(pci->uiCodePage, pvThunk1, dwThunkSize, &pitem->pszText); } } break;
case LVN_ENDLABELEDITA: case LVN_BEGINLABELEDITA: case LVN_SETDISPINFOA: case LVN_GETEMPTYTEXTA: { LV_ITEMA *pitem = &(((LV_DISPINFOA *)pnmhdr)->item); InOutAtoW(pci, &ts, &pitem->pszText); } break;
case LVN_GETINFOTIPA: { NMLVGETINFOTIPA *pgit = (NMLVGETINFOTIPA *)pnmhdr; InOutAtoW(pci, &ts, &pgit->pszText); } break;
case TVN_GETINFOTIPA: { NMTVGETINFOTIPA *pgit = (NMTVGETINFOTIPA *)pnmhdr; StringBufferAtoW(pci->uiCodePage, pvThunk1, dwThunkSize, &pgit->pszText); } break;
case TBN_GETINFOTIPA: { NMTBGETINFOTIPA *pgit = (NMTBGETINFOTIPA *)pnmhdr; StringBufferAtoW(pci->uiCodePage, pvThunk1, dwThunkSize, &pgit->pszText); } break; case TVN_SELCHANGINGA: case TVN_SELCHANGEDA: case TVN_DELETEITEMA: { LPTV_ITEMW pitem;
if ( !IsFlagPtr(pvThunk2) ) { pitem = &(((LPNM_TREEVIEWW)pnmhdr)->itemOld);
FreeProducedString(pitem->pszText); pitem->pszText = pvThunk2; }
// if this is delitem, then we are done
if (code == TVN_DELETEITEM) break;
/* FALL THROUGH TO TVN_ITEMEXPANDING to unthunk itemNew */ } // fall through
case TVN_ITEMEXPANDINGA: case TVN_ITEMEXPANDEDA: case TVN_BEGINDRAGA: case TVN_BEGINRDRAGA: { /* these msgs have a NM_TREEVIEW with itemNew TV_ITEM filled in */ LPTV_ITEMW pitem;
if (!IsFlagPtr(pvThunk1)) { pitem = &(((LPNM_TREEVIEWW)pnmhdr)->itemNew);
FreeProducedString(pitem->pszText); pitem->pszText = pvThunk1; }
break; }
case TVN_SETDISPINFOA: case TVN_BEGINLABELEDITA: case TVN_ENDLABELEDITA: { LPTV_ITEMA pitem; pitem = &(((TV_DISPINFOA *)pnmhdr)->item); InOutAtoW(pci, &ts, &pitem->pszText); } break;
case TVN_GETDISPINFOA: { /*
* This message has a TV_DISPINFO in lParam that wass filled in * during the callback and needs to be unthunked. */ LPTV_ITEMW pitem;
pitem = &(((TV_DISPINFOW *)pnmhdr)->item);
if (!IsFlagPtr(pvThunk1) && (pitem->mask & TVIF_TEXT) && !IsFlagPtr(pitem->pszText)) { ConvertAToWN(pci->uiCodePage, pvThunk1, dwThunkSize, (LPSTR)pitem->pszText, -1); pitem->pszText = pvThunk1; LocalFree(pvThunk2); }
break; }
case HDN_ITEMCHANGINGA: case HDN_ITEMCHANGEDA: case HDN_ITEMCLICKA: case HDN_ITEMDBLCLICKA: case HDN_DIVIDERDBLCLICKA: case HDN_BEGINTRACKA: case HDN_ENDTRACKA: case HDN_TRACKA: { HD_ITEMW *pitem;
pitem = ((HD_NOTIFY *)pnmhdr)->pitem;
if ( !IsFlagPtr(pitem) && (pitem->mask & HDI_TEXT) && !IsFlagPtr(pvThunk1)) { ConvertAToWN(pci->uiCodePage, pvThunk1, dwThunkSize, (LPSTR)(pitem->pszText), -1);
FreeProducedString(pitem->pszText); pitem->pszText = pvThunk1; }
if ( !IsFlagPtr(pitem) && (pitem->mask & HDI_FILTER) && pitem->pvFilter && pvThunk2 ) { if ( !(pitem->type & HDFT_HASNOVALUE) && ((pitem->type & HDFT_ISMASK)==HDFT_ISSTRING) ) { LPHD_TEXTFILTER ptextFilter = (LPHD_TEXTFILTER)pitem->pvFilter; ConvertAToWN(pci->uiCodePage, pvThunk2, dwThunkSize, (LPSTR)(ptextFilter->pszText), -1); FreeProducedString(ptextFilter->pszText); ptextFilter->pszText = pvThunk2; } }
break; }
case CBEN_ENDEDITA: { LPNMCBEENDEDITW peew = (LPNMCBEENDEDITW) pvThunk1; LPNMCBEENDEDITA peea = (LPNMCBEENDEDITA) pnmhdr;
// Don't unthunk the string since that destroys unicode round-trip
// and the client shouldn't be modifying it anyway.
// ConvertAToWN(pci->uiCodePage, peew->szText, ARRAYSIZE(peew->szText),
// peea->szText, -1);
LocalFree(peea); } break;
case CBEN_DRAGBEGINA: { LPNMCBEDRAGBEGINW pdbw = (LPNMCBEDRAGBEGINW) pvThunk1; LPNMCBEDRAGBEGINA pdba = (LPNMCBEDRAGBEGINA) pnmhdr;
// Don't unthunk the string since that destroys unicode round-trip
// and the client shouldn't be modifying it anyway.
// ConvertAToWN(pci->uiCodePage, pdbw->szText, ARRAYSIZE(pdbw->szText),
// pdba->szText, -1);
LocalFree(pdba); } break;
case CBEN_GETDISPINFOA: { PNMCOMBOBOXEXW pnmcbeW;
pnmcbeW = (PNMCOMBOBOXEXW)pnmhdr; ConvertAToWN(pci->uiCodePage, pvThunk1, dwThunkSize, (LPSTR)(pnmcbeW->ceItem.pszText), -1);
if (pvThunk2) LocalFree(pvThunk2); pnmcbeW->ceItem.pszText = pvThunk1;
} break;
case HDN_GETDISPINFOA: { LPNMHDDISPINFOW pHDDispInfoW;
pHDDispInfoW = (LPNMHDDISPINFOW)pnmhdr; ConvertAToWN(pci->uiCodePage, pvThunk1, dwThunkSize, (LPSTR)(pHDDispInfoW->pszText), -1);
LocalFree(pHDDispInfoW->pszText); pHDDispInfoW->pszText = pvThunk1;
} break;
case TBN_GETBUTTONINFOA: { LPTBNOTIFYW pTBNW;
pTBNW = (LPTBNOTIFYW)pnmhdr; ConvertAToWN(pci->uiCodePage, pvThunk1, dwThunkSize, (LPSTR)(pTBNW->pszText), -1);
pTBNW->pszText = pvThunk1; LocalFree(pvThunk2);
} break;
case TTN_NEEDTEXTA: { LPTOOLTIPTEXTA lpTTTA = (LPTOOLTIPTEXTA) pnmhdr; LPTOOLTIPTEXTW lpTTTW = (LPTOOLTIPTEXTW) pvThunk1;
ThunkToolTipTextAtoW (lpTTTA, lpTTTW, pci->uiCodePage); LocalFree(lpTTTA); } break;
case DTN_USERSTRINGA: case DTN_WMKEYDOWNA: case DTN_FORMATQUERYA: { FreeProducedString (pvThunk1); } break;
case DTN_FORMATA: { LPNMDATETIMEFORMATA lpDateTimeFormat = (LPNMDATETIMEFORMATA) pnmhdr;
FreeProducedString (pvThunk1);
//
// pszDisplay and szDisplay are special cases.
//
if (lpDateTimeFormat->pszDisplay && *lpDateTimeFormat->pszDisplay) {
//
// if pszDisplay still points at szDisplay then thunk
// in place. Otherwise allocate memory and copy the
// display string. This buffer will be freeded in monthcal.c
//
if (lpDateTimeFormat->pszDisplay == lpDateTimeFormat->szDisplay) { CHAR szDisplay[64];
lstrcpynA (szDisplay, lpDateTimeFormat->szDisplay, 64);
ConvertAToWN (pci->uiCodePage, (LPWSTR)lpDateTimeFormat->szDisplay, 64, szDisplay, -1); } else { lpDateTimeFormat->pszDisplay = (LPSTR) ProduceWFromA (pci->uiCodePage, lpDateTimeFormat->pszDisplay); }
}
} break;
default: /* No thunking needed */ break; } } return lRet; } else#endif
return(SendMessage(hwndParent, WM_NOTIFY, (WPARAM)id, (LPARAM)pnmhdr));
#undef pvThunk1
#undef pvThunk2
#undef dwThunkSize
}
LRESULT WINAPI SendNotify(HWND hwndTo, HWND hwndFrom, int code, NMHDR FAR* pnmhdr){ CONTROLINFO ci; ci.hwndParent = hwndTo; ci.hwnd = hwndFrom; ci.bUnicode = FALSE; ci.uiCodePage = CP_ACP;
//
// SendNotify is obsolete. New code should call CCSendNotify
// instead. However, if something does call SendNotify,
// it will call SendNotifyEx with FALSE as the Unicode parameter,
// because it probably is ANSI code.
//
return CCSendNotify(&ci, code, pnmhdr);}
DWORD NEAR PASCAL CICustomDrawNotify(LPCONTROLINFO lpci, DWORD dwStage, LPNMCUSTOMDRAW lpnmcd){ DWORD dwRet = CDRF_DODEFAULT;
// bail if...
// this is an item notification, but an item notification wasn't asked for
if ((dwStage & CDDS_ITEM) && !(lpci->dwCustom & CDRF_NOTIFYITEMDRAW)) { return dwRet; }
lpnmcd->dwDrawStage = dwStage; dwRet = (DWORD) CCSendNotify(lpci, NM_CUSTOMDRAW, &lpnmcd->hdr);
// validate the flags
if (dwRet & ~CDRF_VALIDFLAGS) return CDRF_DODEFAULT;
return dwRet;}
//
// Too many apps encounter strange behavior when we send out
// NM_CUSTOMDRAW messages at times unrelated to painting.
// E.g., NetMeeting and MFC recurse back into ListView_RecomputeLabelSize.
// CryptUI will fault if it's asked to NM_CUSTOMDRAW before it gets
// WM_INITDIALOG. So all this fake customdraw stuff is v5 only.
//
// And since it is very popular to call back into the control during
// the handling of NM_CUSTOMDRAW, we protect against recursing ourselves
// to death by blowing off nested fake customdraw messages.
DWORD CIFakeCustomDrawNotify(LPCONTROLINFO lpci, DWORD dwStage, LPNMCUSTOMDRAW lpnmcd){ DWORD dwRet = CDRF_DODEFAULT;
if (lpci->iVersion >= 5 && !lpci->bInFakeCustomDraw) { lpci->bInFakeCustomDraw = TRUE; dwRet = CICustomDrawNotify(lpci, dwStage, lpnmcd); ASSERT(lpci->bInFakeCustomDraw); lpci->bInFakeCustomDraw = FALSE; }
return dwRet;}
/*----------------------------------------------------------
Purpose: Release the capture and tell the parent we've done so.
Returns: Whether the control is still alive.*/BOOL CCReleaseCapture(CONTROLINFO * pci){ HWND hwndCtl = pci->hwnd; NMHDR nmhdr = {0};
ReleaseCapture();
// Tell the parent we've released the capture
CCSendNotify(pci, NM_RELEASEDCAPTURE, &nmhdr);
return IsWindow(hwndCtl);}
/*----------------------------------------------------------
Purpose: Set the capture. If the hwndSet is NULL, it means the capture is being released, so tell the parent we've done so.
Use this function if there's a possibility that the hwnd may be NULL.
*/void CCSetCapture(CONTROLINFO * pci, HWND hwndSet){ SetCapture(hwndSet);
if (NULL == hwndSet) { NMHDR nmhdr = {0};
// Tell the parent we've released the capture
CCSendNotify(pci, NM_RELEASEDCAPTURE, &nmhdr); }}
|
