LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAERO_SUBCLASS_WND_DATA pWndData = (PAERO_SUBCLASS_WND_DATA)GetProp(hWnd, WINDOW_DATA_STRING);
ASSERT(pWndData);
ASSERT(pWndData->m_pDwmApiImpl);
WNDPROC pOldProc = pWndData->m_oldWndProc;
ASSERT(pOldProc);
BOOL bCompositionEnabled = pWndData->m_pDwmApiImpl->IsDwmCompositionEnabled();
///
/// if aero glass is turned off and if we are not in destruction code,
/// just call the original wnd proc we had prior to subclassing:
///
if(WM_COMMAND!=uMsg && WM_DWMCOMPOSITIONCHANGED!=uMsg && WM_DESTROY!=uMsg && WM_NCDESTROY!=uMsg && !bCompositionEnabled)
return CallWindowProc(pOldProc, hWnd, uMsg, wParam, lParam);
if (uMsg == pWndData->m_uiRedrawMsg)
{
HWND hControl = (HWND)lParam;
ASSERT(hControl);
ASSERT(::IsWindow(hControl));
PAERO_SUBCLASS_WND_DATA pCtrlData = (PAERO_SUBCLASS_WND_DATA)GetProp(hControl, WINDOW_DATA_STRING);
if(pCtrlData && pCtrlData->m_dwFlags & WD_IN_PAINT_CONTROL)
{
HDC hdc = GetDC(hControl);
if(hdc)
{
RECT rc;
VERIFY(GetWindowRect(hControl, &rc));
VERIFY(MapWindowPoints(NULL, hControl, (LPPOINT) &rc, 2));
PaintControl(hControl, hdc, &rc, (pCtrlData->m_dwFlags & WD_DRAW_BORDER)!=0);
VERIFY(1==ReleaseDC(hControl, hdc));
}
pCtrlData->m_dwFlags &= ~WD_IN_PAINT_CONTROL;
return 0;
}
}
switch(uMsg)
{
case WM_CTLCOLORSTATIC:
{
HWND hControl = (HWND)lParam;
ASSERT(hControl);
ASSERT(IsWindow(hControl));
PAERO_SUBCLASS_WND_DATA pCtrlData = (PAERO_SUBCLASS_WND_DATA)GetProp(hControl, WINDOW_DATA_STRING);
if(pCtrlData)
{
if(pCtrlData->m_dwFlags&WD_RETURN_BLACK_BRUSH)
return (LRESULT)GetStockObject(BLACK_BRUSH);
else if(pCtrlData->m_dwFlags&WD_RETURN_WHITE_BRUSH)
return (LRESULT)GetStockObject(WHITE_BRUSH);
else
{
pCtrlData->m_dwFlags|=WD_IN_PAINT_CONTROL;
PostMessage((HWND)lParam, pWndData->m_uiRedrawMsg, 0, NULL);
}
}
}
break;
case WM_CTLCOLOREDIT:
{
PAERO_SUBCLASS_WND_DATA pCtrlData = (PAERO_SUBCLASS_WND_DATA)GetProp((HWND)lParam, WINDOW_DATA_STRING);
if(pCtrlData)
pCtrlData->m_dwFlags|=WD_IN_PAINT_CONTROL;
PostMessage((HWND)lParam, pWndData->m_uiRedrawMsg, 0, NULL);
}
break;
case WM_PAINT:
{
if(!IsIconic(hWnd) && !(pWndData->m_dwFlags&WD_NO_FRAME_EXTEND))
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
///
/// we have to paint the *entire* client area in black, not only the
/// paint area inside ps, because otherwise we get ugly areas of white
/// if we partially move the window out of the desktop and back in again:
///
///
MARGINS marGlassInset = {-1, -1, -1, -1}; // -1 means the whole window
if(hdc && pWndData->m_pDwmApiImpl->IsDwmCompositionEnabled()
&& SUCCEEDED(pWndData->m_pDwmApiImpl->DwmExtendFrameIntoClientArea(hWnd, &marGlassInset)))
{
RECT rcClient;
VERIFY(GetClientRect(hWnd, &rcClient));
VERIFY(PatBlt(hdc, 0, 0, RECTWIDTH(rcClient), RECTHEIGHT(rcClient), BLACKNESS));
}
EndPaint(hWnd, &ps);
return 1;
}
}
break;
case WM_COMMAND:
{
if(bCompositionEnabled)
{
if(LBN_SELCHANGE==HIWORD(wParam))
{
InvalidateRgn((HWND)lParam, NULL, TRUE);
VERIFY(UpdateWindow((HWND)lParam));
}
}
if(ACN_STOP==HIWORD(wParam))
{
///
/// if it is an animation control that has just stopped playing,
/// reset the WD_PLAY flag so it repaints itself properly again if
/// e.g. Aero is turned off an on again:
///
PAERO_SUBCLASS_WND_DATA pCtrlData = (PAERO_SUBCLASS_WND_DATA)GetProp((HWND)lParam, WINDOW_DATA_STRING);
if(pCtrlData)
{
pCtrlData->m_dwFlags&=~WD_PLAY;
}
}
if(ACN_START==HIWORD(wParam))
{
PAERO_SUBCLASS_WND_DATA pCtrlData = (PAERO_SUBCLASS_WND_DATA)GetProp((HWND)lParam, WINDOW_DATA_STRING);
if(pCtrlData)
{
pCtrlData->m_dwFlags|=WD_PLAY;
}
}
}
break;
case WM_NOTIFY:
{
LPNMHDR lpnmh = (LPNMHDR)lParam;
if(lpnmh)
{
ASSERT(lpnmh->hwndFrom);
ASSERT(IsWindow(lpnmh->hwndFrom));
switch(lpnmh->code)
{
case LVN_ITEMCHANGED:
{
///
/// if we select and deselect list view items,
/// its header control sometimes vanishes so
/// we have to force a redraw:
///
HWND hHeader = ListView_GetHeader(lpnmh->hwndFrom);
if(hHeader)
{
InvalidateRgn(hHeader, NULL, TRUE);
VERIFY(UpdateWindow(hHeader));
}
}
break;
default:
break;
}
}
}
break;
case WM_DESTROY:
ASSERT(pWndData->m_pUxTheme);
ASSERT(pWndData->m_pDwmApiImpl);
VERIFY(SUCCEEDED(pWndData->m_pUxTheme->BufferedPaintUnInit()));
delete pWndData->m_pUxTheme;
delete pWndData->m_pDwmApiImpl;
if(WndProc==(WNDPROC)GetWindowLongPtr(hWnd, GWLP_WNDPROC))
{
VERIFY(WndProc==(WNDPROC) SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR) pWndData->m_oldWndProc));
VERIFY(pWndData==RemoveProp(hWnd, WINDOW_DATA_STRING));
VERIFY(!LocalFree(pWndData));
}
break;
case WM_NCDESTROY:
if(WndProc==(WNDPROC)GetWindowLongPtr(hWnd, GWLP_WNDPROC))
{
VERIFY(WndProc==(WNDPROC) SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR) pWndData->m_oldWndProc));
VERIFY(pWndData==RemoveProp(hWnd, WINDOW_DATA_STRING));
VERIFY(!LocalFree(pWndData));
}
break;
}
return CallWindowProc(pOldProc, hWnd, uMsg, wParam, lParam);
}
INT_PTR CALLBACK EspServiceTriggersDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PSERVICE_TRIGGERS_CONTEXT context;
if (uMsg == WM_INITDIALOG)
{
context = PhAllocate(sizeof(SERVICE_TRIGGERS_CONTEXT));
memset(context, 0, sizeof(SERVICE_TRIGGERS_CONTEXT));
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PSERVICE_TRIGGERS_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_DESTROY)
RemoveProp(hwndDlg, L"Context");
}
if (!context)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
NTSTATUS status;
LPPROPSHEETPAGE propSheetPage = (LPPROPSHEETPAGE)lParam;
PPH_SERVICE_ITEM serviceItem = (PPH_SERVICE_ITEM)propSheetPage->lParam;
HWND triggersLv;
context->ServiceItem = serviceItem;
context->TriggersLv = triggersLv = GetDlgItem(hwndDlg, IDC_TRIGGERS);
context->TriggerContext = EsCreateServiceTriggerContext(
context->ServiceItem,
hwndDlg,
triggersLv
);
status = EspLoadTriggerInfo(hwndDlg, context);
if (!NT_SUCCESS(status))
{
PhShowWarning(hwndDlg, L"Unable to query service trigger information: %s",
((PPH_STRING)PH_AUTO(PhGetNtMessage(status)))->Buffer);
}
}
break;
case WM_DESTROY:
{
EsDestroyServiceTriggerContext(context->TriggerContext);
PhFree(context);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_NEW:
if (context->TriggerContext)
EsHandleEventServiceTrigger(context->TriggerContext, ES_TRIGGER_EVENT_NEW);
break;
case IDC_EDIT:
if (context->TriggerContext)
EsHandleEventServiceTrigger(context->TriggerContext, ES_TRIGGER_EVENT_EDIT);
break;
case IDC_DELETE:
if (context->TriggerContext)
EsHandleEventServiceTrigger(context->TriggerContext, ES_TRIGGER_EVENT_DELETE);
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_KILLACTIVE:
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, FALSE);
}
return TRUE;
case PSN_APPLY:
{
ULONG win32Result = 0;
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
if (!EsSaveServiceTriggerInfo(context->TriggerContext, &win32Result))
{
if (win32Result == ERROR_CANCELLED || (PhShowMessage(
hwndDlg,
MB_ICONERROR | MB_RETRYCANCEL,
L"Unable to change service trigger information: %s",
((PPH_STRING)PH_AUTO(PhGetWin32Message(win32Result)))->Buffer
) == IDRETRY))
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID);
}
}
return TRUE;
}
break;
case LVN_ITEMCHANGED:
{
if (header->hwndFrom == context->TriggersLv && context->TriggerContext)
{
EsHandleEventServiceTrigger(context->TriggerContext, ES_TRIGGER_EVENT_SELECTIONCHANGED);
}
}
break;
case NM_DBLCLK:
{
if (header->hwndFrom == context->TriggersLv && context->TriggerContext)
{
EsHandleEventServiceTrigger(context->TriggerContext, ES_TRIGGER_EVENT_EDIT);
}
}
break;
}
}
break;
}
return FALSE;
}
LRESULT CALLBACK NcAreaWndSubclassProc(
_In_ HWND hWnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam,
_In_ UINT_PTR uIdSubclass,
_In_ ULONG_PTR dwRefData
)
{
PEDIT_CONTEXT context;
context = (PEDIT_CONTEXT)GetProp(hWnd, L"EditSubclassContext");
switch (uMsg)
{
case WM_NCDESTROY:
{
NcAreaFreeTheme(context);
if (context->ImageList)
ImageList_Destroy(context->ImageList);
if (context->WindowFont)
DeleteObject(context->WindowFont);
RemoveWindowSubclass(hWnd, NcAreaWndSubclassProc, uIdSubclass);
RemoveProp(hWnd, L"EditSubclassContext");
PhFree(context);
}
break;
case WM_ERASEBKGND:
return 1;
case WM_NCCALCSIZE:
{
LPNCCALCSIZE_PARAMS ncCalcSize = (NCCALCSIZE_PARAMS*)lParam;
// Let Windows handle the non-client defaults.
DefSubclassProc(hWnd, uMsg, wParam, lParam);
// Deflate the client area to accommodate the custom button.
ncCalcSize->rgrc[0].right -= context->CXWidth;
}
return 0;
case WM_NCPAINT:
{
RECT windowRect;
// Let Windows handle the non-client defaults.
DefSubclassProc(hWnd, uMsg, wParam, lParam);
// Get the screen coordinates of the window.
GetWindowRect(hWnd, &windowRect);
// Adjust the coordinates (start from 0,0).
OffsetRect(&windowRect, -windowRect.left, -windowRect.top);
// Get the position of the inserted button.
NcAreaGetButtonRect(context, &windowRect);
// Draw the button.
NcAreaDrawButton(context, windowRect);
}
return 0;
case WM_NCHITTEST:
{
POINT windowPoint;
RECT windowRect;
// Get the screen coordinates of the mouse.
windowPoint.x = GET_X_LPARAM(lParam);
windowPoint.y = GET_Y_LPARAM(lParam);
// Get the position of the inserted button.
GetWindowRect(hWnd, &windowRect);
NcAreaGetButtonRect(context, &windowRect);
// Check that the mouse is within the inserted button.
if (PtInRect(&windowRect, windowPoint))
{
return HTBORDER;
}
}
break;
case WM_NCLBUTTONDOWN:
{
POINT windowPoint;
RECT windowRect;
// Get the screen coordinates of the mouse.
windowPoint.x = GET_X_LPARAM(lParam);
windowPoint.y = GET_Y_LPARAM(lParam);
// Get the position of the inserted button.
GetWindowRect(hWnd, &windowRect);
NcAreaGetButtonRect(context, &windowRect);
// Check that the mouse is within the inserted button.
if (PtInRect(&windowRect, windowPoint))
{
context->Pushed = TRUE;
SetCapture(hWnd);
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
}
break;
case WM_LBUTTONUP:
{
POINT windowPoint;
RECT windowRect;
// Get the screen coordinates of the mouse.
windowPoint.x = GET_X_LPARAM(lParam);
windowPoint.y = GET_Y_LPARAM(lParam);
// Get the screen coordinates of the window.
GetWindowRect(hWnd, &windowRect);
// Adjust the coordinates (start from 0,0).
OffsetRect(&windowRect, -windowRect.left, -windowRect.top);
// Get the position of the inserted button.
NcAreaGetButtonRect(context, &windowRect);
// Check that the mouse is within the inserted button.
if (PtInRect(&windowRect, windowPoint))
{
// Forward click notification.
SendMessage(PhMainWndHandle, WM_COMMAND, MAKEWPARAM(context->CommandID, BN_CLICKED), 0);
}
if (GetCapture() == hWnd)
{
context->Pushed = FALSE;
ReleaseCapture();
}
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
break;
case WM_KEYDOWN:
{
if (wParam == '\t' || wParam == '\r')
{
HWND tnHandle;
tnHandle = GetCurrentTreeNewHandle();
if (tnHandle)
{
SetFocus(tnHandle);
if (wParam == '\r')
{
if (TreeNew_GetFlatNodeCount(tnHandle) > 0)
{
TreeNew_DeselectRange(tnHandle, 0, -1);
TreeNew_SelectRange(tnHandle, 0, 0);
TreeNew_SetFocusNode(tnHandle, TreeNew_GetFlatNode(tnHandle, 0));
TreeNew_SetMarkNode(tnHandle, TreeNew_GetFlatNode(tnHandle, 0));
}
}
}
else
{
PTOOLSTATUS_TAB_INFO tabInfo;
if ((tabInfo = FindTabInfo(SelectedTabIndex)) && tabInfo->ActivateContent)
tabInfo->ActivateContent(wParam == '\r');
}
return FALSE;
}
// Handle CTRL+A below Vista.
if (WindowsVersion < WINDOWS_VISTA && (GetKeyState(VK_CONTROL) & VK_LCONTROL) && wParam == 'A')
{
Edit_SetSel(hWnd, 0, -1);
return FALSE;
}
}
break;
case WM_CHAR:
if (wParam == '\t' || wParam == '\r')
return FALSE;
break;
case WM_CUT:
case WM_CLEAR:
case WM_PASTE:
case WM_UNDO:
case WM_KEYUP:
case WM_SETTEXT:
case WM_KILLFOCUS:
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
break;
case WM_SETTINGCHANGE:
case WM_SYSCOLORCHANGE:
case WM_THEMECHANGED:
{
NcAreaFreeTheme(context);
NcAreaInitializeTheme(context);
NcAreaInitializeFont(context);
// Reset the client area margins.
SendMessage(hWnd, EM_SETMARGINS, EC_LEFTMARGIN, MAKELPARAM(0, 0));
// Force the edit control to update its non-client area.
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
//SetWindowPos(hWnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
}
break;
case WM_SETFOCUS:
{
if (SearchBoxDisplayMode != SEARCHBOX_DISPLAY_MODE_HIDEINACTIVE)
break;
if (!RebarBandExists(REBAR_BAND_ID_SEARCHBOX))
{
UINT height = (UINT)SendMessage(RebarHandle, RB_GETROWHEIGHT, 0, 0);
RebarBandInsert(REBAR_BAND_ID_SEARCHBOX, SearchboxHandle, PhMultiplyDivide(180, PhGlobalDpi, 96), height - 2);
}
}
break;
case WM_NCMOUSEMOVE:
{
POINT windowPoint;
RECT windowRect;
// Get the screen coordinates of the mouse.
windowPoint.x = GET_X_LPARAM(lParam);
windowPoint.y = GET_Y_LPARAM(lParam);
// Get the screen coordinates of the window.
GetWindowRect(hWnd, &windowRect);
// Get the position of the inserted button.
NcAreaGetButtonRect(context, &windowRect);
// Check that the mouse is within the inserted button.
if (PtInRect(&windowRect, windowPoint))
{
if (!context->Hot)
{
TRACKMOUSEEVENT trackMouseEvent = { sizeof(TRACKMOUSEEVENT) };
trackMouseEvent.dwFlags = TME_LEAVE | TME_NONCLIENT;
trackMouseEvent.hwndTrack = hWnd;
context->Hot = TRUE;
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
TrackMouseEvent(&trackMouseEvent);
}
}
}
break;
case WM_NCMOUSELEAVE:
{
if (context->Hot)
{
context->Hot = FALSE;
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
}
break;
case WM_MOUSEMOVE:
{
if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
{
POINT windowPoint;
RECT windowRect;
// Get the screen coordinates of the mouse.
windowPoint.x = GET_X_LPARAM(lParam);
windowPoint.y = GET_Y_LPARAM(lParam);
// Get the screen coordinates of the window.
GetWindowRect(hWnd, &windowRect);
// Adjust the coordinates (start from 0,0).
OffsetRect(&windowRect, -windowRect.left, -windowRect.top);
// Get the position of the inserted button.
NcAreaGetButtonRect(context, &windowRect);
// Check that the mouse is within the inserted button.
context->Pushed = PtInRect(&windowRect, windowPoint);
RedrawWindow(hWnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
}
}
break;
}
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
INT_PTR CALLBACK RestartComputerDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PSERVICE_RECOVERY_CONTEXT context;
if (uMsg == WM_INITDIALOG)
{
context = (PSERVICE_RECOVERY_CONTEXT)lParam;
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PSERVICE_RECOVERY_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_DESTROY)
RemoveProp(hwndDlg, L"Context");
}
if (!context)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
SetDlgItemInt(hwndDlg, IDC_RESTARTCOMPAFTER, context->RebootAfter / (1000 * 60), FALSE); // ms to min
Button_SetCheck(GetDlgItem(hwndDlg, IDC_ENABLERESTARTMESSAGE), context->RebootMessage ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemText(hwndDlg, IDC_RESTARTMESSAGE, PhGetString(context->RebootMessage));
SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwndDlg, IDC_RESTARTCOMPAFTER), TRUE);
Edit_SetSel(GetDlgItem(hwndDlg, IDC_RESTARTCOMPAFTER), 0, -1);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
break;
case IDOK:
{
context->RebootAfter = GetDlgItemInt(hwndDlg, IDC_RESTARTCOMPAFTER, NULL, FALSE) * 1000 * 60;
if (Button_GetCheck(GetDlgItem(hwndDlg, IDC_ENABLERESTARTMESSAGE)) == BST_CHECKED)
PhMoveReference(&context->RebootMessage, PhGetWindowText(GetDlgItem(hwndDlg, IDC_RESTARTMESSAGE)));
else
PhClearReference(&context->RebootMessage);
context->Dirty = TRUE;
EndDialog(hwndDlg, IDOK);
}
break;
case IDC_USEDEFAULTMESSAGE:
{
PPH_STRING message;
PWSTR computerName;
ULONG bufferSize;
BOOLEAN allocated = TRUE;
// Get the computer name.
bufferSize = 64;
computerName = PhAllocate((bufferSize + 1) * sizeof(WCHAR));
if (!GetComputerName(computerName, &bufferSize))
{
PhFree(computerName);
computerName = PhAllocate((bufferSize + 1) * sizeof(WCHAR));
if (!GetComputerName(computerName, &bufferSize))
{
PhFree(computerName);
computerName = L"(unknown)";
allocated = FALSE;
}
}
// This message is exactly the same as the one in the Services console,
// except the double spaces are replaced by single spaces.
message = PhFormatString(
L"Your computer is connected to the computer named %s. "
L"The %s service on %s has ended unexpectedly. "
L"%s will restart automatically, and then you can reestablish the connection.",
computerName,
context->ServiceItem->Name->Buffer,
computerName,
computerName
);
SetDlgItemText(hwndDlg, IDC_RESTARTMESSAGE, message->Buffer);
PhDereferenceObject(message);
if (allocated)
PhFree(computerName);
Button_SetCheck(GetDlgItem(hwndDlg, IDC_ENABLERESTARTMESSAGE), BST_CHECKED);
}
break;
case IDC_RESTARTMESSAGE:
{
if (HIWORD(wParam) == EN_CHANGE)
{
// A zero length restart message disables it, so we might as well uncheck the box.
Button_SetCheck(GetDlgItem(hwndDlg, IDC_ENABLERESTARTMESSAGE),
GetWindowTextLength(GetDlgItem(hwndDlg, IDC_RESTARTMESSAGE)) != 0 ? BST_CHECKED : BST_UNCHECKED);
}
}
break;
}
}
break;
}
return FALSE;
}
LRESULT FrameWindow::FrameWndProc(HWND hWndFrame, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
FrameWindow* frame = (FrameWindow*)GetProp(hWndFrame, L"FrameWindowPointer");
switch(uMsg)
{
case WM_NCCREATE:
if(NULL == frame)
{
frame = new FrameWindow(hWndFrame);
SetProp(hWndFrame, L"FrameWindowPointer", frame);
}
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDM_ABOUT:
DialogBox((HINSTANCE)GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_ABOUTBOX), hWndFrame, AboutDialog::About);
break;
case IDM_NEW:
frame->NewDocument(wParam, lParam);
break;
case IDM_EXIT:
DestroyWindow(hWndFrame);
break;
default:
if(frame)
return DefFrameProc(hWndFrame, frame->hClientWnd, uMsg, wParam, lParam);
else
return DefFrameProc(hWndFrame, NULL, uMsg, wParam, lParam);
}
break;
case WM_CREATE:
return frame->Create(wParam, lParam);
case WM_NCDESTROY:
RemoveProp(hWndFrame, L"FrameWindowPointer"); // remove the C++ object pointer from the property list
if(frame)
delete frame;
PostQuitMessage(0);
return 0;
case WM_SIZE:
return frame->Size(wParam, lParam);
default:
if(frame)
return DefFrameProc(hWndFrame, frame->hClientWnd, uMsg, wParam, lParam);
else
return DefFrameProc(hWndFrame, NULL, uMsg, wParam, lParam);
}
if(frame)
return DefFrameProc(hWndFrame, frame->hClientWnd, uMsg, wParam, lParam);
else
return DefFrameProc(hWndFrame, NULL, uMsg, wParam, lParam);
}
CWindowBase::~CWindowBase()
{
RemoveProp(m_hWnd, _T("CWindowBase"));
}
BOOL FAR PASCAL CfgEdtBox (HWND hWnd, unsigned uMsg, WPARAM wParam,
LPARAM lParam)
{
#define PRPLOW "PrpLow"
#define PRPHGH "PrpHgh"
DIGCFG FAR * lpDigCfg; /* Inst local data block ptr */
BOOL bfXlt_OK;
switch (uMsg) {
case WM_INITDIALOG:
/****************************************************************/
/* Store instance specific data pointer */
/****************************************************************/
if (!SetProp (hWnd, PRPLOW, (HANDLE) LOWORD (lParam)) ||
!SetProp (hWnd, PRPHGH, (HANDLE) HIWORD (lParam))) {
EndDialog (hWnd, -1);
break;
}
lpDigCfg = (DIGCFG FAR *) lParam;
/****************************************************************/
/****************************************************************/
CtrDlgBox (NULL, hWnd, NULL, CTR_CTR);
/****************************************************************/
SetDlgItemInt (hWnd, DI_LVLINP, lpDigCfg->usLvlInp, FALSE);
SetDlgItemInt (hWnd, DI_LVLOUT, lpDigCfg->usLvlOut, FALSE);
/************************************************************/
/* Set focus on 1st edit cntrl, ask Windows not to override */
/************************************************************/
SetFocus (GetDlgItem (hWnd, IDOK));
return (FALSE);
case WM_CTLCOLOR:
if ((CTLCOLOR_DLG == HIWORD (lParam))
|| (CTLCOLOR_STATIC == HIWORD (lParam))
|| (CTLCOLOR_BTN == HIWORD (lParam))) {
SetBkColor ((HDC) wParam, MCIGlo.ulDBxClr);
return ((BOOL) MCIGlo.hDBxBsh);
}
return (FALSE);
case WM_COMMAND:
if (NULL == (lpDigCfg = (DIGCFG FAR *)
MAKELONG (GetProp (hWnd, PRPLOW), GetProp (hWnd, PRPHGH)))) {
EndDialog (hWnd, -1);
break;
}
switch(wParam) {
/****************************************************************/
/****************************************************************/
case IDOK:
lpDigCfg->usLvlInp = GetDlgItemInt (hWnd, DI_LVLINP, &bfXlt_OK, FALSE);
lpDigCfg->usLvlOut = GetDlgItemInt (hWnd, DI_LVLOUT, &bfXlt_OK, FALSE);
EndDialog(hWnd, 0);
return(TRUE);
case IDCANCEL:
EndDialog(hWnd, -1);
return(TRUE);
default:
return(FALSE);
}
break;
case WM_DESTROY:
RemoveProp (hWnd, PRPLOW);
RemoveProp (hWnd, PRPHGH);
break;
default:
return(FALSE);
}
return(FALSE);
}
static INT_PTR CALLBACK PhpProcessTerminatorDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
PPH_PROCESS_ITEM processItem = (PPH_PROCESS_ITEM)lParam;
PPH_STRING title;
HWND lvHandle;
HIMAGELIST imageList;
ULONG i;
PhCenterWindow(hwndDlg, GetParent(hwndDlg));
title = PhFormatString(
L"Terminator - %s (%u)",
processItem->ProcessName->Buffer,
(ULONG)processItem->ProcessId
);
SetWindowText(hwndDlg, title->Buffer);
PhDereferenceObject(title);
SetProp(hwndDlg, L"ProcessItem", (HANDLE)processItem);
lvHandle = GetDlgItem(hwndDlg, IDC_TERMINATOR_LIST);
PhAddListViewColumn(lvHandle, 0, 0, 0, LVCFMT_LEFT, 70, L"ID");
PhAddListViewColumn(lvHandle, 1, 1, 1, LVCFMT_LEFT, 280, L"Description");
ListView_SetExtendedListViewStyleEx(lvHandle, LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP | LVS_EX_LABELTIP | LVS_EX_CHECKBOXES, -1);
PhSetControlTheme(lvHandle, L"explorer");
imageList = ImageList_Create(16, 16, ILC_COLOR32, 0, 0);
ImageList_SetImageCount(imageList, 2);
PhSetImageListBitmap(imageList, CROSS_INDEX, PhInstanceHandle, MAKEINTRESOURCE(IDB_CROSS));
PhSetImageListBitmap(imageList, TICK_INDEX, PhInstanceHandle, MAKEINTRESOURCE(IDB_TICK));
for (i = 0; i < sizeof(PhTerminatorTests) / sizeof(TEST_ITEM); i++)
{
INT itemIndex;
BOOLEAN check;
itemIndex = PhAddListViewItem(
lvHandle,
MAXINT,
PhTerminatorTests[i].Id,
&PhTerminatorTests[i]
);
PhSetListViewSubItem(lvHandle, itemIndex, 1, PhTerminatorTests[i].Description);
PhSetListViewItemImageIndex(lvHandle, itemIndex, -1);
check = TRUE;
if (WSTR_EQUAL(PhTerminatorTests[i].Id, L"TT4") || WSTR_EQUAL(PhTerminatorTests[i].Id, L"M1"))
check = FALSE;
ListView_SetCheckState(lvHandle, itemIndex, check);
}
ListView_SetImageList(lvHandle, imageList, LVSIL_SMALL);
SetDlgItemText(
hwndDlg,
IDC_TERMINATOR_TEXT,
L"Double-click a termination method or click Run Selected."
);
}
break;
case WM_DESTROY:
{
RemoveProp(hwndDlg, L"ProcessItem");
}
break;
case WM_COMMAND:
{
INT id = LOWORD(wParam);
switch (id)
{
case IDCANCEL: // Esc and X button to close
case IDOK:
EndDialog(hwndDlg, IDOK);
break;
case IDC_RUNSELECTED:
{
if (PhShowConfirmMessage(hwndDlg, L"run", L"the selected terminator tests", NULL, FALSE))
{
HWND lvHandle;
ULONG i;
lvHandle = GetDlgItem(hwndDlg, IDC_TERMINATOR_LIST);
for (i = 0; i < sizeof(PhTerminatorTests) / sizeof(TEST_ITEM); i++)
{
if (ListView_GetCheckState(lvHandle, i))
{
if (PhpRunTerminatorTest(
hwndDlg,
i
))
break;
}
}
}
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
if (header->hwndFrom == GetDlgItem(hwndDlg, IDC_TERMINATOR_LIST))
{
if (header->code == NM_DBLCLK)
{
LPNMITEMACTIVATE itemActivate = (LPNMITEMACTIVATE)header;
if (itemActivate->iItem != -1)
{
if (PhShowConfirmMessage(hwndDlg, L"run", L"the selected test", NULL, FALSE))
{
PhpRunTerminatorTest(
hwndDlg,
itemActivate->iItem
);
}
}
}
else if (header->code == LVN_ITEMCHANGED)
{
ULONG i;
BOOLEAN oneSelected;
oneSelected = FALSE;
for (i = 0; i < sizeof(PhTerminatorTests) / sizeof(TEST_ITEM); i++)
{
if (ListView_GetCheckState(header->hwndFrom, i))
{
oneSelected = TRUE;
break;
}
}
EnableWindow(GetDlgItem(hwndDlg, IDC_RUNSELECTED), oneSelected);
}
}
}
break;
}
return FALSE;
}
inline BOOL HookHandle(UINT MessageId, HWND hWnd, WPARAM wParam, LPARAM lParam)
{
////////////////////////////////////////////////////////////////
// HANDLE DEFERRED UPDATES
// Is this a deferred-update message?
if (MessageId == VNC_DEFERRED_UPDATE)
{
// NOTE : NEVER use the SendDeferred- routines to send updates
// from here, or you'll get an infinite loop....!
// NB : The format of DEFERRED_UPDATE matches that of UpdateRectMessage,
// so just send the exact same message data to WinVNC
PostThreadMessage(
vnc_thread_id,
UpdateRectMessage,
wParam,
lParam
);
return FALSE;
}
// *** Could use WM_COPYDATA to send data to WinVNC
/*
if (GetClassLong(hWnd, GCW_ATOM) == 32768)
{
_RPT4(_CRT_WARN, "DBG : popup menu message (hwnd=%d, msg=%d, l=%d, w=%d)\n",
hWnd, MessageId, lParam, wParam);
}
*/
////////////////////////////////////////////////////////////////
// UPDATE-TRIGGERING MESSAGES
// Do something dependent upon message type
switch (MessageId)
{
////////////////////////////////////////////////////////////////
// Messages indicating only a border repaint.
case WM_NCPAINT:
case WM_NCACTIVATE:
SendDeferredBorderRect(hWnd);
old_cursor = NULL;
break;
////////////////////////////////////////////////////////////////
// Messages indicating a client area repaint
case WM_CHAR:
case WM_KEYUP: // Handle key-presses
case WM_KEYDOWN:
if (prf_use_KeyPress)
SendDeferredWindowRect(hWnd);
break;
case WM_LBUTTONUP: // Handle LMB clicks
if (prf_use_LButtonUp)
SendDeferredWindowRect(hWnd);
break;
case WM_MBUTTONUP: // Handle MMB clicks
if (prf_use_MButtonUp)
SendDeferredWindowRect(hWnd);
break;
case WM_RBUTTONUP: // Handle RMB clicks
if (prf_use_RButtonUp)
SendDeferredWindowRect(hWnd);
break;
case WM_TIMER:
if (prf_use_Timer)
SendDeferredWindowRect(hWnd);
break;
case WM_HSCROLL:
case WM_VSCROLL:
if (((int) LOWORD(wParam) == SB_THUMBTRACK) || ((int) LOWORD(wParam) == SB_ENDSCROLL))
SendDeferredWindowRect(hWnd);
break;
case 485: // HACK to handle popup menus
{
// Get the old popup menu selection value
HANDLE prop = GetProp(hWnd, (LPCTSTR) MAKELONG(VNC_POPUPSELN_ATOM, 0));
if (prop != (HANDLE) wParam)
{
// It did, so update the menu & the selection value
SendDeferredWindowRect(hWnd);
SetProp(hWnd,
(LPCTSTR) MAKELONG(VNC_POPUPSELN_ATOM, 0),
(HANDLE) wParam);
}
}
break;
////////////////////////////////////////////////////////////////
// Messages indicating a full window update
case WM_SYSCOLORCHANGE:
case WM_PALETTECHANGED:
case WM_SETTEXT:
case WM_ENABLE:
case BM_SETCHECK:
case BM_SETSTATE:
case EM_SETSEL:
//case WM_MENUSELECT:
SendDeferredWindowRect(hWnd);
break;
////////////////////////////////////////////////////////////////
// Messages indicating that an area of the window needs updating
// Uses GetUpdateRect to find out which
case WM_PAINT:
if (prf_use_GetUpdateRect)
{
HRGN region;
region = CreateRectRgn(0, 0, 0, 0);
// Get the affected region
if (GetUpdateRgn(hWnd, region, FALSE) != ERROR)
{
int buffsize;
UINT x;
RGNDATA *buff;
POINT TopLeft;
// Get the top-left point of the client area
TopLeft.x = 0;
TopLeft.y = 0;
if (!ClientToScreen(hWnd, &TopLeft))
break;
// Get the size of buffer required
buffsize = GetRegionData(region, 0, 0);
if (buffsize != 0)
{
buff = (RGNDATA *) new BYTE [buffsize];
if (buff == NULL)
break;
// Now get the region data
if(GetRegionData(region, buffsize, buff))
{
for (x=0; x<(buff->rdh.nCount); x++)
{
// Obtain the rectangles from the list
RECT *urect = (RECT *) (((BYTE *) buff) + sizeof(RGNDATAHEADER) + (x * sizeof(RECT)));
SendDeferredUpdateRect(
hWnd,
(SHORT) (TopLeft.x + urect->left),
(SHORT) (TopLeft.y + urect->top),
(SHORT) (TopLeft.x + urect->right),
(SHORT) (TopLeft.y + urect->bottom)
);
// Modified by mws for VNC ver. 3.3.6
// We yield this thread so our PostMessages and socket commands
// can complete, otherwise this hook can suck up too many
// timeslices before it returns
Sleep (0);
}
}
delete [] buff;
}
}
// Now free the region
if (region != NULL)
DeleteObject(region);
}
else
SendDeferredWindowRect(hWnd);
break;
////////////////////////////////////////////////////////////////
// Messages indicating full repaint of this and a different window
// Send the new position of the window
case WM_WINDOWPOSCHANGING:
if (IsWindowVisible(hWnd))
SendWindowRect(hWnd);
break;
case WM_WINDOWPOSCHANGED:
if (IsWindowVisible(hWnd))
SendDeferredWindowRect(hWnd);
break;
////////////////////////////////////////////////////////////////
// WinVNC also wants to know about mouse movement
case WM_NCMOUSEMOVE:
case WM_MOUSEMOVE:
// Inform WinVNC that the mouse has moved and pass it the current cursor handle
{
ULONG new_cursor = (ULONG)GetCursor();
if (new_cursor != old_cursor) {
PostThreadMessage(
vnc_thread_id,
MouseMoveMessage,
(ULONG) new_cursor, 0);
old_cursor=new_cursor;
}
}
break;
// RealVNC 335
case WM_MOUSEWHEEL: // Handle mousewheel events
SendDeferredWindowRect(hWnd);
break;
////////////////////////////////////////////////////////////////
// VNCHOOKS PROPERTIES HANDLING WINDOWS
case WM_DESTROY:
RemoveProp(hWnd, (LPCTSTR) MAKELONG(VNC_POPUPSELN_ATOM, 0));
break;
}
return TRUE;
}
Bool
winCloseScreenPrimaryDD (int nIndex, ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
Bool fReturn;
ErrorF ("winCloseScreenPrimaryDD - Freeing screen resources\n");
/* Flag that the screen is closed */
pScreenPriv->fClosed = TRUE;
pScreenPriv->fActive = FALSE;
/* Call the wrapped CloseScreen procedure */
pScreen->CloseScreen = pScreenPriv->CloseScreen;
fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
/* Delete the window property */
RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
/* Free the offscreen surface, if there is one */
if (pScreenPriv->pddsOffscreen)
{
IDirectDrawSurface2_Unlock (pScreenPriv->pddsOffscreen, NULL);
IDirectDrawSurface2_Release (pScreenPriv->pddsOffscreen);
pScreenPriv->pddsOffscreen = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary)
{
IDirectDrawSurface2_Unlock (pScreenPriv->pddsPrimary, NULL);
IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
pScreenPriv->pddsPrimary = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd)
{
IDirectDraw2_RestoreDisplayMode (pScreenPriv->pdd);
IDirectDraw2_Release (pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Delete tray icon, if we have one */
if (!pScreenInfo->fNoTrayIcon)
winDeleteNotifyIcon (pScreenPriv);
/* Free the exit confirmation dialog box, if it exists */
if (g_hDlgExit != NULL)
{
DestroyWindow (g_hDlgExit);
g_hDlgExit = NULL;
}
/* Kill our window */
if (pScreenPriv->hwndScreen)
{
DestroyWindow (pScreenPriv->hwndScreen);
pScreenPriv->hwndScreen = NULL;
}
/* Kill our screeninfo's pointer to the screen */
pScreenInfo->pScreen = NULL;
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
/* Free the screen privates for this screen */
free ((pointer) pScreenPriv);
return fReturn;
}
INT_PTR CALLBACK PhpChooseProcessDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PCHOOSE_PROCESS_DIALOG_CONTEXT context = NULL;
if (uMsg == WM_INITDIALOG)
{
context = (PCHOOSE_PROCESS_DIALOG_CONTEXT)lParam;
SetProp(hwndDlg, PhMakeContextAtom(), (HANDLE)context);
}
else
{
context = (PCHOOSE_PROCESS_DIALOG_CONTEXT)GetProp(hwndDlg, PhMakeContextAtom());
if (uMsg == WM_DESTROY)
{
RemoveProp(hwndDlg, PhMakeContextAtom());
}
}
if (!context)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
HWND lvHandle;
PhCenterWindow(hwndDlg, GetParent(hwndDlg));
SetDlgItemText(hwndDlg, IDC_MESSAGE, context->Message);
PhInitializeLayoutManager(&context->LayoutManager, hwndDlg);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_MESSAGE), NULL,
PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT | PH_LAYOUT_FORCE_INVALIDATE);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_LIST), NULL,
PH_ANCHOR_ALL);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDOK), NULL,
PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDCANCEL), NULL,
PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_REFRESH), NULL,
PH_ANCHOR_BOTTOM | PH_ANCHOR_LEFT);
PhLayoutManagerLayout(&context->LayoutManager);
context->MinimumSize.left = 0;
context->MinimumSize.top = 0;
context->MinimumSize.right = 280;
context->MinimumSize.bottom = 170;
MapDialogRect(hwndDlg, &context->MinimumSize);
context->ListViewHandle = lvHandle = GetDlgItem(hwndDlg, IDC_LIST);
context->ImageList = ImageList_Create(PhSmallIconSize.X, PhSmallIconSize.Y, ILC_COLOR32 | ILC_MASK, 0, 40);
PhSetListViewStyle(lvHandle, FALSE, TRUE);
PhSetControlTheme(lvHandle, L"explorer");
PhAddListViewColumn(lvHandle, 0, 0, 0, LVCFMT_LEFT, 180, L"Name");
PhAddListViewColumn(lvHandle, 1, 1, 1, LVCFMT_LEFT, 60, L"PID");
PhAddListViewColumn(lvHandle, 2, 2, 2, LVCFMT_LEFT, 160, L"User name");
PhSetExtendedListView(lvHandle);
ListView_SetImageList(lvHandle, context->ImageList, LVSIL_SMALL);
PhpRefreshProcessList(hwndDlg, context);
EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
}
break;
case WM_DESTROY:
{
ImageList_Destroy(context->ImageList);
PhDeleteLayoutManager(&context->LayoutManager);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
{
EndDialog(hwndDlg, IDCANCEL);
}
break;
case IDOK:
{
if (ListView_GetSelectedCount(context->ListViewHandle) == 1)
{
context->ProcessId = (HANDLE)PhGetSelectedListViewItemParam(context->ListViewHandle);
EndDialog(hwndDlg, IDOK);
}
}
break;
case IDC_REFRESH:
{
PhpRefreshProcessList(hwndDlg, context);
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case LVN_ITEMCHANGED:
{
EnableWindow(GetDlgItem(hwndDlg, IDOK), ListView_GetSelectedCount(context->ListViewHandle) == 1);
}
break;
case NM_DBLCLK:
{
SendMessage(hwndDlg, WM_COMMAND, IDOK, 0);
}
break;
}
}
break;
case WM_SIZE:
{
PhLayoutManagerLayout(&context->LayoutManager);
}
break;
case WM_SIZING:
{
PhResizingMinimumSize((PRECT)lParam, wParam, context->MinimumSize.right, context->MinimumSize.bottom);
}
break;
}
return FALSE;
}
static LRESULT WINAPI lv_newProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
WNDPROC oldproc = (WNDPROC)GetProp(hwnd,WDL_UTF8_OLDPROCPROP);
if (!oldproc) return 0;
if (msg==WM_NCDESTROY)
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC,(INT_PTR)oldproc);
RemoveProp(hwnd,WDL_UTF8_OLDPROCPROP);
}
else if (msg == LVM_INSERTCOLUMNA || msg==LVM_SETCOLUMNA)
{
LPLVCOLUMNA pCol = (LPLVCOLUMNA) lParam;
char *str;
if (pCol && (str=pCol->pszText) && (pCol->mask & LVCF_TEXT) && WDL_HasUTF8(str))
{
MBTOWIDE(wbuf,str);
if (wbuf_ok)
{
LRESULT rv;
pCol->pszText=(char*)wbuf; // set new buffer
rv=CallWindowProc(oldproc,hwnd,msg==LVM_INSERTCOLUMNA?LVM_INSERTCOLUMNW:LVM_SETCOLUMNW,wParam,lParam);
pCol->pszText = str; // restore old pointer
MBTOWIDE_FREE(wbuf);
return rv;
}
}
}
else if (msg == LVM_INSERTITEMA || msg == LVM_SETITEMA || msg == LVM_SETITEMTEXTA)
{
LPLVITEMA pItem = (LPLVITEMA) lParam;
char *str;
if (pItem && (str=pItem->pszText) && (msg==LVM_SETITEMTEXTA || (pItem->mask&LVIF_TEXT)) && WDL_HasUTF8(str))
{
MBTOWIDE(wbuf,str);
if (wbuf_ok)
{
LRESULT rv;
pItem->pszText=(char*)wbuf; // set new buffer
rv=CallWindowProc(oldproc,hwnd,msg == LVM_INSERTITEMA ? LVM_INSERTITEMW : msg == LVM_SETITEMA ? LVM_SETITEMW : LVM_SETITEMTEXTW,wParam,lParam);
pItem->pszText = str; // restore old pointer
MBTOWIDE_FREE(wbuf);
return rv;
}
MBTOWIDE_FREE(wbuf);
}
}
else if (msg==LVM_GETITEMA||msg==LVM_GETITEMTEXTA)
{
LPLVITEMA pItem = (LPLVITEMA) lParam;
char *obuf;
if (pItem && (msg == LVM_GETITEMTEXTA || (pItem->mask & LVIF_TEXT)) && (obuf=pItem->pszText) && pItem->cchTextMax > 3)
{
WIDETOMB_ALLOC(wbuf,pItem->cchTextMax);
if (wbuf)
{
LRESULT rv;
int oldsz=pItem->cchTextMax;
*wbuf=0;
*obuf=0;
pItem->cchTextMax=wbuf_size/sizeof(WCHAR);
pItem->pszText = (char *)wbuf;
rv=CallWindowProc(oldproc,hwnd,msg==LVM_GETITEMTEXTA ? LVM_GETITEMTEXTW : LVM_GETITEMW,wParam,lParam);
if (!WideCharToMultiByte(CP_UTF8,0,wbuf,-1,obuf,oldsz,NULL,NULL) && GetLastError()==ERROR_INSUFFICIENT_BUFFER)
obuf[oldsz-1]=0;
pItem->cchTextMax=oldsz;
pItem->pszText=obuf;
WIDETOMB_FREE(wbuf);
if (obuf[0]) return rv;
}
}
}
return CallWindowProc(oldproc,hwnd,msg,wParam,lParam);
}
static INT_PTR CALLBACK PhpMemoryProtectDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
SetProp(hwndDlg, PhMakeContextAtom(), (HANDLE)lParam);
SetDlgItemText(hwndDlg, IDC_INTRO,
L"Possible values:\r\n"
L"\r\n"
L"0x01 - PAGE_NOACCESS\r\n"
L"0x02 - PAGE_READONLY\r\n"
L"0x04 - PAGE_READWRITE\r\n"
L"0x08 - PAGE_WRITECOPY\r\n"
L"0x10 - PAGE_EXECUTE\r\n"
L"0x20 - PAGE_EXECUTE_READ\r\n"
L"0x40 - PAGE_EXECUTE_READWRITE\r\n"
L"0x80 - PAGE_EXECUTE_WRITECOPY\r\n"
L"Modifiers:\r\n"
L"0x100 - PAGE_GUARD\r\n"
L"0x200 - PAGE_NOCACHE\r\n"
L"0x400 - PAGE_WRITECOMBINE\r\n"
);
SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwndDlg, IDC_VALUE), TRUE);
}
break;
case WM_DESTROY:
{
RemoveProp(hwndDlg, PhMakeContextAtom());
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
break;
case IDOK:
{
NTSTATUS status;
PMEMORY_PROTECT_CONTEXT context = (PMEMORY_PROTECT_CONTEXT)GetProp(hwndDlg, PhMakeContextAtom());
HANDLE processHandle;
ULONG64 protect;
PhStringToInteger64(&PhaGetDlgItemText(hwndDlg, IDC_VALUE)->sr, 0, &protect);
if (NT_SUCCESS(status = PhOpenProcess(
&processHandle,
PROCESS_VM_OPERATION,
context->ProcessItem->ProcessId
)))
{
PVOID baseAddress;
SIZE_T regionSize;
ULONG oldProtect;
baseAddress = context->MemoryItem->BaseAddress;
regionSize = context->MemoryItem->RegionSize;
status = NtProtectVirtualMemory(
processHandle,
&baseAddress,
®ionSize,
(ULONG)protect,
&oldProtect
);
if (NT_SUCCESS(status))
context->MemoryItem->Protect = (ULONG)protect;
}
if (NT_SUCCESS(status))
{
EndDialog(hwndDlg, IDOK);
}
else
{
PhShowStatus(hwndDlg, L"Unable to change memory protection", status, 0);
SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwndDlg, IDC_VALUE), TRUE);
Edit_SetSel(GetDlgItem(hwndDlg, IDC_VALUE), 0, -1);
}
}
break;
}
}
break;
}
return FALSE;
}
BOOL AeroAutoSubclass(HWND hWnd, DWORD dwFlags, DWORD dwReserved)
{
if(!hWnd || !IsWindow(hWnd) || 0L!=dwReserved)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
UINT uiRedrawMsg = RegisterWindowMessage(REDRAWSTRING);
if(!uiRedrawMsg)
return FALSE; // use the RegisterWindowMessage last error
CDwmApiImpl *pDwm = NULL;
CUxThemeAeroImpl *pUxTheme = NULL;
PAERO_SUBCLASS_WND_DATA pWndData = NULL;
DWORD dwLastError = ERROR_SUCCESS;
MARGINS marGlassInset = {-1,-1,-1,-1};
HRESULT hRes = S_OK;
bool bBufferedPaintInitialized = false;
ERROR_PARENT_AERO_SUBCLASS_WND_DATA errParentAeroData;
ZeroMemory(&errParentAeroData, sizeof(errParentAeroData));
errParentAeroData.m_dwFlags = dwFlags;
errParentAeroData.m_hWndParent = hWnd;
try
{
pDwm = new CDwmApiImpl;
}
catch (...)
{
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
}
if(ERROR_SUCCESS!=dwLastError)
goto CLEANUP;
try
{
pUxTheme = new CUxThemeAeroImpl;
}
catch (...)
{
dwLastError = ERROR_NOT_ENOUGH_MEMORY;
}
if(ERROR_SUCCESS!=dwLastError)
goto CLEANUP;
pWndData = (PAERO_SUBCLASS_WND_DATA)LocalAlloc(LPTR, sizeof(AERO_SUBCLASS_WND_DATA));
if(!pWndData)
{
dwLastError = GetLastError();
goto CLEANUP;
}
if(!pDwm->Initialize())
{
dwLastError = GetLastError();
goto CLEANUP;
}
if(!pUxTheme->Initialize())
{
dwLastError = GetLastError();
goto CLEANUP;
}
if(pDwm->IsDwmCompositionEnabled() && !(dwFlags&ASC_NO_FRAME_EXTENSION))
{
///
/// we do not evaluate the return value of pDwm->DwmExtendFrameIntoClientArea, because
/// if composition is turned off in the tiny little race condition after the previous call
/// to IsDwmCompositionEnabled and before the following call to DwmExtendFrameIntoClientArea,
/// we would see DwmExtendFrameIntoClientArea fail. However, if composition is turned on again
/// aterwards, the UI can display composition again without problems:
///
pDwm->DwmExtendFrameIntoClientArea(hWnd, &marGlassInset);
}
hRes = pUxTheme->BufferedPaintInit();
if(FAILED(hRes))
{
dwLastError = hRes;
goto CLEANUP;
}
bBufferedPaintInitialized = true;
if(!SetProp(hWnd, WINDOW_DATA_STRING, pWndData))
{
dwLastError = hRes;
goto CLEANUP;
}
errParentAeroData.m_pdwError = &dwLastError;
errParentAeroData.m_pWndParentAeroData = pWndData;
pWndData->m_pDwmApiImpl = pDwm;
pWndData->m_pUxTheme = pUxTheme;
pWndData->m_uiRedrawMsg = uiRedrawMsg;
if(dwFlags&ASC_NO_FRAME_EXTENSION)
pWndData->m_dwFlags |= WD_NO_FRAME_EXTEND;
if(!EnumChildWindows(hWnd, SubclassChildWindows, (LPARAM)&errParentAeroData))
{
if(ERROR_SUCCESS==dwLastError)
dwLastError = GetLastError();
goto CLEANUP;
}
if(ERROR_SUCCESS!=dwLastError)
goto CLEANUP;
pWndData->m_oldWndProc = (WNDPROC) SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR) WndProc);
if(!pWndData->m_oldWndProc)
{
dwLastError = GetLastError();
goto CLEANUP;
}
CLEANUP:
if(ERROR_SUCCESS!=dwLastError)
{
RemoveProp(hWnd, WINDOW_DATA_STRING); // don't care if this fails
if(pDwm)
delete pDwm;
if(pUxTheme)
{
if(bBufferedPaintInitialized)
pUxTheme->BufferedPaintUnInit();
delete pUxTheme;
}
if(pWndData)
VERIFY(!LocalFree(pWndData));
SetLastError(dwLastError);
return FALSE;
}
return TRUE;
}
//BRACKETS: added so our popup windows can have a menu bar too
//
// FUNCTION: PopupWndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Handle commands from the menus.
LRESULT CALLBACK PopupWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
//For now, we are only interest in WM_COMMAND's that we know are in our menus
//and WM_CLOSE so we can delegate that back to the browser
CefRefPtr<CefBrowser> browser = ClientHandler::GetBrowserForNativeWindow(hWnd);
switch (message)
{
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
int wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_CLOSE:
if (g_handler.get() && browser.get()) {
HWND browserHwnd = browser->GetHost()->GetWindowHandle();
HANDLE closing = GetProp(browserHwnd, CLOSING_PROP);
if (closing) {
RemoveProp(browserHwnd, CLOSING_PROP);
break;
}
CefRefPtr<CommandCallback> callback = new CloseWindowCommandCallback(browser);
g_handler->SendJSCommand(browser, FILE_CLOSE_WINDOW, callback);
}
return 0;
default:
ExtensionString commandId = NativeMenuModel::getInstance(getMenuParent(browser)).getCommandId(wmId);
if (commandId.size() > 0) {
CefRefPtr<CommandCallback> callback = new EditCommandCallback(browser, commandId);
g_handler->SendJSCommand(browser, commandId, callback);
}
}
}
break;
case WM_CLOSE:
if (g_handler.get() && browser.get()) {
HWND browserHwnd = browser->GetHost()->GetWindowHandle();
HANDLE closing = GetProp(browserHwnd, CLOSING_PROP);
if (closing) {
RemoveProp(browserHwnd, CLOSING_PROP);
break;
}
CefRefPtr<CommandCallback> callback = new CloseWindowCommandCallback(browser);
g_handler->SendJSCommand(browser, FILE_CLOSE_WINDOW, callback);
return 0;
}
break;
case WM_INITMENUPOPUP:
HMENU menu = (HMENU)wParam;
int count = GetMenuItemCount(menu);
void* menuParent = getMenuParent(browser);
for (int i = 0; i < count; i++) {
UINT id = GetMenuItemID(menu, i);
bool enabled = NativeMenuModel::getInstance(menuParent).isMenuItemEnabled(id);
UINT flagEnabled = enabled ? MF_ENABLED | MF_BYCOMMAND : MF_DISABLED | MF_BYCOMMAND;
EnableMenuItem(menu, id, flagEnabled);
bool checked = NativeMenuModel::getInstance(menuParent).isMenuItemChecked(id);
UINT flagChecked = checked ? MF_CHECKED | MF_BYCOMMAND : MF_UNCHECKED | MF_BYCOMMAND;
CheckMenuItem(menu, id, flagChecked);
}
break;
}
if (g_popupWndOldProc)
return (LRESULT)::CallWindowProc(g_popupWndOldProc, hWnd, message, wParam, lParam);
return ::DefWindowProc(hWnd, message, wParam, lParam);
}
LRESULT WINAPI
SendMailToolbarWndProc( HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
WNDPROC lpOldProc;
lpOldProc = (WNDPROC)GetProp( hwnd, "oldproc" );
switch(msg)
{
case WM_DESTROY:
{
// Put back old window proc and
SetWindowLong( hwnd, GWL_WNDPROC, (DWORD)lpOldProc );
// remove window property
RemoveProp( hwnd, "oldproc" );
break;
}
case WM_NOTIFY:
{
static char szTooltip[256] = {0x00};
LPTOOLTIPTEXT lpToolTipText = (LPTOOLTIPTEXT) lParam;;
switch (((LPNMHDR)lParam)->code)
{
case TTN_NEEDTEXTA:
{
if(lpToolTipText->hdr.idFrom >= IDC_DECRYPT &&
lpToolTipText->hdr.idFrom <= IDC_MIME )
{
int StringId = lpToolTipText->hdr.idFrom -
WM_USER - 1000;
LoadString (g_hinst,
StringId,
szTooltip,
sizeof(szTooltip));
lpToolTipText->lpszText = szTooltip;
if(g_hwndEudoraStatusbar)
{
SendMessage(g_hwndEudoraStatusbar,
SB_SETTEXT,
(WPARAM)0,
(LPARAM)szTooltip);
}
return 0;
}
}
case TTN_NEEDTEXTW:
{
static wchar_t wideBuf[256];
if(lpToolTipText->hdr.idFrom >= IDC_DECRYPT &&
lpToolTipText->hdr.idFrom <= IDC_MIME )
{
int StringId = lpToolTipText->hdr.idFrom -
WM_USER - 1000;
LoadString (g_hinst,
StringId,
szTooltip,
sizeof(szTooltip));
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szTooltip,
-1,
wideBuf,
256);
lpToolTipText->lpszText = (char*)wideBuf;
if(g_hwndEudoraStatusbar)
{
SendMessage(g_hwndEudoraStatusbar,
SB_SETTEXT,
(WPARAM)0,
(LPARAM)szTooltip);
}
return 0;
}
}
}
break;
}
case WM_COMMAND:
{
switch(wParam)
{
case IDC_SENDMAIL:
{
HWND hwndSendToolbar = NULL;
BOOL bEncrypt = FALSE;
BOOL bSign = FALSE;
BOOL bPGPMIME = FALSE;
BYTE KeyboardStatus[256];
//char temp[100];
// Did the user have the shift key pressed
// when they sent mail?
GetKeyboardState( KeyboardStatus );
// Get our Toolbar
hwndSendToolbar = FindWindowEx(hwnd,
NULL,
"ToolbarWindow32",
NULL);
if(hwndSendToolbar)
{
g_bSendingMail = TRUE;
g_hwndSendToolbar = hwndSendToolbar;
// set up the Eudora Plugin Menu correctly
SendMessage(hwnd,
WM_COMMAND,
(WPARAM)IDC_PLUGINMENU,
0);
// See if the user wants us to use PGPMIME
if(SendMessage( hwndSendToolbar,
TB_ISBUTTONCHECKED,
(WPARAM)IDC_MIME,
0))
{
bPGPMIME = TRUE;
}
// See if the user wants us encrypt the message
if(SendMessage( hwndSendToolbar,
TB_ISBUTTONCHECKED,
(WPARAM)IDC_ENCRYPT,
0))
{
bEncrypt = TRUE;
}
// See if the user wants us sign the message
if(SendMessage( hwndSendToolbar,
TB_ISBUTTONCHECKED,
(WPARAM)IDC_SIGN,
0))
{
bSign = TRUE;
}
}
else
{
int err;
char szMessage[256];
char szTitle[256];
LoadString(g_hinst, IDS_E_SENDMAIL, szMessage,
sizeof(szMessage));
LoadString(g_hinst, IDS_E_SENDMAILTITLE, szTitle,
sizeof(szTitle));
err = MessageBox(NULL,
szMessage,
szTitle,
MB_YESNO|MB_ICONSTOP);
if(err == IDNO)
{
return 0;
}
}
if(!bPGPMIME)
{
if(!SendMessage(hwnd, WM_COMMAND, IDC_JUSTDOIT, 0))
{
return 0;
}
else
{
LRESULT lresult;
BYTE oldKeyboardStatus[256];
GetKeyboardState( oldKeyboardStatus );
SetKeyboardState( KeyboardStatus );
lresult = CallWindowProc( lpOldProc,
hwnd,
msg,
wParam,
lParam );
// reset these keys so they don't "stick"
oldKeyboardStatus[VK_SHIFT] = 0;
oldKeyboardStatus[VK_CONTROL] = 0;
oldKeyboardStatus[VK_MENU] = 0;
SetKeyboardState( oldKeyboardStatus );
return lresult;
}
}
break;
}
case IDC_JUSTDOIT:
{
HWND hwndSendToolbar = NULL;
BOOL bEncrypt = FALSE;
BOOL bSign = FALSE;
BOOL bEncryptSuccessful = FALSE;
HCURSOR hCursor, hOldCursor;
//char temp[100];
// Get our Toolbar
hwndSendToolbar = FindWindowEx(hwnd,
NULL,
"ToolbarWindow32",
NULL);
if(hwndSendToolbar)
{
// See if the user wants us encrypt the message
if(SendMessage( hwndSendToolbar,
TB_ISBUTTONCHECKED,
(WPARAM)IDC_ENCRYPT,
0))
{
bEncrypt = TRUE;
}
// See if the user wants us sign the message
if(SendMessage( hwndSendToolbar,
TB_ISBUTTONCHECKED,
(WPARAM)IDC_SIGN,
0))
{
bSign = TRUE;
}
}
// does the user want us to do anything to the message
if(bEncrypt || bSign )
{
BOOL bSelectedText = FALSE;
CHARRANGE chRange = {0,0};
HWND hwndParent = NULL;
HWND hwndRichEdit = NULL;
HWND hwndAfxWnd = NULL;
HWND hwndHeaders = NULL;
char* pRichEditText = NULL;
char** pPGPRecipients = NULL;
long NumAddresses = 0;
long nChar = 0;
HEADERDATA hd;
// zero out HEADERDATA struct
memset(&hd, 0x00, sizeof(hd));
// Find the windows we are interested in...
hwndParent = GetParent(hwnd);
hwndAfxWnd = FindWindowEx( hwndParent,
NULL,
"AfxMDIFrame40",
NULL);
if(!hwndAfxWnd) // 3.04 and 3.05 use new mfc versions
{
hwndAfxWnd = FindWindowEx( hwndParent,
NULL,
"AfxMDIFrame42",
NULL);
if(!hwndAfxWnd)
{
char szMessage[256];
LoadString(g_hinst, IDS_E_OLDVERSION,
szMessage, sizeof(szMessage));
MessageBox(NULL,
szMessage,
0,
MB_OK);
return 0;
}
}
hwndRichEdit = FindWindowEx( hwndAfxWnd,
NULL,
"RICHEDIT",
NULL);
hwndHeaders = FindWindowEx( hwndAfxWnd,
NULL,
"#32770", //Dialog
NULL);
// See if the user has selected text in the window
SendMessage(hwndRichEdit,
EM_EXGETSEL,
(WPARAM)0,
(LPARAM)
&chRange);
bSelectedText = chRange.cpMax - chRange.cpMin;
// if not context menu invoked then we don't
// want to do selected text.
// this will protect users
if(lParam != SENT_FROM_CONTEXT_MENU)
{
bSelectedText = FALSE;
}
if(!bSelectedText)
{
RECT rect;
// there is a bug in the richedit control...
// so if there is no selected text click in
// the lower right corner real quick to
// clear up the bug...
GetClientRect(hwndRichEdit, &rect);
SendMessage(hwndRichEdit,
WM_LBUTTONDOWN,
MK_LBUTTON,
MAKELPARAM(rect.right - 5,
rect.bottom -5 ));
SendMessage(hwndRichEdit,
WM_LBUTTONUP,
MK_LBUTTON,
MAKELPARAM(rect.right - 5 ,
rect.bottom -5 ));
}
// This could take awhile... give some feedback.
hCursor = LoadCursor(NULL, IDC_WAIT);
hOldCursor = SetCursor(hCursor);
// get text of message
pRichEditText = GetRichEditContents ( hwndRichEdit,
&nChar,
FALSE,
bSelectedText);
// get the email headers
GetEudoraHeaders( hwndHeaders, &hd);
// now create an appropriate list for pgplib
NumAddresses = CreateRecipientListFromEudoraHeaders(
&hd,
&pPGPRecipients);
if( pRichEditText )
{
char* pInAttachments = "";
char* pOutAttachments = NULL;
// if context menu invoked then we don't
// want to do attachments.
if(lParam != SENT_FROM_CONTEXT_MENU)
{
pInAttachments = hd.pAttachments;
}
// length might have changed
nChar = strlen(pRichEditText);
// Encrypt Text
bEncryptSuccessful = EncryptSignRichEditText(
&pRichEditText,
&nChar,
bEncrypt,
bSign,
pPGPRecipients,
NumAddresses,
pInAttachments,
&pOutAttachments);
if( bEncryptSuccessful )
{
SetRichEditContents ( hwndRichEdit,
pRichEditText,
FALSE,
bSelectedText);
if(pOutAttachments)
{
// set the attachments
SetEudoraAttachments( hwndHeaders,
pOutAttachments);
free(pOutAttachments);
}
else
{
// Wait for about .5 seconds
// so user can see encrypted text...
Sleep(500);
}
}
}
// want to reset buttons for context menu
// regardless of success or failure
if( bEncryptSuccessful ||
lParam == SENT_FROM_CONTEXT_MENU)
{
// Reset the buttons
SendMessage(hwndSendToolbar,
TB_CHECKBUTTON,
(WPARAM)IDC_ENCRYPT,
MAKELPARAM(FALSE,0));
HeapFree(GetProcessHeap(), 0, pRichEditText);
}
// want to reset buttons for context menu
// regardless of success or failure
if( bEncryptSuccessful ||
lParam == SENT_FROM_CONTEXT_MENU)
{
// Reset the buttons
SendMessage(hwndSendToolbar,
TB_CHECKBUTTON,
(WPARAM)IDC_ENCRYPT,
MAKELPARAM(FALSE,0));
SendMessage(hwndSendToolbar,
TB_CHECKBUTTON,
(WPARAM)IDC_SIGN,
MAKELPARAM(FALSE, 0));
SendMessage(hwndSendToolbar,
TB_ENABLEBUTTON,
(WPARAM)IDC_JUSTDOIT,
MAKELPARAM(FALSE, 0));
}
// clean up after ourselves
FreeRecipientList(pPGPRecipients, NumAddresses);
FreeHeaderData(&hd);
SetCursor(hOldCursor);
}
else
{
// we 'successfully' did nothing to the message
bEncryptSuccessful = TRUE;
}
return bEncryptSuccessful;
break;
}
case IDC_KEYMGR:
{
char szPath[MAX_PATH];
char szPGPkeys[256];
PGPError error = kPGPError_NoErr;
LoadString(g_hinst, IDS_PGPKEYSEXE, szPGPkeys,
sizeof(szPGPkeys));
error = PGPclGetPath (kPGPclPGPkeysExeFile,
szPath, sizeof(szPath));
if( IsntPGPError(error) )
{
PGPclExecute (szPath, SW_SHOW);
}
else
{
char szError[256];
LoadString(g_hinst, IDS_E_LAUNCHPGPKEYS, szError,
sizeof(szError));
MessageBox(NULL,
szError,
0,
MB_OK);
}
break;
}
}
}
case WM_ENTERIDLE:
{
if( g_bSendingMail && g_hwndSendToolbar && wParam == MSGF_MENU )
{
g_bInitializeButtons = FALSE;
g_bSendingMail = FALSE;
g_hwndSendToolbar = NULL;
PostMessage(hwnd, WM_KEYDOWN, (WPARAM)VK_ESCAPE, 0x001c0001);
PostMessage(hwnd, WM_KEYUP, (WPARAM)VK_ESCAPE, 0x001c0001);
}
break;
}
case WM_DRAWITEM:
{
// control identifier
UINT idCtl = (UINT) wParam;
// item-drawing information
LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) lParam;
//char szString[256] = {0x00};
if( g_bSendingMail )
{
if(lpdis && lpdis->CtlType == ODT_MENU)
{
if(*((void**)(lpdis->itemData + 4)))
{
WPARAM wCommand = 0;
BOOL bItemChecked = FALSE;
// see if it is already checked
if((lpdis->itemState & ODS_CHECKED))
{
bItemChecked = TRUE;
}
// see which plugin this menuitem represents
if( !strcmp(*((char**)(lpdis->itemData + 4)),
"PGP plugin 1 (use toolbar)") )
{
wCommand = IDC_ENCRYPT;
// we might be getting a window from a cancel...
if( g_bInitializeButtons && bItemChecked)
{
g_bEncrypt = TRUE;
}
}
else if( !strcmp(*((char**)(lpdis->itemData + 4)),
"PGP plugin 2 (use toolbar)") )
{
wCommand = IDC_SIGN;
// we might be getting a window from a cancel...
if( g_bInitializeButtons && bItemChecked)
{
g_bSign = TRUE;
}
}
if( !g_bInitializeButtons )
{
// make sure the window handle is valid
if( g_hwndSendToolbar)
{
if( wCommand ) // is this one of our menus
{
BOOL bCommandPressed = FALSE;
BOOL bPGPMIMEPressed = FALSE;
bCommandPressed = SendMessage(
g_hwndSendToolbar,
TB_ISBUTTONCHECKED,
wCommand,
0);
bPGPMIMEPressed = SendMessage(
g_hwndSendToolbar,
TB_ISBUTTONCHECKED,
IDC_MIME,
0);
if( (bCommandPressed &&
!bItemChecked && bPGPMIMEPressed) ||
(bCommandPressed && bItemChecked &&
!bPGPMIMEPressed) ||
(!bCommandPressed && bItemChecked))
{
SendMessage(hwnd,
WM_COMMAND,
(WPARAM)lpdis->itemID,
0);
}
}
}
}
}
}
}
break;
}
}
// Pass all non-custom messages to old window proc
return CallWindowProc(lpOldProc, hwnd, msg, wParam, lParam ) ;
}
INT_PTR CALLBACK PhpHandleGeneralDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
LPPROPSHEETPAGE propSheetPage = (LPPROPSHEETPAGE)lParam;
PHANDLE_PROPERTIES_CONTEXT context = (PHANDLE_PROPERTIES_CONTEXT)propSheetPage->lParam;
PPH_ACCESS_ENTRY accessEntries;
ULONG numberOfAccessEntries;
HANDLE processHandle;
OBJECT_BASIC_INFORMATION basicInfo;
BOOLEAN haveBasicInfo = FALSE;
SetProp(hwndDlg, PhMakeContextAtom(), (HANDLE)context);
SetDlgItemText(hwndDlg, IDC_NAME, PhGetString(context->HandleItem->BestObjectName));
SetDlgItemText(hwndDlg, IDC_TYPE, context->HandleItem->TypeName->Buffer);
SetDlgItemText(hwndDlg, IDC_ADDRESS, context->HandleItem->ObjectString);
if (PhGetAccessEntries(
context->HandleItem->TypeName->Buffer,
&accessEntries,
&numberOfAccessEntries
))
{
PPH_STRING accessString;
PPH_STRING grantedAccessString;
accessString = PhGetAccessString(
context->HandleItem->GrantedAccess,
accessEntries,
numberOfAccessEntries
);
if (accessString->Length != 0)
{
grantedAccessString = PhFormatString(
L"%s (%s)",
context->HandleItem->GrantedAccessString,
accessString->Buffer
);
SetDlgItemText(hwndDlg, IDC_GRANTED_ACCESS, grantedAccessString->Buffer);
PhDereferenceObject(grantedAccessString);
}
else
{
SetDlgItemText(hwndDlg, IDC_GRANTED_ACCESS, context->HandleItem->GrantedAccessString);
}
PhDereferenceObject(accessString);
PhFree(accessEntries);
}
else
{
SetDlgItemText(hwndDlg, IDC_GRANTED_ACCESS, context->HandleItem->GrantedAccessString);
}
if (NT_SUCCESS(PhOpenProcess(
&processHandle,
PROCESS_DUP_HANDLE,
context->ProcessId
)))
{
if (NT_SUCCESS(PhGetHandleInformation(
processHandle,
context->HandleItem->Handle,
-1,
&basicInfo,
NULL,
NULL,
NULL
)))
{
SetDlgItemInt(hwndDlg, IDC_REFERENCES, basicInfo.PointerCount, FALSE);
SetDlgItemInt(hwndDlg, IDC_HANDLES, basicInfo.HandleCount, FALSE);
SetDlgItemInt(hwndDlg, IDC_PAGED, basicInfo.PagedPoolCharge, FALSE);
SetDlgItemInt(hwndDlg, IDC_NONPAGED, basicInfo.NonPagedPoolCharge, FALSE);
haveBasicInfo = TRUE;
}
NtClose(processHandle);
}
if (!haveBasicInfo)
{
SetDlgItemText(hwndDlg, IDC_REFERENCES, L"Unknown");
SetDlgItemText(hwndDlg, IDC_HANDLES, L"Unknown");
SetDlgItemText(hwndDlg, IDC_PAGED, L"Unknown");
SetDlgItemText(hwndDlg, IDC_NONPAGED, L"Unknown");
}
}
break;
case WM_DESTROY:
{
RemoveProp(hwndDlg, PhMakeContextAtom());
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_QUERYINITIALFOCUS:
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)GetDlgItem(hwndDlg, IDC_BASICINFORMATION));
}
return TRUE;
}
}
break;
}
return FALSE;
}
static BOOL CALLBACK PropEnumProc(HWND hwnd, LPCSTR lpszString, HANDLE hData){
if((DWORD)(VOID *)hData != 0xffffffff){
RemoveProp(hwnd, lpszString);
}
return TRUE;
}
static INT_PTR CALLBACK PhpInformationDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
PINFORMATION_CONTEXT context = (PINFORMATION_CONTEXT)lParam;
PPH_LAYOUT_MANAGER layoutManager;
PhCenterWindow(hwndDlg, GetParent(hwndDlg));
SetDlgItemText(hwndDlg, IDC_TEXT, context->String);
layoutManager = PhAllocate(sizeof(PH_LAYOUT_MANAGER));
PhInitializeLayoutManager(layoutManager, hwndDlg);
PhAddLayoutItem(layoutManager, GetDlgItem(hwndDlg, IDC_TEXT), NULL,
PH_ANCHOR_ALL);
PhAddLayoutItem(layoutManager, GetDlgItem(hwndDlg, IDOK), NULL,
PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(layoutManager, GetDlgItem(hwndDlg, IDC_COPY), NULL,
PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddLayoutItem(layoutManager, GetDlgItem(hwndDlg, IDC_SAVE), NULL,
PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
if (MinimumSize.left == -1)
{
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = 200;
rect.bottom = 140;
MapDialogRect(hwndDlg, &rect);
MinimumSize = rect;
MinimumSize.left = 0;
}
SetProp(hwndDlg, L"LayoutManager", (HANDLE)layoutManager);
SetProp(hwndDlg, L"String", (HANDLE)context->String);
SendMessage(hwndDlg, WM_NEXTDLGCTL, (LPARAM)GetDlgItem(hwndDlg, IDOK), TRUE);
}
break;
case WM_DESTROY:
{
PPH_LAYOUT_MANAGER layoutManager;
layoutManager = (PPH_LAYOUT_MANAGER)GetProp(hwndDlg, L"LayoutManager");
PhDeleteLayoutManager(layoutManager);
PhFree(layoutManager);
RemoveProp(hwndDlg, L"String");
RemoveProp(hwndDlg, L"LayoutManager");
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
case IDOK:
EndDialog(hwndDlg, IDOK);
break;
case IDC_COPY:
{
HWND editControl;
LONG selStart;
LONG selEnd;
PWSTR buffer;
PH_STRINGREF string;
editControl = GetDlgItem(hwndDlg, IDC_TEXT);
SendMessage(editControl, EM_GETSEL, (WPARAM)&selStart, (LPARAM)&selEnd);
buffer = (PWSTR)GetProp(hwndDlg, L"String");
if (selStart == selEnd)
{
// Select and copy the entire string.
PhInitializeStringRefLongHint(&string, buffer);
Edit_SetSel(editControl, 0, -1);
}
else
{
string.Buffer = buffer + selStart;
string.Length = (selEnd - selStart) * 2;
}
PhSetClipboardString(hwndDlg, &string);
SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM)editControl, TRUE);
}
break;
case IDC_SAVE:
{
static PH_FILETYPE_FILTER filters[] =
{
{ L"Text files (*.txt)", L"*.txt" },
{ L"All files (*.*)", L"*.*" }
};
PVOID fileDialog;
fileDialog = PhCreateSaveFileDialog();
PhSetFileDialogFilter(fileDialog, filters, sizeof(filters) / sizeof(PH_FILETYPE_FILTER));
PhSetFileDialogFileName(fileDialog, L"Information.txt");
if (PhShowFileDialog(hwndDlg, fileDialog))
{
NTSTATUS status;
PPH_STRING fileName;
PPH_FILE_STREAM fileStream;
fileName = PH_AUTO(PhGetFileDialogFileName(fileDialog));
if (NT_SUCCESS(status = PhCreateFileStream(
&fileStream,
fileName->Buffer,
FILE_GENERIC_WRITE,
FILE_SHARE_READ,
FILE_OVERWRITE_IF,
0
)))
{
PH_STRINGREF string;
PhWriteStringAsUtf8FileStream(fileStream, &PhUnicodeByteOrderMark);
PhInitializeStringRef(&string, (PWSTR)GetProp(hwndDlg, L"String"));
PhWriteStringAsUtf8FileStream(fileStream, &string);
PhDereferenceObject(fileStream);
}
if (!NT_SUCCESS(status))
PhShowStatus(hwndDlg, L"Unable to create the file", status, 0);
}
PhFreeFileDialog(fileDialog);
}
break;
}
}
break;
case WM_SIZE:
{
PPH_LAYOUT_MANAGER layoutManager;
layoutManager = (PPH_LAYOUT_MANAGER)GetProp(hwndDlg, L"LayoutManager");
PhLayoutManagerLayout(layoutManager);
}
break;
case WM_SIZING:
{
PhResizingMinimumSize((PRECT)lParam, wParam, MinimumSize.right, MinimumSize.bottom);
}
break;
}
return FALSE;
}
static INT_PTR CALLBACK NetAdapterDialogProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PPH_NETADAPTER_SYSINFO_CONTEXT context = NULL;
if (uMsg == WM_INITDIALOG)
{
context = (PPH_NETADAPTER_SYSINFO_CONTEXT)lParam;
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PPH_NETADAPTER_SYSINFO_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_NCDESTROY)
{
PhDeleteLayoutManager(&context->LayoutManager);
PhDeleteGraphState(&context->GraphState);
if (context->GraphHandle)
DestroyWindow(context->GraphHandle);
if (context->PanelWindowHandle)
DestroyWindow(context->PanelWindowHandle);
PhUnregisterCallback(&PhProcessesUpdatedEvent, &context->ProcessesUpdatedRegistration);
RemoveProp(hwndDlg, L"Context");
}
}
if (context == NULL)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
PPH_LAYOUT_ITEM graphItem;
PPH_LAYOUT_ITEM panelItem;
context->WindowHandle = hwndDlg;
PhInitializeGraphState(&context->GraphState);
PhInitializeLayoutManager(&context->LayoutManager, hwndDlg);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_ADAPTERNAME), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT | PH_LAYOUT_FORCE_INVALIDATE);
graphItem = PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_GRAPH_LAYOUT), NULL, PH_ANCHOR_ALL);
panelItem = PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_LAYOUT), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
SendMessage(GetDlgItem(hwndDlg, IDC_ADAPTERNAME), WM_SETFONT, (WPARAM)context->SysinfoSection->Parameters->LargeFont, FALSE);
SetDlgItemText(hwndDlg, IDC_ADAPTERNAME, context->SysinfoSection->Name.Buffer);
context->PanelWindowHandle = CreateDialogParam(PluginInstance->DllBase, MAKEINTRESOURCE(IDD_NETADAPTER_PANEL), hwndDlg, NetAdapterPanelDialogProc, (LPARAM)context);
ShowWindow(context->PanelWindowHandle, SW_SHOW);
PhAddLayoutItemEx(&context->LayoutManager, context->PanelWindowHandle, NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM, panelItem->Margin);
// Create the graph control.
context->GraphHandle = CreateWindow(
PH_GRAPH_CLASSNAME,
NULL,
WS_VISIBLE | WS_CHILD | WS_BORDER,
0,
0,
3,
3,
hwndDlg,
NULL,
NULL,
NULL
);
Graph_SetTooltip(context->GraphHandle, TRUE);
PhAddLayoutItemEx(&context->LayoutManager, context->GraphHandle, NULL, PH_ANCHOR_ALL, graphItem->Margin);
PhRegisterCallback(
&PhProcessesUpdatedEvent,
ProcessesUpdatedHandler,
context,
&context->ProcessesUpdatedRegistration
);
NetAdapterUpdateGraphs(context);
NetAdapterUpdatePanel(context);
}
break;
case WM_SIZE:
PhLayoutManagerLayout(&context->LayoutManager);
break;
case WM_NOTIFY:
{
NMHDR* header = (NMHDR*)lParam;
if (header->hwndFrom == context->GraphHandle)
{
switch (header->code)
{
case GCN_GETDRAWINFO:
{
PPH_GRAPH_GETDRAWINFO getDrawInfo = (PPH_GRAPH_GETDRAWINFO)header;
PPH_GRAPH_DRAW_INFO drawInfo = getDrawInfo->DrawInfo;
drawInfo->Flags = PH_GRAPH_USE_GRID | PH_GRAPH_USE_LINE_2;
context->SysinfoSection->Parameters->ColorSetupFunction(drawInfo, PhGetIntegerSetting(L"ColorIoReadOther"), PhGetIntegerSetting(L"ColorIoWrite"));
PhGraphStateGetDrawInfo(
&context->GraphState,
getDrawInfo,
context->InboundBuffer.Count
);
if (!context->GraphState.Valid)
{
ULONG i;
FLOAT max = 0;
for (i = 0; i < drawInfo->LineDataCount; i++)
{
FLOAT data1;
FLOAT data2;
context->GraphState.Data1[i] = data1 = (FLOAT)PhGetItemCircularBuffer_ULONG64(&context->InboundBuffer, i);
context->GraphState.Data2[i] = data2 = (FLOAT)PhGetItemCircularBuffer_ULONG64(&context->OutboundBuffer, i);
if (max < data1 + data2)
max = data1 + data2;
}
// Minimum scaling of 1 MB.
//if (max < 1024 * 1024)
// max = 1024 * 1024;
// Scale the data.
PhDivideSinglesBySingle(
context->GraphState.Data1,
max,
drawInfo->LineDataCount
);
// Scale the data.
PhDivideSinglesBySingle(
context->GraphState.Data2,
max,
drawInfo->LineDataCount
);
context->GraphState.Valid = TRUE;
}
}
break;
case GCN_GETTOOLTIPTEXT:
{
PPH_GRAPH_GETTOOLTIPTEXT getTooltipText = (PPH_GRAPH_GETTOOLTIPTEXT)header;
if (getTooltipText->Index < getTooltipText->TotalCount)
{
if (context->GraphState.TooltipIndex != getTooltipText->Index)
{
ULONG64 adapterInboundValue = PhGetItemCircularBuffer_ULONG64(
&context->InboundBuffer,
getTooltipText->Index
);
ULONG64 adapterOutboundValue = PhGetItemCircularBuffer_ULONG64(
&context->OutboundBuffer,
getTooltipText->Index
);
PhMoveReference(&context->GraphState.TooltipText, PhFormatString(
L"R: %s\nS: %s\n%s",
PhaFormatSize(adapterInboundValue, -1)->Buffer,
PhaFormatSize(adapterOutboundValue, -1)->Buffer,
((PPH_STRING)PhAutoDereferenceObject(PhGetStatisticsTimeString(NULL, getTooltipText->Index)))->Buffer
));
}
getTooltipText->Text = context->GraphState.TooltipText->sr;
}
}
break;
}
}
}
break;
case MSG_UPDATE:
{
NetAdapterUpdateGraphs(context);
NetAdapterUpdatePanel(context);
}
break;
}
return FALSE;
}
INT_PTR CALLBACK EspServiceRecoveryDlgProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PSERVICE_RECOVERY_CONTEXT context;
if (uMsg == WM_INITDIALOG)
{
context = PhAllocate(sizeof(SERVICE_RECOVERY_CONTEXT));
memset(context, 0, sizeof(SERVICE_RECOVERY_CONTEXT));
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PSERVICE_RECOVERY_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_DESTROY)
RemoveProp(hwndDlg, L"Context");
}
if (!context)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
NTSTATUS status;
LPPROPSHEETPAGE propSheetPage = (LPPROPSHEETPAGE)lParam;
PPH_SERVICE_ITEM serviceItem = (PPH_SERVICE_ITEM)propSheetPage->lParam;
context->ServiceItem = serviceItem;
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_FIRSTFAILURE));
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_SECONDFAILURE));
EspAddServiceActionStrings(GetDlgItem(hwndDlg, IDC_SUBSEQUENTFAILURES));
status = EspLoadRecoveryInfo(hwndDlg, context);
if (status == STATUS_SOME_NOT_MAPPED)
{
if (context->NumberOfActions > 3)
{
PhShowWarning(
hwndDlg,
L"The service has %lu failure actions configured, but this program only supports editing 3. "
L"If you save the recovery information using this program, the additional failure actions will be lost.",
context->NumberOfActions
);
}
}
else if (!NT_SUCCESS(status))
{
SetDlgItemText(hwndDlg, IDC_RESETFAILCOUNT, L"0");
if (WindowsVersion >= WINDOWS_VISTA)
{
context->EnableFlagCheckBox = TRUE;
EnableWindow(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS), TRUE);
}
PhShowWarning(hwndDlg, L"Unable to query service recovery information: %s",
((PPH_STRING)PhAutoDereferenceObject(PhGetNtMessage(status)))->Buffer);
}
EspFixControls(hwndDlg, context);
context->Ready = TRUE;
}
break;
case WM_DESTROY:
{
PhClearReference(&context->RebootMessage);
PhFree(context);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_FIRSTFAILURE:
case IDC_SECONDFAILURE:
case IDC_SUBSEQUENTFAILURES:
{
if (HIWORD(wParam) == CBN_SELCHANGE)
{
EspFixControls(hwndDlg, context);
}
}
break;
case IDC_RESTARTCOMPUTEROPTIONS:
{
DialogBoxParam(
PluginInstance->DllBase,
MAKEINTRESOURCE(IDD_RESTARTCOMP),
hwndDlg,
RestartComputerDlgProc,
(LPARAM)context
);
}
break;
case IDC_BROWSE:
{
static PH_FILETYPE_FILTER filters[] =
{
{ L"Executable files (*.exe;*.cmd;*.bat)", L"*.exe;*.cmd;*.bat" },
{ L"All files (*.*)", L"*.*" }
};
PVOID fileDialog;
PPH_STRING fileName;
fileDialog = PhCreateOpenFileDialog();
PhSetFileDialogFilter(fileDialog, filters, sizeof(filters) / sizeof(PH_FILETYPE_FILTER));
fileName = PhaGetDlgItemText(hwndDlg, IDC_RUNPROGRAM);
PhSetFileDialogFileName(fileDialog, fileName->Buffer);
if (PhShowFileDialog(hwndDlg, fileDialog))
{
fileName = PhGetFileDialogFileName(fileDialog);
SetDlgItemText(hwndDlg, IDC_RUNPROGRAM, fileName->Buffer);
PhDereferenceObject(fileName);
}
PhFreeFileDialog(fileDialog);
}
break;
case IDC_ENABLEFORERRORSTOPS:
{
context->Dirty = TRUE;
}
break;
}
switch (HIWORD(wParam))
{
case EN_CHANGE:
case CBN_SELCHANGE:
{
if (context->Ready)
context->Dirty = TRUE;
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case PSN_KILLACTIVE:
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, FALSE);
}
return TRUE;
case PSN_APPLY:
{
NTSTATUS status;
PPH_SERVICE_ITEM serviceItem = context->ServiceItem;
SC_HANDLE serviceHandle;
ULONG restartServiceAfter;
SERVICE_FAILURE_ACTIONS failureActions;
SC_ACTION actions[3];
ULONG i;
BOOLEAN enableRestart = FALSE;
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
if (!context->Dirty)
{
return TRUE;
}
// Build the failure actions structure.
failureActions.dwResetPeriod = GetDlgItemInt(hwndDlg, IDC_RESETFAILCOUNT, NULL, FALSE) * 60 * 60 * 24;
failureActions.lpRebootMsg = PhGetStringOrEmpty(context->RebootMessage);
failureActions.lpCommand = PhaGetDlgItemText(hwndDlg, IDC_RUNPROGRAM)->Buffer;
failureActions.cActions = 3;
failureActions.lpsaActions = actions;
actions[0].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_FIRSTFAILURE));
actions[1].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_SECONDFAILURE));
actions[2].Type = ComboBoxToServiceAction(GetDlgItem(hwndDlg, IDC_SUBSEQUENTFAILURES));
restartServiceAfter = GetDlgItemInt(hwndDlg, IDC_RESTARTSERVICEAFTER, NULL, FALSE) * 1000 * 60;
for (i = 0; i < 3; i++)
{
switch (actions[i].Type)
{
case SC_ACTION_RESTART:
actions[i].Delay = restartServiceAfter;
enableRestart = TRUE;
break;
case SC_ACTION_REBOOT:
actions[i].Delay = context->RebootAfter;
break;
case SC_ACTION_RUN_COMMAND:
actions[i].Delay = 0;
break;
}
}
// Try to save the changes.
serviceHandle = PhOpenService(
serviceItem->Name->Buffer,
SERVICE_CHANGE_CONFIG | (enableRestart ? SERVICE_START : 0) // SC_ACTION_RESTART requires SERVICE_START
);
if (serviceHandle)
{
if (ChangeServiceConfig2(
serviceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS,
&failureActions
))
{
if (context->EnableFlagCheckBox)
{
SERVICE_FAILURE_ACTIONS_FLAG failureActionsFlag;
failureActionsFlag.fFailureActionsOnNonCrashFailures =
Button_GetCheck(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS)) == BST_CHECKED;
ChangeServiceConfig2(
serviceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
&failureActionsFlag
);
}
CloseServiceHandle(serviceHandle);
}
else
{
CloseServiceHandle(serviceHandle);
goto ErrorCase;
}
}
else
{
if (GetLastError() == ERROR_ACCESS_DENIED && !PhElevated)
{
// Elevate using phsvc.
if (PhUiConnectToPhSvc(hwndDlg, FALSE))
{
if (NT_SUCCESS(status = PhSvcCallChangeServiceConfig2(
serviceItem->Name->Buffer,
SERVICE_CONFIG_FAILURE_ACTIONS,
&failureActions
)))
{
if (context->EnableFlagCheckBox)
{
SERVICE_FAILURE_ACTIONS_FLAG failureActionsFlag;
failureActionsFlag.fFailureActionsOnNonCrashFailures =
Button_GetCheck(GetDlgItem(hwndDlg, IDC_ENABLEFORERRORSTOPS)) == BST_CHECKED;
PhSvcCallChangeServiceConfig2(
serviceItem->Name->Buffer,
SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
&failureActionsFlag
);
}
}
PhUiDisconnectFromPhSvc();
if (!NT_SUCCESS(status))
{
SetLastError(PhNtStatusToDosError(status));
goto ErrorCase;
}
}
else
{
// User cancelled elevation.
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID);
}
}
else
{
goto ErrorCase;
}
}
return TRUE;
ErrorCase:
if (PhShowMessage(
hwndDlg,
MB_ICONERROR | MB_RETRYCANCEL,
L"Unable to change service recovery information: %s",
((PPH_STRING)PhAutoDereferenceObject(PhGetWin32Message(GetLastError())))->Buffer
) == IDRETRY)
{
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID);
}
}
return TRUE;
}
}
break;
}
return FALSE;
}
LRESULT PASCAL HotKeyWndProc(HWND hWnd, register UINT uMsg, register WPARAM wParam, register LPARAM lParam)
{
CM_HOTKEY *pHotKey = ( CM_HOTKEY * ) GetProp( hWnd, _T("HOTKEY") );
switch ( uMsg )
{
case WM_CREATE:
{
CM_HOTKEY *pHotKey = new CM_HOTKEY;
ZeroMemory( pHotKey, sizeof( CM_HOTKEY ) );
SetProp( hWnd, _T("HOTKEY"), pHotKey );
SetWindowLong( hWnd, GWL_EXSTYLE, GetWindowLong( hWnd, GWL_EXSTYLE ) | WS_EX_CLIENTEDGE );
SetWindowPos( hWnd, NULL, -1, -1, -1, -1, SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE | SWP_DRAWFRAME );
SendMessage( hWnd, UM_UPDATEHOTKEYTEXT, 0, 0 );
g_bEatCommand = FALSE;
break;
}
case WM_DESTROY:
{
RemoveProp( hWnd, _T("HOTKEY") );
delete pHotKey;
break;
}
case UM_TAKEBACKFOCUS:
{
if ( GetFocus() != hWnd )
{
SetFocus( hWnd );
}
g_bEatCommand = FALSE;
return 0;
}
case HOTM_QUERYEATCOMMAND:
{
return g_bEatCommand;
}
case UM_UPDATEHOTKEYTEXT:
{
TCHAR szHotKey[ 100 ];
*szHotKey = '\0';
GetHotKeyString( *pHotKey, szHotKey );
g_bCanUpdateText = TRUE;
SetWindowText( hWnd, szHotKey );
g_bCanUpdateText = FALSE;
SendMessage( hWnd, EM_SETSEL, 1000, 1000 );
return 0;
}
case UM_INTERNALSETHOTKEY:
{
UINT nVirtKey = wParam;
switch ( nVirtKey )
{
case VK_CONTROL:
case VK_SHIFT:
case VK_MENU:
{
nVirtKey = 0;
}
}
if ( nVirtKey )
{
CM_HOTKEY cmHotKey = *pHotKey;
BYTE byModifiers = 0;
byModifiers |= ( ( GetKeyState( VK_CONTROL ) < 0 ) ? HOTKEYF_CONTROL : 0 );
byModifiers |= ( ( GetKeyState( VK_SHIFT ) < 0 ) ? HOTKEYF_SHIFT : 0 );
byModifiers |= ( ( GetKeyState( VK_MENU ) < 0 ) ? HOTKEYF_ALT : 0 );
if ( cmHotKey.byModifiers1 || cmHotKey.nVirtKey1 )
{
if ( !cmHotKey.byModifiers2 && !cmHotKey.nVirtKey2 )
{
cmHotKey.byModifiers2 = byModifiers;
cmHotKey.nVirtKey2 = nVirtKey;
}
else
{
cmHotKey.byModifiers2 = 0;
cmHotKey.nVirtKey2 = 0;
goto set_loword;
}
}
else
{
set_loword:
ASSERT( !cmHotKey.byModifiers2 && !cmHotKey.nVirtKey2 );
cmHotKey.byModifiers1 = byModifiers;
cmHotKey.nVirtKey1 = nVirtKey;
}
SendMessage( hWnd, HOTM_SETHOTKEY, 0, ( LPARAM ) &cmHotKey );
}
return 0;
}
case HOTM_SETHOTKEY:
{
if ( lParam )
{
*pHotKey = *( CM_HOTKEY * ) lParam;
}
else
{
CM_HOTKEY cmHotKey = { 0, 0, 0, 0 };
*pHotKey = cmHotKey;
}
SendMessage( hWnd, UM_UPDATEHOTKEYTEXT, 0, 0 );
return 0;
}
case HOTM_GETHOTKEY:
{
*( ( CM_HOTKEY * ) lParam ) = *pHotKey;
break;
}
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
g_bEatCommand = TRUE;
SendMessage( hWnd, UM_INTERNALSETHOTKEY, wParam, lParam );
PostMessage( hWnd, UM_TAKEBACKFOCUS, 0, 0 );
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
case WM_KEYUP:
case WM_SYSKEYUP:
{
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
case WM_CHAR:
case WM_SYSCHAR:
{
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_RBUTTONDBLCLK:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_MBUTTONDBLCLK:
case WM_CONTEXTMENU:
{
SetFocus( hWnd );
return 0;
}
case WM_SYSCOMMAND:
{
return 0;
}
case WM_SETTEXT:
{
if ( g_bCanUpdateText )
{
break;
}
else
{
return 0;
}
}
case WM_GETDLGCODE:
{
DWORD dwDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS | DLGC_WANTTAB;
if ( HAS_FLAG( GetWindowLong( hWnd, GWL_STYLE ), ES_WANTRETURN ) )
{
dwDlgCode |= DLGC_WANTALLKEYS;
}
return dwDlgCode;
}
}
// Other than the above messages, the hotkey control behaves identical to an edit control
WNDCLASS wcEdit;
VERIFY( GetClassInfo( ( HINSTANCE ) GetWindowLong( hWnd, GWL_HINSTANCE ), _T("EDIT"), &wcEdit ) );
#ifdef _ACTIVEX
return CallWindowProc( wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam );
#else
#if _MSC_VER > 1100
return CallWindowProc( ( WNDPROC ) wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam );
#else
return CallWindowProc( ( FARPROC ) wcEdit.lpfnWndProc, hWnd, uMsg, wParam, lParam );
#endif
#endif
}
LRESULT CALLBACK PhpExtendedListViewWndProc(
_In_ HWND hwnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PPH_EXTLV_CONTEXT context;
WNDPROC oldWndProc;
context = (PPH_EXTLV_CONTEXT)GetProp(hwnd, PhpMakeExtLvContextAtom());
oldWndProc = context->OldWndProc;
switch (uMsg)
{
case WM_DESTROY:
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)oldWndProc);
PhFree(context);
RemoveProp(hwnd, PhpMakeExtLvContextAtom());
}
break;
case WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case HDN_ITEMCLICK:
{
HWND headerHandle;
headerHandle = (HWND)CallWindowProc(context->OldWndProc, hwnd, LVM_GETHEADER, 0, 0);
if (header->hwndFrom == headerHandle)
{
LPNMHEADER header2 = (LPNMHEADER)header;
if (header2->iItem == context->SortColumn)
{
if (context->TriState)
{
if (context->SortOrder == AscendingSortOrder)
context->SortOrder = DescendingSortOrder;
else if (context->SortOrder == DescendingSortOrder)
context->SortOrder = NoSortOrder;
else
context->SortOrder = AscendingSortOrder;
}
else
{
if (context->SortOrder == AscendingSortOrder)
context->SortOrder = DescendingSortOrder;
else
context->SortOrder = AscendingSortOrder;
}
}
else
{
context->SortColumn = header2->iItem;
context->SortOrder = AscendingSortOrder;
}
PhSetHeaderSortIcon(headerHandle, context->SortColumn, context->SortOrder);
ExtendedListView_SortItems(hwnd);
}
}
break;
}
}
break;
case WM_REFLECT + WM_NOTIFY:
{
LPNMHDR header = (LPNMHDR)lParam;
switch (header->code)
{
case NM_CUSTOMDRAW:
{
if (header->hwndFrom == hwnd)
{
LPNMLVCUSTOMDRAW customDraw = (LPNMLVCUSTOMDRAW)header;
switch (customDraw->nmcd.dwDrawStage)
{
case CDDS_PREPAINT:
return CDRF_NOTIFYITEMDRAW;
case CDDS_ITEMPREPAINT:
{
BOOLEAN colorChanged = FALSE;
HFONT newFont = NULL;
if (context->ItemColorFunction)
{
customDraw->clrTextBk = context->ItemColorFunction(
(INT)customDraw->nmcd.dwItemSpec,
(PVOID)customDraw->nmcd.lItemlParam,
context->Context
);
colorChanged = TRUE;
}
if (context->ItemFontFunction)
{
newFont = context->ItemFontFunction(
(INT)customDraw->nmcd.dwItemSpec,
(PVOID)customDraw->nmcd.lItemlParam,
context->Context
);
}
if (newFont)
SelectObject(customDraw->nmcd.hdc, newFont);
if (colorChanged)
{
if (PhGetColorBrightness(customDraw->clrTextBk) > 100) // slightly less than half
customDraw->clrText = RGB(0x00, 0x00, 0x00);
else
customDraw->clrText = RGB(0xff, 0xff, 0xff);
}
if (!newFont)
return CDRF_DODEFAULT;
else
return CDRF_NEWFONT;
}
break;
}
}
}
break;
}
}
break;
case WM_SETCURSOR:
{
if (context->Cursor)
{
SetCursor(context->Cursor);
return TRUE;
}
}
break;
case WM_UPDATEUISTATE:
{
// Disable focus rectangles by setting or masking out the flag where appropriate.
switch (LOWORD(wParam))
{
case UIS_SET:
wParam |= UISF_HIDEFOCUS << 16;
break;
case UIS_CLEAR:
case UIS_INITIALIZE:
wParam &= ~(UISF_HIDEFOCUS << 16);
break;
}
}
break;
case ELVM_ADDFALLBACKCOLUMN:
{
if (context->NumberOfFallbackColumns < PH_MAX_COMPARE_FUNCTIONS)
context->FallbackColumns[context->NumberOfFallbackColumns++] = (ULONG)wParam;
else
return FALSE;
}
return TRUE;
case ELVM_ADDFALLBACKCOLUMNS:
{
ULONG numberOfColumns = (ULONG)wParam;
PULONG columns = (PULONG)lParam;
if (context->NumberOfFallbackColumns + numberOfColumns <= PH_MAX_COMPARE_FUNCTIONS)
{
memcpy(
&context->FallbackColumns[context->NumberOfFallbackColumns],
columns,
numberOfColumns * sizeof(ULONG)
);
context->NumberOfFallbackColumns += numberOfColumns;
}
else
{
return FALSE;
}
}
return TRUE;
case ELVM_INIT:
{
PhSetHeaderSortIcon(ListView_GetHeader(hwnd), context->SortColumn, context->SortOrder);
// HACK to fix tooltips showing behind Always On Top windows.
SetWindowPos(ListView_GetToolTips(hwnd), HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
// Make sure focus rectangles are disabled.
SendMessage(hwnd, WM_CHANGEUISTATE, MAKELONG(UIS_SET, UISF_HIDEFOCUS), 0);
}
return TRUE;
case ELVM_SETCOLUMNWIDTH:
{
ULONG column = (ULONG)wParam;
LONG width = (LONG)lParam;
if (width == ELVSCW_AUTOSIZE_REMAININGSPACE)
{
RECT clientRect;
LONG availableWidth;
ULONG i;
LVCOLUMN lvColumn;
GetClientRect(hwnd, &clientRect);
availableWidth = clientRect.right;
i = 0;
lvColumn.mask = LVCF_WIDTH;
while (TRUE)
{
if (i != column)
{
if (CallWindowProc(oldWndProc, hwnd, LVM_GETCOLUMN, i, (LPARAM)&lvColumn))
{
availableWidth -= lvColumn.cx;
}
else
{
break;
}
}
i++;
}
if (availableWidth >= 40)
return CallWindowProc(oldWndProc, hwnd, LVM_SETCOLUMNWIDTH, column, availableWidth);
}
return CallWindowProc(oldWndProc, hwnd, LVM_SETCOLUMNWIDTH, column, width);
}
break;
case ELVM_SETCOMPAREFUNCTION:
{
ULONG column = (ULONG)wParam;
PPH_COMPARE_FUNCTION compareFunction = (PPH_COMPARE_FUNCTION)lParam;
if (column >= PH_MAX_COMPARE_FUNCTIONS)
return FALSE;
context->CompareFunctions[column] = compareFunction;
}
return TRUE;
case ELVM_SETCONTEXT:
{
context->Context = (PVOID)lParam;
}
return TRUE;
case ELVM_SETCURSOR:
{
context->Cursor = (HCURSOR)lParam;
}
return TRUE;
case ELVM_SETITEMCOLORFUNCTION:
{
context->ItemColorFunction = (PPH_EXTLV_GET_ITEM_COLOR)lParam;
}
return TRUE;
case ELVM_SETITEMFONTFUNCTION:
{
context->ItemFontFunction = (PPH_EXTLV_GET_ITEM_FONT)lParam;
}
return TRUE;
case ELVM_SETREDRAW:
{
if (wParam)
context->EnableRedraw++;
else
context->EnableRedraw--;
if (context->EnableRedraw == 1)
{
SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
InvalidateRect(hwnd, NULL, FALSE);
}
else if (context->EnableRedraw == 0)
{
SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
}
}
return TRUE;
case ELVM_SETSORT:
{
context->SortColumn = (ULONG)wParam;
context->SortOrder = (PH_SORT_ORDER)lParam;
PhSetHeaderSortIcon(ListView_GetHeader(hwnd), context->SortColumn, context->SortOrder);
}
return TRUE;
case ELVM_SETSORTFAST:
{
context->SortFast = !!wParam;
}
return TRUE;
case ELVM_SETTRISTATE:
{
context->TriState = !!wParam;
}
return TRUE;
case ELVM_SETTRISTATECOMPAREFUNCTION:
{
context->TriStateCompareFunction = (PPH_COMPARE_FUNCTION)lParam;
}
return TRUE;
case ELVM_SORTITEMS:
{
if (context->SortFast)
{
// This sort method is faster than the normal sort because our comparison function
// doesn't have to call the list view window procedure to get the item lParam values.
// The disadvantage of this method is that default sorting is not available - if a
// column doesn't have a comparison function, it doesn't get sorted at all.
ListView_SortItems(
hwnd,
PhpExtendedListViewCompareFastFunc,
(LPARAM)context
);
}
else
{
ListView_SortItemsEx(
hwnd,
PhpExtendedListViewCompareFunc,
(LPARAM)context
);
}
}
return TRUE;
}
return CallWindowProc(oldWndProc, hwnd, uMsg, wParam, lParam);
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam,
LPARAM lParam) {
static HWND backWnd = NULL, forwardWnd = NULL, reloadWnd = NULL,
stopWnd = NULL, editWnd = NULL;
static WNDPROC editWndOldProc = NULL;
// Static members used for the find dialog.
static FINDREPLACE fr;
static WCHAR szFindWhat[80] = {0};
static WCHAR szLastFindWhat[80] = {0};
static bool findNext = false;
static bool lastMatchCase = false;
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
#ifdef SHOW_TOOLBAR_UI
if (hWnd == editWnd) {
// Callback for the edit window
switch (message) {
case WM_CHAR:
if (wParam == VK_RETURN && g_handler.get()) {
// When the user hits the enter key load the URL
CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
wchar_t strPtr[MAX_URL_LENGTH+1] = {0};
*((LPWORD)strPtr) = MAX_URL_LENGTH;
LRESULT strLen = SendMessage(hWnd, EM_GETLINE, 0, (LPARAM)strPtr);
if (strLen > 0) {
strPtr[strLen] = 0;
browser->GetMainFrame()->LoadURL(strPtr);
}
return 0;
}
}
return (LRESULT)CallWindowProc(editWndOldProc, hWnd, message, wParam,
lParam);
} else
#endif // SHOW_TOOLBAR_UI
{
// Callback for the main window
switch (message) {
case WM_CREATE: {
// Create the single static handler class instance
g_handler = new ClientHandler();
g_handler->SetMainHwnd(hWnd);
// Create the child windows used for navigation
RECT rect;
int x = 0;
GetClientRect(hWnd, &rect);
#ifdef SHOW_TOOLBAR_UI
backWnd = CreateWindow(L"BUTTON", L"Back",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON
| WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
hWnd, (HMENU) IDC_NAV_BACK, hInst, 0);
x += BUTTON_WIDTH;
forwardWnd = CreateWindow(L"BUTTON", L"Forward",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON
| WS_DISABLED, x, 0, BUTTON_WIDTH,
URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_FORWARD,
hInst, 0);
x += BUTTON_WIDTH;
reloadWnd = CreateWindow(L"BUTTON", L"Reload",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON
| WS_DISABLED, x, 0, BUTTON_WIDTH,
URLBAR_HEIGHT, hWnd, (HMENU) IDC_NAV_RELOAD,
hInst, 0);
x += BUTTON_WIDTH;
stopWnd = CreateWindow(L"BUTTON", L"Stop",
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON
| WS_DISABLED, x, 0, BUTTON_WIDTH, URLBAR_HEIGHT,
hWnd, (HMENU) IDC_NAV_STOP, hInst, 0);
x += BUTTON_WIDTH;
editWnd = CreateWindow(L"EDIT", 0,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT |
ES_AUTOVSCROLL | ES_AUTOHSCROLL| WS_DISABLED,
x, 0, rect.right - BUTTON_WIDTH * 4,
URLBAR_HEIGHT, hWnd, 0, hInst, 0);
// Assign the edit window's WNDPROC to this function so that we can
// capture the enter key
editWndOldProc =
reinterpret_cast<WNDPROC>(GetWindowLongPtr(editWnd, GWLP_WNDPROC));
SetWindowLongPtr(editWnd, GWLP_WNDPROC,
reinterpret_cast<LONG_PTR>(WndProc));
g_handler->SetEditHwnd(editWnd);
g_handler->SetButtonHwnds(backWnd, forwardWnd, reloadWnd, stopWnd);
rect.top += URLBAR_HEIGHT;
#endif // SHOW_TOOLBAR_UI
CefWindowInfo info;
CefBrowserSettings settings;
// Populate the settings based on command line arguments.
AppGetBrowserSettings(settings);
settings.file_access_from_file_urls_allowed = true;
settings.universal_access_from_file_urls_allowed = true;
// Initialize window info to the defaults for a child window
info.SetAsChild(hWnd, rect);
// Creat the new child browser window
CefBrowserHost::CreateBrowser(info,
static_cast<CefRefPtr<CefClient> >(g_handler),
szInitialUrl, settings);
return 0;
}
case WM_COMMAND: {
CefRefPtr<CefBrowser> browser;
if (g_handler.get())
browser = g_handler->GetBrowser();
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId) {
case IDM_EXIT:
if (g_handler.get()) {
g_handler->QuittingApp(true);
g_handler->DispatchCloseToNextBrowser();
} else {
DestroyWindow(hWnd);
}
return 0;
case ID_WARN_CONSOLEMESSAGE:
/*
if (g_handler.get()) {
std::wstringstream ss;
ss << L"Console messages will be written to "
<< std::wstring(CefString(g_handler->GetLogFile()));
MessageBox(hWnd, ss.str().c_str(), L"Console Messages",
MB_OK | MB_ICONINFORMATION);
}
*/
return 0;
case ID_WARN_DOWNLOADCOMPLETE:
case ID_WARN_DOWNLOADERROR:
if (g_handler.get()) {
std::wstringstream ss;
ss << L"File \"" <<
std::wstring(CefString(g_handler->GetLastDownloadFile())) <<
L"\" ";
if (wmId == ID_WARN_DOWNLOADCOMPLETE)
ss << L"downloaded successfully.";
else
ss << L"failed to download.";
MessageBox(hWnd, ss.str().c_str(), L"File Download",
MB_OK | MB_ICONINFORMATION);
}
return 0;
#ifdef SHOW_TOOLBAR_UI
case IDC_NAV_BACK: // Back button
if (browser.get())
browser->GoBack();
return 0;
case IDC_NAV_FORWARD: // Forward button
if (browser.get())
browser->GoForward();
return 0;
case IDC_NAV_RELOAD: // Reload button
if (browser.get())
browser->Reload();
return 0;
case IDC_NAV_STOP: // Stop button
if (browser.get())
browser->StopLoad();
return 0;
#endif // SHOW_TOOLBAR_UI
default:
ExtensionString commandId = NativeMenuModel::getInstance(getMenuParent(g_handler->GetBrowser())).getCommandId(wmId);
if (commandId.size() > 0) {
CefRefPtr<CommandCallback> callback = new EditCommandCallback(g_handler->GetBrowser(), commandId);
g_handler->SendJSCommand(g_handler->GetBrowser(), commandId, callback);
}
}
break;
}
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
return 0;
case WM_SETFOCUS:
if (g_handler.get() && g_handler->GetBrowser()) {
// Pass focus to the browser window
CefWindowHandle hwnd =
g_handler->GetBrowser()->GetHost()->GetWindowHandle();
if (hwnd)
PostMessage(hwnd, WM_SETFOCUS, wParam, NULL);
}
return 0;
case WM_SIZE:
// Minimizing resizes the window to 0x0 which causes our layout to go all
// screwy, so we just ignore it.
if (wParam != SIZE_MINIMIZED && g_handler.get() &&
g_handler->GetBrowser()) {
CefWindowHandle hwnd =
g_handler->GetBrowser()->GetHost()->GetWindowHandle();
if (hwnd) {
// Resize the browser window and address bar to match the new frame
// window size
RECT rect;
GetClientRect(hWnd, &rect);
#ifdef SHOW_TOOLBAR_UI
rect.top += URLBAR_HEIGHT;
int urloffset = rect.left + BUTTON_WIDTH * 4;
#endif // SHOW_TOOLBAR_UI
HDWP hdwp = BeginDeferWindowPos(1);
#ifdef SHOW_TOOLBAR_UI
hdwp = DeferWindowPos(hdwp, editWnd, NULL, urloffset,
0, rect.right - urloffset, URLBAR_HEIGHT, SWP_NOZORDER);
#endif // SHOW_TOOLBAR_UI
hdwp = DeferWindowPos(hdwp, hwnd, NULL,
rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
SWP_NOZORDER);
EndDeferWindowPos(hdwp);
}
}
break;
case WM_ERASEBKGND:
if (g_handler.get() && g_handler->GetBrowser()) {
CefWindowHandle hwnd =
g_handler->GetBrowser()->GetHost()->GetWindowHandle();
if (hwnd) {
// Dont erase the background if the browser window has been loaded
// (this avoids flashing)
return 0;
}
}
break;
case WM_CLOSE:
if (g_handler.get()) {
HWND hWnd = GetActiveWindow();
SaveWindowRect(hWnd);
// If we already initiated the browser closing, then let default window proc handle it.
HWND browserHwnd = g_handler->GetBrowser()->GetHost()->GetWindowHandle();
HANDLE closing = GetProp(browserHwnd, CLOSING_PROP);
if (closing) {
RemoveProp(browserHwnd, CLOSING_PROP);
break;
}
g_handler->QuittingApp(true);
g_handler->DispatchCloseToNextBrowser();
return 0;
}
break;
case WM_DESTROY:
// The frame window has exited
PostQuitMessage(0);
return 0;
case WM_DROPFILES:
if (g_handler.get()) {
return HandleDropFiles((HDROP)wParam, g_handler, g_handler->GetBrowser());
}
return 0;
case WM_INITMENUPOPUP:
HMENU menu = (HMENU)wParam;
int count = GetMenuItemCount(menu);
void* menuParent = getMenuParent(g_handler->GetBrowser());
for (int i = 0; i < count; i++) {
UINT id = GetMenuItemID(menu, i);
bool enabled = NativeMenuModel::getInstance(menuParent).isMenuItemEnabled(id);
UINT flagEnabled = enabled ? MF_ENABLED | MF_BYCOMMAND : MF_DISABLED | MF_BYCOMMAND;
EnableMenuItem(menu, id, flagEnabled);
bool checked = NativeMenuModel::getInstance(menuParent).isMenuItemChecked(id);
UINT flagChecked = checked ? MF_CHECKED | MF_BYCOMMAND : MF_UNCHECKED | MF_BYCOMMAND;
CheckMenuItem(menu, id, flagChecked);
}
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
/*
* Function CHyperLink::_HyperlinkProc
*
* Note: Processed messages are not passed back to the static control
* procedure. It does work fine but be aware that it could cause
* some problems if the static control is already subclassed.
* Consider the example where the static control would be already
* subclassed with the ToolTip control that needs to process mouse
* messages. In that situation, the ToolTip control would not work
* as expected.
*/
LRESULT CALLBACK CHyperLink::_HyperlinkProc(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
CHyperLink *pHyperLink = (CHyperLink *)GetProp(hwnd, PROP_OBJECT_PTR);
switch (message)
{
case WM_MOUSEMOVE:
{
if ( pHyperLink->m_bOverControl )
{
// This is the most common case for static branch prediction
// optimization
RECT rect;
GetClientRect(hwnd,&rect);
POINT pt = { LOWORD(lParam), HIWORD(lParam) };
if (!PTINRECT(&rect,pt))
{
ReleaseCapture();
}
}
else
{
pHyperLink->m_bOverControl = TRUE;
SendMessage(hwnd, WM_SETFONT,
(WPARAM)CHyperLink::g_UnderlineFont, FALSE);
InvalidateRect(hwnd, NULL, FALSE);
pHyperLink->OnSelect();
SetCapture(hwnd);
}
return 0;
}
case WM_SETCURSOR:
{
SetCursor(CHyperLink::g_hLinkCursor);
return TRUE;
}
case WM_CAPTURECHANGED:
{
pHyperLink->m_bOverControl = FALSE;
pHyperLink->OnDeselect();
SendMessage(hwnd, WM_SETFONT,
(WPARAM)pHyperLink->m_StdFont, FALSE);
InvalidateRect(hwnd, NULL, FALSE);
return 0;
}
case WM_KEYUP:
{
if( wParam != VK_SPACE )
{
break;
}
}
// Fall through
case WM_LBUTTONUP:
{
pHyperLink->Navigate();
return 0;
}
case WM_SETFOCUS: // Fall through
case WM_KILLFOCUS:
{
if( message == WM_SETFOCUS )
{
pHyperLink->OnSelect();
}
else // WM_KILLFOCUS
{
pHyperLink->OnDeselect();
}
CHyperLink::DrawFocusRect(hwnd);
return 0;
}
case WM_DESTROY:
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC,
(LONG_PTR) pHyperLink->m_pfnOrigCtlProc);
SendMessage(hwnd, WM_SETFONT, (WPARAM) pHyperLink->m_StdFont, 0);
if( --CHyperLink::g_counter <= 0 )
{
destroyGlobalResources();
}
RemoveProp(hwnd, PROP_OBJECT_PTR);
break;
}
}
return CallWindowProc(pHyperLink->m_pfnOrigCtlProc, hwnd, message,
wParam, lParam);
}
INT_PTR CALLBACK PhpProcessTokenHookProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_DESTROY:
{
RemoveProp(hwndDlg, PhMakeContextAtom());
}
break;
case WM_SHOWWINDOW:
{
if (!GetProp(hwndDlg, PhMakeContextAtom())) // LayoutInitialized
{
PPH_LAYOUT_ITEM dialogItem;
HWND groupsLv;
HWND privilegesLv;
// This is a big violation of abstraction...
dialogItem = PhAddPropPageLayoutItem(hwndDlg, hwndDlg,
PH_PROP_PAGE_TAB_CONTROL_PARENT, PH_ANCHOR_ALL);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_USER),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_USERSID),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_VIRTUALIZED),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_APPCONTAINERSID),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_GROUPS),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_PRIVILEGES),
dialogItem, PH_ANCHOR_ALL);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_INSTRUCTION),
dialogItem, PH_ANCHOR_LEFT | PH_ANCHOR_BOTTOM);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_INTEGRITY),
dialogItem, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhAddPropPageLayoutItem(hwndDlg, GetDlgItem(hwndDlg, IDC_ADVANCED),
dialogItem, PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
PhDoPropPageLayout(hwndDlg);
groupsLv = GetDlgItem(hwndDlg, IDC_GROUPS);
privilegesLv = GetDlgItem(hwndDlg, IDC_PRIVILEGES);
if (ListView_GetItemCount(groupsLv) != 0)
{
ListView_SetColumnWidth(groupsLv, 0, LVSCW_AUTOSIZE);
ExtendedListView_SetColumnWidth(groupsLv, 1, ELVSCW_AUTOSIZE_REMAININGSPACE);
}
if (ListView_GetItemCount(privilegesLv) != 0)
{
ListView_SetColumnWidth(privilegesLv, 0, LVSCW_AUTOSIZE);
ListView_SetColumnWidth(privilegesLv, 1, LVSCW_AUTOSIZE);
ExtendedListView_SetColumnWidth(privilegesLv, 2, ELVSCW_AUTOSIZE_REMAININGSPACE);
}
SetProp(hwndDlg, PhMakeContextAtom(), (HANDLE)TRUE);
}
}
break;
}
return FALSE;
}
Bool
winCloseScreenShadowDDNL (int nIndex, ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
Bool fReturn;
#if CYGDEBUG
ErrorF ("winCloseScreenShadowDDNL - Freeing screen resources\n");
#endif
/* Flag that the screen is closed */
pScreenPriv->fClosed = TRUE;
pScreenPriv->fActive = FALSE;
/* Call the wrapped CloseScreen procedure */
pScreen->CloseScreen = pScreenPriv->CloseScreen;
fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
/* Free the screen DC */
ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
/* Delete the window property */
RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
/* Free the shadow surface, if there is one */
if (pScreenPriv->pddsShadow4)
{
IDirectDrawSurface4_Release (pScreenPriv->pddsShadow4);
free (pScreenInfo->pfb);
pScreenInfo->pfb = NULL;
pScreenPriv->pddsShadow4 = NULL;
}
/* Detach the clipper from the primary surface and release the clipper. */
if (pScreenPriv->pddcPrimary)
{
/* Detach the clipper */
IDirectDrawSurface4_SetClipper (pScreenPriv->pddsPrimary4,
NULL);
/* Release the clipper object */
IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
pScreenPriv->pddcPrimary = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary4)
{
IDirectDrawSurface4_Release (pScreenPriv->pddsPrimary4);
pScreenPriv->pddsPrimary4 = NULL;
}
/* Free the DirectDraw4 object, if there is one */
if (pScreenPriv->pdd4)
{
IDirectDraw4_RestoreDisplayMode (pScreenPriv->pdd4);
IDirectDraw4_Release (pScreenPriv->pdd4);
pScreenPriv->pdd4 = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd)
{
IDirectDraw_Release (pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Kill our window */
if (pScreenPriv->hwndScreen)
{
DestroyWindow (pScreenPriv->hwndScreen);
pScreenPriv->hwndScreen = NULL;
}
/* Destroy the thread startup mutex */
pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
/* Kill our screeninfo's pointer to the screen */
pScreenInfo->pScreen = NULL;
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
/* Free the screen privates for this screen */
free ((pointer) pScreenPriv);
return fReturn;
}
LRESULT CALLBACK CLinkControl::_HyperlinkProc(HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
CLinkControl *pHyperLink = (CLinkControl *)GetProp(hwnd, PROP_OBJECT_PTR);
switch (message)
{
case WM_MOUSEMOVE:
{
if (pHyperLink->m_bOverControl)
{
RECT rect;
GetClientRect(hwnd, &rect);
POINT pt = { LOWORD(lParam), HIWORD(lParam) };
if (!PtInRect(&rect, pt))
ReleaseCapture();
}
else
{
pHyperLink->m_bOverControl = TRUE;
SendMessage(hwnd, WM_SETFONT, (WPARAM)CLinkControl::g_UnderlineFont, FALSE);
InvalidateRect(hwnd, NULL, FALSE);
SetCapture(hwnd);
}
}
break;
case WM_SETCURSOR:
{
SetCursor(CLinkControl::g_hLinkCursor);
return TRUE;
}
break;
case WM_CAPTURECHANGED:
{
pHyperLink->m_bOverControl = FALSE;
SendMessage(hwnd, WM_SETFONT, (WPARAM)CLinkControl::g_NormalFont, FALSE);
InvalidateRect(hwnd, NULL, FALSE);
}
break;
case WM_KEYDOWN:
{
if ((wParam != VK_SPACE)&&(wParam != VK_RETURN))
break;
PostMessage(::GetParent(hwnd), LK_LINKITEMCLICKED, (WPARAM)hwnd, (LPARAM)0);
return 0;
}
break;
case WM_LBUTTONUP:
{
PostMessage(::GetParent(hwnd), LK_LINKITEMCLICKED, (WPARAM)hwnd, (LPARAM)0);
}
break;
case WM_GETDLGCODE:
{
LRESULT lres = CallWindowProc(pHyperLink->m_pfnOrigCtlProc, hwnd, message, wParam, lParam);
// we want all keys to get the return key
lres |= DLGC_WANTALLKEYS;
// but we don't want the tab key since that should be used in dialogs
// to switch the focus
lres &= ~DLGC_WANTTAB;
if (lParam &&
((MSG *)lParam)->message == WM_KEYDOWN &&
((MSG *)lParam)->wParam == VK_TAB)
{
lres &= ~DLGC_WANTMESSAGE;
}
return lres;
}
break;
case WM_SETFOCUS:
// Fall through
case WM_KILLFOCUS:
{
CLinkControl::DrawFocusRect(hwnd);
}
break;
case WM_DESTROY:
{
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)pHyperLink->m_pfnOrigCtlProc);
SendMessage(hwnd, WM_SETFONT, (WPARAM)pHyperLink->m_StdFont, 0);
if (--CLinkControl::g_counter <= 0)
destroyGlobalResources();
RemoveProp(hwnd, PROP_OBJECT_PTR);
}
break;
}
return CallWindowProc(pHyperLink->m_pfnOrigCtlProc, hwnd, message,
wParam, lParam);
}
/*
* DialogProc for OpenVPN status dialog windows
*/
INT_PTR CALLBACK
StatusDialogFunc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
connection_t *c;
switch (msg)
{
case WM_MANAGEMENT:
/* Management interface related event */
OnManagement(wParam, lParam);
return TRUE;
case WM_INITDIALOG:
c = (connection_t *) lParam;
/* Set window icon "disconnected" */
SetStatusWinIcon(hwndDlg, ID_ICO_CONNECTING);
/* Set connection for this dialog */
SetProp(hwndDlg, cfgProp, (HANDLE) c);
/* Create log window */
HWND hLogWnd = CreateWindowEx(0, RICHEDIT_CLASS, NULL,
WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_SUNKEN|ES_LEFT|
ES_MULTILINE|ES_READONLY|ES_AUTOHSCROLL|ES_AUTOVSCROLL,
20, 25, 350, 160, hwndDlg, (HMENU) ID_EDT_LOG, o.hInstance, NULL);
if (!hLogWnd)
{
ShowLocalizedMsg(IDS_ERR_CREATE_EDIT_LOGWINDOW);
return FALSE;
}
/* Set font and fontsize of the log window */
CHARFORMAT cfm = {
.cbSize = sizeof(CHARFORMAT),
.dwMask = CFM_SIZE|CFM_FACE|CFM_BOLD,
.szFaceName = _T("Microsoft Sans Serif"),
.dwEffects = 0,
.yHeight = 160
};
if (SendMessage(hLogWnd, EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM) &cfm) == 0)
ShowLocalizedMsg(IDS_ERR_SET_SIZE);
/* Set size and position of controls */
RECT rect;
GetClientRect(hwndDlg, &rect);
MoveWindow(hLogWnd, 20, 25, rect.right - 40, rect.bottom - 70, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_TXT_STATUS), 20, 5, rect.right - 25, 15, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_DISCONNECT), 20, rect.bottom - 30, 110, 23, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_RESTART), 145, rect.bottom - 30, 110, 23, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_HIDE), rect.right - 130, rect.bottom - 30, 110, 23, TRUE);
/* Set focus on the LogWindow so it scrolls automatically */
SetFocus(hLogWnd);
return FALSE;
case WM_SIZE:
MoveWindow(GetDlgItem(hwndDlg, ID_EDT_LOG), 20, 25, LOWORD(lParam) - 40, HIWORD(lParam) - 70, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_DISCONNECT), 20, HIWORD(lParam) - 30, 110, 23, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_RESTART), 145, HIWORD(lParam) - 30, 110, 23, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_HIDE), LOWORD(lParam) - 130, HIWORD(lParam) - 30, 110, 23, TRUE);
MoveWindow(GetDlgItem(hwndDlg, ID_TXT_STATUS), 20, 5, LOWORD(lParam) - 25, 15, TRUE);
InvalidateRect(hwndDlg, NULL, TRUE);
return TRUE;
case WM_COMMAND:
c = (connection_t *) GetProp(hwndDlg, cfgProp);
switch (LOWORD(wParam))
{
case ID_DISCONNECT:
SetFocus(GetDlgItem(c->hwndStatus, ID_EDT_LOG));
StopOpenVPN(c);
return TRUE;
case ID_HIDE:
if (c->state != disconnected)
ShowWindow(hwndDlg, SW_HIDE);
else
DestroyWindow(hwndDlg);
return TRUE;
case ID_RESTART:
c->state = reconnecting;
SetFocus(GetDlgItem(c->hwndStatus, ID_EDT_LOG));
ManagementCommand(c, "signal SIGHUP", NULL, regular);
return TRUE;
}
break;
case WM_SHOWWINDOW:
if (wParam == TRUE)
{
c = (connection_t *) GetProp(hwndDlg, cfgProp);
if (c->hwndStatus)
SetFocus(GetDlgItem(c->hwndStatus, ID_EDT_LOG));
}
return FALSE;
case WM_CLOSE:
c = (connection_t *) GetProp(hwndDlg, cfgProp);
if (c->state != disconnected)
ShowWindow(hwndDlg, SW_HIDE);
else
DestroyWindow(hwndDlg);
return TRUE;
case WM_NCDESTROY:
RemoveProp(hwndDlg, cfgProp);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
}
return FALSE;
}
/*
* ThreadProc for OpenVPN status dialog windows
*/
static DWORD WINAPI
ThreadOpenVPNStatus(void *p)
{
connection_t *c = p;
TCHAR conn_name[200];
MSG msg;
/* Cut of extention from config filename. */
_tcsncpy(conn_name, c->config_file, _countof(conn_name));
conn_name[_tcslen(conn_name) - _tcslen(o.ext_string) - 1] = _T('\0');
c->state = (c->state == suspended ? resuming : connecting);
/* Create and Show Status Dialog */
c->hwndStatus = CreateLocalizedDialogParam(ID_DLG_STATUS, StatusDialogFunc, (LPARAM) c);
if (!c->hwndStatus)
return 1;
CheckAndSetTrayIcon();
SetMenuStatus(c, connecting);
SetDlgItemText(c->hwndStatus, ID_TXT_STATUS, LoadLocalizedString(IDS_NFO_STATE_CONNECTING));
SetWindowText(c->hwndStatus, LoadLocalizedString(IDS_NFO_CONNECTION_XXX, conn_name));
if (!OpenManagement(c))
PostMessage(c->hwndStatus, WM_CLOSE, 0, 0);
if (o.silent_connection[0] == '0')
ShowWindow(c->hwndStatus, SW_SHOW);
/* Run the message loop for the status window */
while (GetMessage(&msg, NULL, 0, 0))
{
if (msg.hwnd == NULL)
{
switch (msg.message)
{
case WM_OVPN_STOP:
c->state = disconnecting;
RunDisconnectScript(c, false);
EnableWindow(GetDlgItem(c->hwndStatus, ID_DISCONNECT), FALSE);
EnableWindow(GetDlgItem(c->hwndStatus, ID_RESTART), FALSE);
SetMenuStatus(c, disconnecting);
SetDlgItemText(c->hwndStatus, ID_TXT_STATUS, LoadLocalizedString(IDS_NFO_STATE_WAIT_TERM));
SetEvent(c->exit_event);
break;
case WM_OVPN_SUSPEND:
c->state = suspending;
EnableWindow(GetDlgItem(c->hwndStatus, ID_DISCONNECT), FALSE);
EnableWindow(GetDlgItem(c->hwndStatus, ID_RESTART), FALSE);
SetMenuStatus(&o.conn[config], disconnecting);
SetDlgItemText(c->hwndStatus, ID_TXT_STATUS, LoadLocalizedString(IDS_NFO_STATE_WAIT_TERM));
SetEvent(c->exit_event);
break;
}
}
else if (IsDialogMessage(c->hwndStatus, &msg) == 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return 0;
}
static LRESULT CALLBACK BaseBar_WindowProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
LPBASEBARINFO lpbi = (LPBASEBARINFO)GetProp(hwnd, (LPCTSTR)MAKEWORD(s_hBaseBarAtom, 0));//GetWindowLong(hwnd, GWL_USERDATA);
switch (uMessage)
{
case WM_CREATE:
{
LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
DWORD dwStyle = RBS_VERTICALGRIPPER | RBS_REGISTERDROP | RBS_AUTOSIZE | RBS_VARHEIGHT | RBS_DBLCLKTOGGLE | CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE;
REBARBANDINFO rbBand;
TBBUTTON tbb;
if (lpcs->lpszName)
lpbi->pszTitle = String_Duplicate(lpcs->lpszName);
lpbi->dwAlign = BaseBar_GetAlign(hwnd);
lpbi->dwAllowableAligns = CCS_LEFT | CCS_RIGHT | CCS_TOP | CCS_BOTTOM;
if (lpbi->dwAlign == CCS_LEFT || lpbi->dwAlign == CCS_RIGHT)
dwStyle |= CCS_VERT;
if (!(lpbi->hwndRebar = CreateWindowEx(0, REBARCLASSNAME, NULL, WS_VISIBLE | WS_BORDER | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | dwStyle,
0, 0, 0, 0, hwnd, (HMENU) REBARID, (HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE), NULL)))
return (0);
SendMessage(lpbi->hwndRebar, RB_SETBKCOLOR, 0, (LPARAM)GetSysColor(COLOR_BTNFACE));
ZeroMemory(&rbBand, sizeof(REBARBANDINFO));
rbBand.cbSize = sizeof(REBARBANDINFO);
rbBand.fMask = RBBIM_HEADERSIZE | RBBIM_ID | RBBIM_STYLE | RBBIM_COLORS;
rbBand.fStyle = RBBS_FIXEDSIZE | RBBS_VARIABLEHEIGHT | RBBS_NOGRIPPER;
rbBand.clrFore = GetSysColor(COLOR_BTNTEXT);
rbBand.clrBack = GetSysColor(COLOR_BTNFACE);
rbBand.cxHeader = ((lpcs->style & CCS_VERT) ? 21 : 24);
rbBand.wID = (UINT)lpcs->hMenu;
if (lpcs->style & CCS_VERT)
{
rbBand.fMask |= RBBIM_TEXT;
rbBand.lpText = (char*)lpcs->lpszName;
}
SendMessage(lpbi->hwndRebar, RB_INSERTBAND, (int) -1, (LPARAM) &rbBand);
ZeroMemory(&tbb, sizeof(TBBUTTON));
tbb.iBitmap = 0;
tbb.idCommand = IDM_BAND_CLOSE;
tbb.fsState = TBSTATE_ENABLED;
tbb.fsStyle = TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE;
lpbi->hwndToolbar = CreateToolbarEx(lpbi->hwndRebar, WS_CHILDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NOMOVEY | CCS_NORESIZE | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT | TBSTYLE_TRANSPARENT,
IDC_TOOLBAR, 1, PCPControls_GetHandle(), IDB_CHECKBOX, &tbb, 1, 13, 12, 11, 10, sizeof (TBBUTTON));
SendMessage(lpbi->hwndToolbar, TB_SETBUTTONSIZE, 0, (LPARAM) MAKELONG(20, 18));
SendMessage(lpbi->hwndToolbar, TB_SETBITMAPSIZE, 0, (LPARAM) MAKELONG(10, 9));
}
return (TRUE);
case WM_SIZE:
{
RECT rcNew;
GetClientRect(hwnd, &rcNew);
if (wParam == SIZE_RESTORED && !EqualRect(&rcNew, &lpbi->rcSize))
{
NMHDR nmhdr;
MoveWindow(lpbi->hwndRebar, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
nmhdr.code = RBN_HEIGHTCHANGE;
nmhdr.hwndFrom = hwnd;
nmhdr.idFrom = GetDlgCtrlID(hwnd);
SendMessage(GetParent(hwnd), WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
if (lpbi->hwndToolbar)
{
RECT rcBand;
DWORD dwSize = (DWORD)SendMessage(lpbi->hwndToolbar, TB_GETBUTTONSIZE, 0, 0);
SendMessage(lpbi->hwndRebar, RB_GETBANDBORDERS, 0, (LPARAM)&rcBand);
if (lpbi->dwAlign == CCS_LEFT || lpbi->dwAlign == CCS_RIGHT)
{
int x = (LOWORD(lParam) - 24);
int y = ((rcBand.top - HIWORD(dwSize)) / 2);
MoveWindow(lpbi->hwndToolbar, x, y, 20, 18, TRUE);
}
else
{
MoveWindow(lpbi->hwndToolbar, 2, 2, 20, 18, TRUE);
}
}
}
GetClientRect(hwnd, &lpbi->rcSize);
}
break;
case WM_NOTIFY:
{
LPNMHDR lphdr = (LPNMHDR)lParam;
if (lphdr->code == NM_NCHITTEST && lphdr->idFrom == REBARID)
{
if (HIBYTE(GetAsyncKeyState(VK_RBUTTON)))
{
HMENU hMenu = LoadMenu(PCPControls_GetHandle(), MAKEINTRESOURCE(IDR_BANDMENU));
HMENU hPopupMenu = GetSubMenu(hMenu, 0);
POINT pt;
if (lpbi->dwAllowableAligns & CCS_VERT)
{
if (!(lpbi->dwAllowableAligns & CCS_LEFT))
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_LEFT, FALSE);
if (!(lpbi->dwAllowableAligns & CCS_RIGHT))
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_RIGHT, FALSE);
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_TOP, FALSE);
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_BOTTOM, FALSE);
}
else
{
if (!(lpbi->dwAllowableAligns & CCS_TOP))
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_TOP, FALSE);
if (!(lpbi->dwAllowableAligns & CCS_BOTTOM))
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_BOTTOM, FALSE);
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_LEFT, FALSE);
Menu_EnableMenuItem(hPopupMenu, IDM_BAND_RIGHT, FALSE);
}
GetCursorPos(&pt);
Menu_TrackPopupMenu(hPopupMenu, pt.x, pt.y, hwnd);
}
return (HTCLIENT);
}
else if (lphdr->code == NM_CUSTOMDRAW && lphdr->idFrom == REBARID)
{
LPNMCUSTOMDRAW lpnmcd = (LPNMCUSTOMDRAW) lParam;
if (lpnmcd->dwDrawStage == CDDS_PREPAINT)
return (CDRF_NOTIFYPOSTPAINT);
else if (lpnmcd->dwDrawStage == CDDS_POSTPAINT && (lpbi->dwAlign == CCS_TOP || lpbi->dwAlign == CCS_BOTTOM))
{
DrawEdge(lpnmcd->hdc, &lpnmcd->rc, EDGE_ETCHED, BF_RIGHT);
}
}
else if (lphdr->idFrom == IDC_TOOLBAR)
{
}
}
return (SendMessage(GetParent(hwnd), uMessage, wParam, lParam));
case WM_COMMAND:
{
DWORD dwAlign;
switch (LOWORD(wParam))
{
case IDM_BAND_LEFT:
dwAlign = CCS_LEFT;
break;
case IDM_BAND_RIGHT:
dwAlign = CCS_RIGHT;
break;
case IDM_BAND_TOP:
dwAlign = CCS_TOP;
break;
case IDM_BAND_BOTTOM:
dwAlign = CCS_BOTTOM;
break;
case IDM_BAND_CLOSE:
{
NMHDR nmhdr;
nmhdr.code = BBN_CLOSE;
nmhdr.hwndFrom = hwnd;
nmhdr.idFrom = GetDlgCtrlID(hwnd);
SendMessage(GetParent(hwnd), WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
}
return (0);
default:
return (0);
}
SendMessage(hwnd, BCM_SETALIGNMENT, (WPARAM)dwAlign, 0L);
}
case WM_GETMINMAXINFO:
{
MINMAXINFO *lpmmi = (MINMAXINFO *)lParam;
if (lpmmi != NULL)
{
int cx = GetSystemMetrics(SM_CXSCREEN);
int cy = GetSystemMetrics(SM_CYSCREEN);
if (lpbi->dwAlign == CCS_LEFT || lpbi->dwAlign == CCS_RIGHT)
lpmmi->ptMaxTrackSize.x = cx / 2;
else
lpmmi->ptMaxTrackSize.y = cy / 2;
if (lpbi->dwAlign == CCS_LEFT)
{
lpmmi->ptMinTrackSize.x = 50;
}
else if (lpbi->dwAlign == CCS_RIGHT)
{
lpmmi->ptMinTrackSize.x = 50;
}
else if (lpbi->dwAlign == CCS_TOP)
{
lpmmi->ptMinTrackSize.y = 50;
}
else if (lpbi->dwAlign == CCS_BOTTOM)
{
lpmmi->ptMinTrackSize.y = 50;
}
else
{
lpmmi->ptMinTrackSize.x = 56;
lpmmi->ptMinTrackSize.y = 24;
}
}
}
return (FALSE);
case WM_NCCREATE:
{
lpbi = Mem_Alloc(sizeof(BASEBARINFO));
if (lpbi == NULL)
return (FALSE);
SetProp(hwnd, (LPCTSTR)MAKEWORD(s_hBaseBarAtom, 0), lpbi);
}
return (TRUE);
case WM_NCDESTROY:
{
RemoveProp(hwnd, (LPCTSTR)MAKEWORD(s_hBaseBarAtom, 0));
if (lpbi != NULL)
{
if (lpbi->pszTitle != NULL)
Mem_Free(lpbi->pszTitle);
Mem_Free(lpbi);
}
}
return (TRUE);
case WM_NCHITTEST:
{
POINT pt = {LOWORD(lParam), HIWORD(lParam)};
RECT re;
GetWindowRect(hwnd, &re);
if (!PtInRect(&re, pt))
return (HTNOWHERE);
if (lpbi->dwAlign == CCS_LEFT)
{
re.left = re.right - 4;
if (PtInRect(&re, pt))
return (HTRIGHT);
}
else if (lpbi->dwAlign == CCS_RIGHT)
{
re.right = re.left + 4;
if (PtInRect(&re, pt))
return (HTLEFT);
}
else if (lpbi->dwAlign == CCS_BOTTOM)
{
re.bottom = re.top + 4;
if (PtInRect(&re, pt))
return (HTTOP);
}
else if (lpbi->dwAlign == CCS_TOP)
{
re.top = re.bottom - 4;
if (PtInRect(&re, pt))
return (HTBOTTOM);
}
}
return (HTCLIENT);
case WM_NCCALCSIZE:
{
if (wParam == TRUE)
{
NCCALCSIZE_PARAMS *ncp = (NCCALCSIZE_PARAMS *) lParam;
if (lpbi->dwAlign == CCS_LEFT)
{
ncp->rgrc[0].top += 4;
ncp->rgrc[0].right -= 4;
}
else if (lpbi->dwAlign == CCS_RIGHT)
{
ncp->rgrc[0].top += 4;
ncp->rgrc[0].left += 4;
}
else if (lpbi->dwAlign == CCS_BOTTOM)
{
ncp->rgrc[0].top += 4;
}
else if (lpbi->dwAlign == CCS_TOP)
{
ncp->rgrc[0].bottom -= 4;
}
else
{
ncp->rgrc[0].top += 4;
ncp->rgrc[0].right -= 4;
ncp->rgrc[0].left += 4;
ncp->rgrc[0].bottom -= 4;
}
}
}
break;
case WM_ERASEBKGND:
return (TRUE);
case WM_NCPAINT:
{
HDC hdc = GetWindowDC(hwnd);
RECT rcWindow, rcClient;
if (hdc == NULL)
break;
GetClientRect(hwnd, &rcClient);
GetWindowRect(hwnd, &rcWindow);
MapWindowPoints(NULL, hwnd, (LPPOINT)&rcWindow, 2);
OffsetRect(&rcClient, -rcWindow.left, -rcWindow.top);
OffsetRect(&rcWindow, -rcWindow.left, -rcWindow.top);
ExcludeClipRect(hdc, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
FillRect(hdc, &rcWindow, (HBRUSH)GetSysColorBrush(COLOR_BTNFACE));
ReleaseDC(hwnd, hdc);
}
return (TRUE);
case BCM_SETCLIENTWND:
{
REBARBANDINFO rbBand;
ZeroMemory(&rbBand, sizeof(REBARBANDINFO));
rbBand.cbSize = sizeof(REBARBANDINFO);
rbBand.fMask = RBBIM_CHILDSIZE | RBBIM_CHILD;
rbBand.cyIntegral = 1;
rbBand.cyMaxChild = -1;
rbBand.hwndChild = (HWND)lParam;
return (SendMessage(lpbi->hwndRebar, RB_SETBANDINFO, 0, (LPARAM)&rbBand));
}
case BCM_GETCLIENTWND:
{
REBARBANDINFO rbBand;
ZeroMemory(&rbBand, sizeof(REBARBANDINFO));
rbBand.cbSize = sizeof(REBARBANDINFO);
rbBand.fMask = RBBIM_CHILD;
SendMessage(lpbi->hwndRebar, RB_GETBANDINFO, 0, (LPARAM)&rbBand);
return (LRESULT)((IsWindow(rbBand.hwndChild) ? rbBand.hwndChild : NULL));
}
case BCM_SETIMAGELIST:
{
REBARINFO rbi;
HIMAGELIST hilOld = BandCtrl_GetImageList(hwnd);
rbi.cbSize = sizeof(REBARINFO);
rbi.fMask = RBIM_IMAGELIST;
rbi.himl = (HIMAGELIST)lParam;
if (!SendMessage(lpbi->hwndRebar, RB_SETBARINFO, 0, (LPARAM) &rbi))
return ((LRESULT)NULL);
return ((LRESULT)hilOld);
}
case BCM_GETIMAGELIST:
{
REBARINFO rbi;
rbi.cbSize = sizeof(REBARINFO);
rbi.fMask = RBIM_IMAGELIST;
rbi.himl = 0;
if (!SendMessage(lpbi->hwndRebar, RB_GETBARINFO, 0, (LPARAM) &rbi))
return ((LRESULT)NULL);
return ((LRESULT)rbi.himl);
}
case BCM_SETTITLEIMAGE:
{
REBARBANDINFO rbBand;
ZeroMemory(&rbBand, sizeof(REBARBANDINFO));
rbBand.cbSize = sizeof(REBARBANDINFO);
rbBand.fMask = RBBIM_IMAGE;
rbBand.iImage = wParam;
return (SendMessage(lpbi->hwndRebar, RB_SETBANDINFO, 0, (LPARAM)&rbBand));
}
case BCM_GETTITLEIMAGE:
{
REBARBANDINFO rbBand;
ZeroMemory(&rbBand, sizeof(REBARBANDINFO));
rbBand.cbSize = sizeof(REBARBANDINFO);
rbBand.fMask = RBBIM_IMAGE;
rbBand.iImage = -1;
SendMessage(lpbi->hwndRebar, RB_GETBANDINFO, 0, (LPARAM)&rbBand);
return (rbBand.iImage);
}
case BCM_GETALIGNMENT:
return ((LRESULT)lpbi->dwAlign);
case BCM_SETALIGNMENT:
{
NMHDR nmhdr;
DWORD dwStyle;
if (lpbi->dwAlign == wParam)
return (wParam);
lpbi->dwAlign = wParam;
dwStyle = GetWindowLong(lpbi->hwndRebar, GWL_STYLE);
dwStyle &= ~(CCS_BOTTOM | CCS_TOP | CCS_LEFT | CCS_RIGHT);
dwStyle |= lpbi->dwAlign;
SetWindowLong(lpbi->hwndRebar, GWL_STYLE, dwStyle);
SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
nmhdr.code = RBN_HEIGHTCHANGE;
nmhdr.hwndFrom = hwnd;
nmhdr.idFrom = GetDlgCtrlID(hwnd);
SendMessage(GetParent(hwnd), WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
return (lpbi->dwAlign);
}
case BCM_SETDATA:
{
LPARAM lParamOld = lpbi->lParam;
lpbi->lParam = lParam;
return (lParamOld);
}
case BCM_GETDATA:
return (lpbi->lParam);
case BCM_SETALLOWABLEALIGNS:
{
DWORD dwOldAllowableAligns = lpbi->dwAllowableAligns;
lpbi->dwAllowableAligns = lParam;
return (dwOldAllowableAligns);
}
case BCM_GETALLOWABLEALIGNS:
return (lpbi->dwAllowableAligns);
}
return (DefWindowProc(hwnd, uMessage, wParam, lParam));
}
