able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/comctl32/v5/notify.c

1505 lines
51 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#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);
}
}
Reference in a new issue Copy permalink