LRESULT Control::ControlProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam,
UINT_PTR subClassId, DWORD_PTR dataReference)
{
Pointer ptr;
MessageMap msgMap;
if (!ProcessMessages)
{
MSG msg;
msg.hwnd = hwnd;
msg.message = message;
msg.wParam = wParam;
msg.lParam = lParam;
QueuedMessages.push_back(msg);
return DefSubclassProc(hwnd, message, wParam, lParam);
}
map<HWND, MessageMap>::iterator iterGlobal = GlobalMessageMap.find(hwnd);
if (iterGlobal == GlobalMessageMap.end())
return DefSubclassProc(hwnd, message, wParam, lParam);
msgMap = iterGlobal->second;
MessageMap::iterator iter = msgMap.find(message);
if (iter == msgMap.end())
return DefSubclassProc(hwnd, message, wParam, lParam);
ptr = iter->second;
return (ptr.Window->*ptr.Function)(wParam, lParam);
}
static LRESULT CALLBACK
EditProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
EditCtrl *w = (EditCtrl *)dwRefData;
CrashIf(w->hwnd != (HWND)lp);
if (w->preFilter) {
bool discard = false;
auto res = w->preFilter(hwnd, msg, wp, lp, discard);
if (discard) {
return res;
}
}
if (WM_NCDESTROY == msg) {
RemoveWindowSubclass(GetParent(w->hwnd), EditParentProc, 0);
RemoveWindowSubclass(w->hwnd, EditProc, 0);
return DefSubclassProc(hwnd, msg, wp, lp);
}
// Node: this is sent during creation, which is too early for us (we didn't
// subclass the window yet)
// currently, we force it with SetWindowPos(... SMP_FRAMECHANGED)
if (WM_NCCALCSIZE == msg) {
NCCALCSIZE_PARAMS *p = (NCCALCSIZE_PARAMS *)lp;
RECT orig = p->rgrc[0];
LRESULT res = DefSubclassProc(hwnd, msg, wp, lp);
RECT curr = p->rgrc[0];
w->ncDx = RectDx(orig) - RectDx(curr);
w->ncDy = RectDy(orig) - RectDy(curr);
return res;
}
return DefSubclassProc(hwnd, msg, wp, lp);
}
static LRESULT CALLBACK TreeProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
UNUSED(uIdSubclass);
TreeCtrl* w = (TreeCtrl*)dwRefData;
CrashIf(w->hwnd != (HWND)hwnd);
if (w->preFilter) {
bool discard = false;
auto res = w->preFilter(hwnd, msg, wp, lp, discard);
if (discard) {
return res;
}
}
if (WM_ERASEBKGND == msg) {
return FALSE;
}
if (WM_KEYDOWN == msg) {
if (HandleKey(hwnd, wp)) {
return 0;
}
}
if (WM_NCDESTROY == msg) {
Unsubclass(w);
return DefSubclassProc(hwnd, msg, wp, lp);
}
return DefSubclassProc(hwnd, msg, wp, lp);
}
LRESULT AeroControlBase::ProgressbarWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_ENABLE:
case WM_STYLECHANGED:
{
LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
InvalidateRgn(hWnd, NULL, FALSE);
return res;
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
RECT rc;
GetWindowRect(hWnd, &rc);
MapWindowPoints(NULL, hWnd, (LPPOINT)&rc, 2);
if (hdc)
{
PaintControl(hWnd, hdc, &ps.rcPaint, false);
BP_PAINTPARAMS params = { sizeof(BP_PAINTPARAMS) };
params.dwFlags = 0L;
HDC hdcPaint = NULL;
HPAINTBUFFER hBufferedPaint = BeginBufferedPaint(hdc, &rc, BPBF_TOPDOWNDIB, ¶ms, &hdcPaint);
if (hdcPaint)
{
COLORREF cr = RGB(0x00, 0x00, 0x00);
SetPixel(hdcPaint, 0, 0, cr);
SetPixel(hdcPaint, 0, RECTHEIGHT(rc) - 1, cr);
SetPixel(hdcPaint, RECTWIDTH(rc) - 1, 0, cr);
SetPixel(hdcPaint, RECTWIDTH(rc) - 1, RECTHEIGHT(rc) - 1, cr);
EndBufferedPaint(hBufferedPaint, TRUE);
}
}
EndPaint(hWnd, &ps);
return 0;
}
break;
case WM_NCDESTROY:
case WM_DESTROY:
RemoveWindowSubclass(hWnd, SubclassProc, Static);
subclassedControls.erase(hWnd);
break;
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
static LRESULT CALLBACK FrameSubclass(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR, DWORD_PTR dwRefData)
{
HWND hwndTransfer = (HWND) dwRefData;
switch (uMsg)
{
case WM_MOVE:
{
LPCALC lpCalc = (LPCALC) GetWindowLongPtr(hwndTransfer, GWLP_USERDATA);
RECT wr;
GetWindowRect(hwnd, &wr);
DWORD dwSendWidth = (wr.right - wr.left) * 9 / 10;
DWORD dwSendHeight = 90; //10 * HIWORD(GetDialogBaseUnits());
LPSENDINFO lpsi = g_SendInfo[lpCalc];
RECT rcLcd = { 0 };
if (lpsi != NULL) {
GetWindowRect(lpsi->hwndParent, &rcLcd);
}
SetWindowPos(hwndTransfer, NULL,
wr.left + ((wr.right - wr.left) - dwSendWidth) / 2,
rcLcd.top + (rcLcd.bottom - rcLcd.top - dwSendHeight) / 2,
dwSendWidth, dwSendHeight,
SWP_NOSIZE | SWP_NOZORDER);
break;
}
}
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
// the real list view intercepts these keys to control editing
static LRESULT CALLBACK editSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIDSubclass, DWORD_PTR dwRefData)
{
uiTable *t = (uiTable *) dwRefData;
HRESULT hr;
switch (uMsg) {
case WM_KEYDOWN:
switch (wParam) {
// TODO handle VK_TAB and VK_SHIFT+VK_TAB
case VK_RETURN:
hr = uiprivTableFinishEditingText(t);
if (hr != S_OK) {
// TODO
}
return 0; // yes, the real list view just returns here
case VK_ESCAPE:
hr = uiprivTableAbortEditingText(t);
if (hr != S_OK) {
// TODO
}
return 0;
}
break;
// the real list view also forces these flags
case WM_GETDLGCODE:
return DLGC_HASSETSEL | DLGC_WANTALLKEYS;
case WM_NCDESTROY:
if (RemoveWindowSubclass(hwnd, editSubProc, uIDSubclass) == FALSE)
logLastError(L"RemoveWindowSubclass()");
// fall through
}
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
static LRESULT CALLBACK groupSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
uiGroup *g = uiGroup(dwRefData);
WINDOWPOS *wp = (WINDOWPOS *) lParam;
MINMAXINFO *mmi = (MINMAXINFO *) lParam;
int minwid, minht;
LRESULT lResult;
if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE)
return lResult;
switch (uMsg) {
case WM_WINDOWPOSCHANGED:
if ((wp->flags & SWP_NOSIZE) != 0)
break;
groupRelayout(g);
return 0;
case WM_GETMINMAXINFO:
lResult = DefWindowProcW(hwnd, uMsg, wParam, lParam);
uiWindowsControlMinimumSize(uiWindowsControl(g), &minwid, &minht);
mmi->ptMinTrackSize.x = minwid;
mmi->ptMinTrackSize.y = minht;
return lResult;
case WM_NCDESTROY:
if (RemoveWindowSubclass(hwnd, groupSubProc, uIdSubclass) == FALSE)
logLastError(L"error removing groupbox subclass");
break;
}
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
LRESULT CALLBACK Explorerplusplus::EditSubclass(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch(msg)
{
case WM_KEYDOWN:
switch(wParam)
{
case VK_RETURN:
OnAddressBarGo();
return 0;
break;
}
break;
case WM_SETFOCUS:
UpdateMainToolbar();
break;
case WM_MOUSEWHEEL:
if(OnMouseWheel(MOUSEWHEEL_SOURCE_OTHER,wParam,lParam))
{
return 0;
}
break;
}
return DefSubclassProc(hwnd,msg,wParam,lParam);
}
LRESULT CALLBACK Explorerplusplus::EditSubclass(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch(msg)
{
case WM_KEYDOWN:
switch(wParam)
{
case VK_RETURN:
SendMessage(m_hContainer,CBN_KEYDOWN,VK_RETURN,0);
return 0;
break;
}
break;
case WM_SETFOCUS:
HandleToolbarItemStates();
break;
case WM_MOUSEWHEEL:
if(OnMouseWheel(MOUSEWHEEL_SOURCE_OTHER,wParam,lParam))
{
return 0;
}
break;
}
return DefSubclassProc(hwnd,msg,wParam,lParam);
}
LRESULT CALLBACK CBookmarksToolbar::BookmarksToolbarParentProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch(uMsg)
{
case WM_COMMAND:
if(LOWORD(wParam) >= m_uIDStart &&
LOWORD(wParam) <= m_uIDEnd)
{
/* TODO: Map the id back to a GUID, and
then open the bookmark/show a dropdown
list. */
return 0;
}
break;
case WM_NOTIFY:
if(reinterpret_cast<LPNMHDR>(lParam)->hwndFrom == m_hToolbar)
{
switch(reinterpret_cast<LPNMHDR>(lParam)->code)
{
case TBN_GETINFOTIP:
{
//NMTBGETINFOTIP *pnmtbgit = reinterpret_cast<NMTBGETINFOTIP *>(lParam);
/* TODO: Build an infotip for the bookmark. */
//return 0;
}
break;
}
}
break;
}
return DefSubclassProc(hwnd,uMsg,wParam,lParam);
}
/***********************************************************************
* UPDOWN_Buddy_SubclassProc used to handle messages sent to the buddy
* control.
*/
static LRESULT CALLBACK
UPDOWN_Buddy_SubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
UINT_PTR uId, DWORD_PTR ref_data)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr((HWND)ref_data);
TRACE("hwnd=%p, uMsg=%04x, wParam=%08lx, lParam=%08lx\n",
hwnd, uMsg, wParam, lParam);
switch(uMsg)
{
case WM_KEYDOWN:
UPDOWN_KeyPressed(infoPtr, (int)wParam);
if ((wParam == VK_UP) || (wParam == VK_DOWN)) return 0;
break;
case WM_MOUSEWHEEL:
UPDOWN_MouseWheel(infoPtr, (int)wParam);
break;
default:
break;
}
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
/***********************************************************************
* COMCTL32_SubclassProc (internal)
*
* Window procedure for all subclassed windows.
* Saves the current subclassing stack position to support nested messages
*/
static LRESULT WINAPI COMCTL32_SubclassProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPSUBCLASS_INFO stack;
LPSUBCLASSPROCS proc;
LRESULT ret;
TRACE ("(%p, 0x%08x, 0x%08lx, 0x%08lx)\n", hWnd, uMsg, wParam, lParam);
stack = GetPropW (hWnd, COMCTL32_wSubclass);
if (!stack) {
ERR ("Our sub classing stack got erased for %p!! Nothing we can do\n", hWnd);
return 0;
}
/* Save our old stackpos to properly handle nested messages */
proc = stack->stackpos;
stack->stackpos = stack->SubclassProcs;
stack->running++;
ret = DefSubclassProc(hWnd, uMsg, wParam, lParam);
stack->running--;
stack->stackpos = proc;
if (!stack->SubclassProcs && !stack->running) {
TRACE("Last Subclass removed, cleaning up\n");
/* clean up our heap and reset the original window procedure */
if (IsWindowUnicode (hWnd))
SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
else
SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
Free (stack);
RemovePropW( hWnd, COMCTL32_wSubclass );
}
return ret;
}
static LRESULT CALLBACK opacitySliderSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
ID2D1RenderTarget *rt;
struct colorDialog *c;
D2D1_POINT_2F *pos;
D2D1_SIZE_F *size;
c = (struct colorDialog *) dwRefData;
switch (uMsg) {
case msgD2DScratchPaint:
rt = (ID2D1RenderTarget *) lParam;
drawOpacitySlider(c, rt);
return 0;
case msgD2DScratchLButtonDown:
pos = (D2D1_POINT_2F *) wParam;
size = (D2D1_SIZE_F *) lParam;
c->a = 1 - (pos->x / size->width);
updateDialog(c, NULL);
return 0;
case WM_NCDESTROY:
if (RemoveWindowSubclass(hwnd, opacitySliderSubProc, uIdSubclass) == FALSE)
logLastError(L"error removing color dialog opacity slider subclass");
break;
}
return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
LRESULT CALLBACK Explorerplusplus::MainWndTaskbarThumbnailProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
if(uMsg == m_uTaskbarButtonCreatedMessage)
{
if(m_pTaskbarList != NULL)
{
m_pTaskbarList->Release();
}
CoCreateInstance(CLSID_TaskbarList,NULL,CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&m_pTaskbarList));
m_pTaskbarList->HrInit();
m_bTaskbarInitialised = TRUE;
/* Add each of the jump list tasks. */
SetupJumplistTasks();
/* Register each of the tabs. */
for(auto itr = m_TabProxyList.begin();itr != m_TabProxyList.end();itr++)
{
BOOL bActive = (itr->iTabId == m_iObjectIndex);
RegisterTab(itr->hProxy,EMPTY_STRING,bActive);
HandleTabText(itr->iTabId);
SetTabIcon(itr->iTabId);
}
RemoveWindowSubclass(hwnd,MainWndProcStub,0);
return 0;
}
return DefSubclassProc(hwnd,uMsg,wParam,lParam);
}
LRESULT CALLBACK
FilterListProcedure(
IN HWND hWnd,
IN UINT uMsg,
IN WPARAM wp,
IN LPARAM lp,
IN UINT_PTR uIdSubclass,
IN DWORD_PTR dwRefData
)
{
BOOLEAN Handled;
switch (uMsg) {
case WM_KEYDOWN:
if ((ULONG)wp == VK_DELETE) {
Handled = FilterListOnDelete(hWnd, uMsg, wp, lp);
if (Handled) {
return TRUE;
}
}
}
return DefSubclassProc(hWnd, uMsg, wp, lp);
}
LRESULT CALLBACK TextBoxSubclassProc(
_In_ HWND hWnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam,
_In_ UINT_PTR uIdSubclass,
_In_ ULONG_PTR dwRefData
)
{
switch (uMsg)
{
case WM_NCDESTROY:
RemoveWindowSubclass(hWnd, TextBoxSubclassProc, uIdSubclass);
break;
case WM_GETDLGCODE:
{
if (wParam == VK_RETURN)
return DLGC_WANTALLKEYS;
}
break;
case WM_CHAR:
{
if (wParam == VK_RETURN)
{
SendMessage(GetParent(hWnd), WM_COMMAND, IDC_TEXT_RETURN, 0);
return 0;
}
}
break;
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
LRESULT RichEdit::ParentWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam,
UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
if(msg==WM_NOTIFY && (((LPNMHDR)lParam)->code)== EN_LINK) {
ENLINK* enLinkInfo = (ENLINK *)lParam;
if(enLinkInfo->msg == WM_LBUTTONUP || enLinkInfo->msg == WM_RBUTTONUP) {
LONG utlBeg = enLinkInfo->chrg.cpMin;
LONG utlEnd = enLinkInfo->chrg.cpMax;
if(utlEnd - utlBeg > 0) {
HWND hRichEdit = enLinkInfo->nmhdr.hwndFrom;
wchar_t* urlString = new wchar_t[utlEnd-utlBeg+1];
SendMessageW(hRichEdit, EM_EXSETSEL, 0, reinterpret_cast<LPARAM>(&enLinkInfo->chrg));
SendMessageW(hRichEdit, EM_GETSELTEXT, 0, reinterpret_cast<LPARAM>(urlString));
switch(enLinkInfo->msg) {
case WM_LBUTTONUP:
ShellExecuteW(NULL, L"open", urlString, NULL, NULL, SW_SHOWNORMAL);
break;
case WM_RBUTTONUP:
copyToClipboard(hRichEdit, urlString);
break;
}
delete [] urlString;
SendMessage(hRichEdit, EM_SETSEL, utlEnd, utlEnd);
HideCaret(hRichEdit);
}
}
}
return DefSubclassProc(hWnd, msg, wParam, lParam);
}
LRESULT AeroControlBase::SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uidSubclass, DWORD_PTR dwRefData)
{
AeroControlBase * pThis = (AeroControlBase*)dwRefData;
if (pThis)
{
HIGHCONTRAST hc = { sizeof(HIGHCONTRAST) };
SystemParametersInfo(SPI_GETHIGHCONTRAST, sizeof(HIGHCONTRAST), &hc, FALSE);
BOOL bEnabled = FALSE;
if (((hc.dwFlags & HCF_HIGHCONTRASTON) == 0) && SUCCEEDED(DwmIsCompositionEnabled(&bEnabled)) && bEnabled)
{
switch (uidSubclass)
{
case Static:
return pThis->StaticWindowProc(hWnd, uMsg, wParam, lParam);
break;
case Button:
return pThis->ButtonWindowProc(hWnd, uMsg, wParam, lParam);
break;
case Progressbar:
return pThis->ProgressbarWindowProc(hWnd, uMsg, wParam, lParam);
break;
}
}
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
LRESULT CALLBACK DropWindowSubclass(HWND hwnd,UINT uMsg,
WPARAM wParam,LPARAM lParam,UINT_PTR uIdSubclass,DWORD_PTR dwRefData)
{
switch(uMsg)
{
case WM_APP_COPYOPERATIONFINISHED:
{
PastedFilesInfo_t *ppfi = reinterpret_cast<PastedFilesInfo_t *>(wParam);
ppfi->pao->EndOperation(ppfi->hrCopy,NULL,ppfi->dwEffect);
ppfi->pDropHandler->Release();
free((void *)ppfi);
RemoveWindowSubclass(hwnd,DropWindowSubclass,SUBCLASS_ID);
return 0;
}
break;
/* TODO: The window we're subclassing may be destroyed
while the subclass is active. This should be handled in
some way. */
/*case WM_NCDESTROY:
RemoveWindowSubclass(hwnd,DropWindowSubclass,SUBCLASS_ID);
break;*/
}
return DefSubclassProc(hwnd,uMsg,wParam,lParam);
}
LRESULT CALLBACK EditBoxChanged(HWND hwnd,UINT message, WPARAM wParam, LPARAM lParam,UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
char formel[255];
switch(message) {
case WM_CHAR:
switch(wParam)
{
case VK_RETURN:
// Formel überprüfen und hinzufügen, wenn korrekt
GetWindowText(items[3].handle,formel,255);
if(strlen(formel) > 0) {
INFO("Füge Formel zum Verlauf hinzu!");
list[getListCount(items[4].handle)].text = malloc(sizeof(char*) * 255);
strcpy(list[getListCount(items[4].handle)].text,formel);
SendMessage(items[4].handle,LB_ADDSTRING,(WPARAM) NULL,(LONG)formel);
int Count = getListCount(items[4].handle);
sprintf(formel,"Einträge: %d",Count);
SetWindowText(items[1].handle,formel);
SetWindowText(hwnd,"");
if(PostThreadMessage(ThreadIds[0],TH_HANDLE,0x0,0x0) == FALSE) {
ERR("Nachricht konnte nicht gesendet werden!");
}
return TRUE; } else {
WARN("Es wurde versucht eine leere Formel einzugeben!");
MessageBox(hwnd,"Leere Formeln werden nicht akzeptiert!","Formeleingabe",
MB_ICONEXCLAMATION | MB_OK); SetFocus(items[3].handle); return false; }
break;
};
break;
}
return DefSubclassProc(hwnd,message,wParam,lParam);
}
LRESULT CALLBACK CBookmarksToolbar::BookmarksToolbarProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch(uMsg)
{
case WM_MBUTTONUP:
{
DWORD dwPos = GetMessagePos();
POINT ptCursor;
ptCursor.x = GET_X_LPARAM(dwPos);
ptCursor.y = GET_Y_LPARAM(dwPos);
MapWindowPoints(HWND_DESKTOP,m_hToolbar,&ptCursor,1);
int iIndex = static_cast<int>(SendMessage(m_hToolbar,TB_HITTEST,0,
reinterpret_cast<LPARAM>(&ptCursor)));
if(iIndex >= 0)
{
TBBUTTON tbButton;
SendMessage(m_hToolbar,TB_GETBUTTON,iIndex,reinterpret_cast<LPARAM>(&tbButton));
/* TODO: If this is a bookmark, open it in a new tab. */
}
}
break;
}
return DefSubclassProc(hwnd,uMsg,wParam,lParam);
}
LRESULT CALLBACK CManageBookmarksDialog::EditSearchProc(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam)
{
switch(Msg)
{
case WM_SETFOCUS:
if(m_bSearchFieldBlank)
{
RemoveSearchFieldDefaultState();
}
m_bEditingSearchField = true;
break;
case WM_KILLFOCUS:
if(GetWindowTextLength(hwnd) == 0)
{
m_bSearchFieldBlank = true;
SetSearchFieldDefaultState();
}
else
{
m_bSearchFieldBlank = false;
}
m_bEditingSearchField = false;
break;
}
return DefSubclassProc(hwnd,Msg,wParam,lParam);
}
/**
* Subclass procedure for any dialog control. Reports key press events to
* ooDialog for those key presses connected to an ooDialog method by the user.
*
* All messages are passed on unchanged to the control.
*
* processKeyPress() is used to actually decipher the key press data and set
* up the ooDialog method invocation. That function documents what is sent on
* to the ooDialog method.
*/
LRESULT CALLBACK KeyPressSubclassProc(HWND hwnd, UINT msg, WPARAM wParam,
LPARAM lParam, UINT_PTR id, DWORD_PTR dwData)
{
SUBCLASSDATA *pSubclassData = (SUBCLASSDATA *)dwData;
if ( ! pSubclassData )
{
return DefSubclassProc(hwnd, msg, wParam, lParam);
}
KEYPRESSDATA *pKeyData = (KEYPRESSDATA *)pSubclassData->pData;
switch ( msg )
{
case WM_GETDLGCODE:
/* Don't do anything for now. This message has some interesting
* uses, perhaps a future enhancement.
*/
break;
case WM_SYSKEYDOWN:
/* Sent when the alt key is down. We need both WM_SYSKEYDOWN and
* WM_KEYDOWN to catch everything that a keyboard hook catches.
*/
if ( pKeyData->key[wParam] && !(lParam & KEY_RELEASED) && !(lParam & KEY_WASDOWN) )
{
processKeyPress(pSubclassData, wParam, lParam);
}
break;
case WM_KEYDOWN:
/* WM_KEYDOWN will never have KEY_RELEASED set. */
if ( pKeyData->key[wParam] && !(lParam & KEY_WASDOWN) )
{
processKeyPress(pSubclassData, wParam, lParam);
}
break;
case WM_NCDESTROY:
/* The window is being destroyed, remove the subclass, clean up
* memory.
*/
RemoveWindowSubclass(hwnd, KeyPressSubclassProc, id);
freeKeyPressData(pSubclassData);
break;
}
return DefSubclassProc(hwnd, msg, wParam, lParam);
}
LRESULT CALLBACK MainWndDevicesSubclassProc(
_In_ HWND hWnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam,
_In_ UINT_PTR uIdSubclass,
_In_ ULONG_PTR dwRefData
)
{
// The IOCTL_MOUNTMGR_CHANGE_NOTIFY callback would have been preferred but doesn't work from non-elevated processes?
switch (uMsg)
{
case WM_DEVICECHANGE:
{
switch (wParam)
{
case DBT_DEVICEARRIVAL: // Drive letter added
case DBT_DEVICEREMOVECOMPLETE: // Drive letter removed
{
DEV_BROADCAST_HDR* deviceBroadcast = (DEV_BROADCAST_HDR*)lParam;
if (deviceBroadcast->dbch_devicetype == DBT_DEVTYP_VOLUME)
{
//DEV_BROADCAST_VOLUME* deviceVolume = (DEV_BROADCAST_VOLUME*)deviceBroadcast;
PhAcquireQueuedLockShared(&DiskDrivesListLock);
for (ULONG i = 0; i < DiskDrivesList->Count; i++)
{
PDV_DISK_ENTRY entry;
entry = PhReferenceObjectSafe(DiskDrivesList->Items[i]);
if (!entry)
continue;
// Reset the DiskIndexName so we can re-query the device letter on the next interval update.
PhClearReference(&entry->DiskIndexName);
PhDereferenceObjectDeferDelete(entry);
}
PhReleaseQueuedLockShared(&DiskDrivesListLock);
}
}
}
goto DefaultWndProc;
}
break;
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
DefaultWndProc:
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
LRESULT Control::OnClose(WPARAM wParam, LPARAM lParam)
{
if (IsMainWindow)
{
PostQuitMessage(0);
return 0;
}
return DefSubclassProc(ThisWindow, WM_CLOSE, wParam, lParam);
}
LRESULT Control::OnDestroy(WPARAM wParam, LPARAM lParam)
{
if (IsMainWindow)
{
PostQuitMessage(0);
return 0;
}
return DefSubclassProc(ThisWindow, WM_DESTROY, wParam, lParam);
}
LRESULT CALLBACK CContainer::TabBackingProc(HWND hTabCtrl,
UINT msg,WPARAM wParam,LPARAM lParam)
{
switch(msg)
{
case WM_INITMENU:
SendMessage(m_hContainer,WM_INITMENU,wParam,lParam);
break;
case WM_MEASUREITEM:
{
MEASUREITEMSTRUCT *pMeasureItem = NULL;
pMeasureItem = (MEASUREITEMSTRUCT *)lParam;
pMeasureItem->itemWidth = 20;
pMeasureItem->itemHeight = 10;
}
break;
case WM_LBUTTONDBLCLK:
{
HRESULT hr;
hr = BrowseFolder(m_DefaultTabDirectory,SBSP_ABSOLUTE,TRUE,TRUE,FALSE);
if(FAILED(hr))
BrowseFolder(m_DefaultTabDirectoryStatic,SBSP_ABSOLUTE,TRUE,TRUE,FALSE);
}
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case TABTOOLBAR_CLOSE:
OnCloseTab();
break;
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->code)
{
case TCN_SELCHANGE:
OnTabSelectionChange();
break;
case TTN_GETDISPINFO:
OnTabCtrlGetDispInfo(lParam);
break;
}
break;
}
return DefSubclassProc(hTabCtrl,msg,wParam,lParam);
}
LRESULT CALLBACK fproc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR id, DWORD_PTR data)
{
if(!data) return DefSubclassProc(hwnd, msg, wp, lp);
STATE* state = (STATE*)data;
switch(msg)
{
case WM_WINDOWPOSCHANGING:
if(!state->hwnd)
{
state->hwnd = hwnd;
fenum(state);
}
if(state->rect_list_n > 0) fposchanging(state, (PWINDOWPOS)lp);
break;
}
return DefSubclassProc(hwnd, msg, wp, lp);
} // fproc
LRESULT CALLBACK NoiseGateSettings::PBSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
switch(uMsg)
{
case WM_ERASEBKGND:
return TRUE;
case WM_PAINT:
{
RECT clRect, eclRect;
PAINTSTRUCT ps;
PBRANGE pbRange;
int position;
bool orientation;
float perc;
HBRUSH hGreen = CreateSolidBrush(0x32CD32);
orientation = (GetWindowLongPtr(hWnd, GWL_STYLE) & PBS_VERTICAL) == PBS_VERTICAL; // false = horizontal, true = vertical
position = (int)SendMessage(hWnd, PBM_GETPOS, 0, 0);
SendMessage(hWnd, PBM_GETRANGE, TRUE, (LPARAM)&pbRange);
GetClientRect(hWnd, &clRect);
memcpy(&eclRect, &clRect, sizeof(RECT));
HDC hDC = BeginPaint(hWnd, &ps);
perc = float(position - pbRange.iLow) / float(pbRange.iHigh - pbRange.iLow);
if(orientation)
{
clRect.top = clRect.bottom - int(float(clRect.bottom - clRect.top) * perc);
eclRect.bottom = clRect.top;
}
else
{
clRect.right = clRect.left + int(float(clRect.right - clRect.left) * perc);
eclRect.left = clRect.right;
}
FillRect(hDC, &eclRect, (HBRUSH)COLOR_WINDOW);
FillRect(hDC, &clRect, hGreen);
DeleteObject(hGreen);
EndPaint(hWnd, &ps);
return TRUE;
}
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
static LRESULT CALLBACK WndProcFrameRateAssociated(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
if (WM_MOVING == msg ||
WM_SIZING == msg ||
WM_WINDOWPOSCHANGED == msg ||
WM_MOVE == msg) {
FrameRateWnd *w = (FrameRateWnd*) dwRefData;
PositionWindow(w, w->maxSizeSoFar);
}
return DefSubclassProc(hwnd, msg, wp, lp);
}