evtdetctl.c File Reference

#include "eventvwr.h"
#include "evtdetctl.h"
#include <shellapi.h>

Include dependency graph for evtdetctl.c:

Go to the source code of this file.

Classes
struct	_DETAILDATA

Macros
#define	EVENT_MESSAGE_EVENTTEXT_BUFFER   (1024*10)

Typedefs
typedef struct _DETAILDATA	DETAILDATA
typedef struct _DETAILDATA *	PDETAILDATA

Functions
BOOL	GetEventMessage (IN LPCWSTR KeyName, IN LPCWSTR SourceName, IN PEVENTLOGRECORD pevlr, OUT PWCHAR EventText)
static VOID	DisplayEvent (_In_ HWND hDlg, _In_ PDETAILDATA pDetailData)
static UINT	PrintByteDataLine (PWCHAR pBuffer, UINT uOffset, PBYTE pData, UINT uLength)
static UINT	PrintWordDataLine (PWCHAR pBuffer, UINT uOffset, PULONG pData, UINT uLength)
static VOID	DisplayEventData (_In_ HWND hDlg, _In_ PDETAILDATA pDetailData)
static HFONT	CreateMonospaceFont (VOID)
static VOID	CopyEventEntry (HWND hWnd)
static VOID	OnLink (HWND hDlg, ENLINK *penLink)
static VOID	OnScroll (HWND hDlg, PDETAILDATA pData, INT nBar, WORD sbCode)
static VOID	OnSize (HWND hDlg, PDETAILDATA pData, INT cx, INT cy)
static VOID	InitDetailsDlgCtrl (HWND hDlg, PDETAILDATA pData)
static INT_PTR CALLBACK	EventDetailsCtrl (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
HWND	CreateEventDetailsCtrl (HINSTANCE hInstance, HWND hParentWnd, LPARAM lParam)
VOID	EnableEventDetailsButtons (HWND hWnd, BOOL bEnable)

Variables
WCHAR	szTitle []
HWND	hwndListView

Macro Definition Documentation

EVENT_MESSAGE_EVENTTEXT_BUFFER

#define EVENT_MESSAGE_EVENTTEXT_BUFFER   (1024*10)

Definition at line 16 of file evtdetctl.c.

Typedef Documentation

DETAILDATA

typedef struct _DETAILDATA DETAILDATA

PDETAILDATA

typedef struct _DETAILDATA * PDETAILDATA

Function Documentation

CopyEventEntry()

static VOID CopyEventEntry ( HWND  hWnd )

static

Definition at line 267 of file evtdetctl.c.

{
    WCHAR tmpHeader[512];
    WCHAR szEventType[MAX_PATH];
    WCHAR szSource[MAX_PATH];
    WCHAR szCategory[MAX_PATH];
    WCHAR szEventID[MAX_PATH];
    WCHAR szDate[MAX_PATH];
    WCHAR szTime[MAX_PATH];
    WCHAR szUser[MAX_PATH];
    WCHAR szComputer[MAX_PATH];
    WCHAR evtDesc[EVENT_MESSAGE_EVENTTEXT_BUFFER];
    ULONG size = 0;
    LPWSTR output;
    HGLOBAL hMem;
 
    /* Try to open the clipboard */
    if (!OpenClipboard(hWnd))
        return;
 
    /* Get the formatted text needed to place the content into */
    size += LoadStringW(hInst, IDS_COPY, tmpHeader, ARRAYSIZE(tmpHeader));
 
    /* Grab all the information and get it ready for the clipboard */
    size += GetDlgItemTextW(hWnd, IDC_EVENTTYPESTATIC, szEventType, ARRAYSIZE(szEventType));
    size += GetDlgItemTextW(hWnd, IDC_EVENTSOURCESTATIC, szSource, ARRAYSIZE(szSource));
    size += GetDlgItemTextW(hWnd, IDC_EVENTCATEGORYSTATIC, szCategory, ARRAYSIZE(szCategory));
    size += GetDlgItemTextW(hWnd, IDC_EVENTIDSTATIC, szEventID, ARRAYSIZE(szEventID));
    size += GetDlgItemTextW(hWnd, IDC_EVENTDATESTATIC, szDate, ARRAYSIZE(szDate));
    size += GetDlgItemTextW(hWnd, IDC_EVENTTIMESTATIC, szTime, ARRAYSIZE(szTime));
    size += GetDlgItemTextW(hWnd, IDC_EVENTUSERSTATIC, szUser, ARRAYSIZE(szUser));
    size += GetDlgItemTextW(hWnd, IDC_EVENTCOMPUTERSTATIC, szComputer, ARRAYSIZE(szComputer));
    size += GetDlgItemTextW(hWnd, IDC_EVENTTEXTEDIT, evtDesc, ARRAYSIZE(evtDesc));
 
    size++; /* Null-termination */
    size *= sizeof(WCHAR);
 
    /*
     * Consolidate the information into one big piece and
     * sort out the memory needed to write to the clipboard.
     */
    hMem = GlobalAlloc(GMEM_MOVEABLE, size);
    if (hMem == NULL) goto Quit;
 
    output = GlobalLock(hMem);
    if (output == NULL)
    {
        GlobalFree(hMem);
        goto Quit;
    }
 
    StringCbPrintfW(output, size,
                    tmpHeader, szEventType, szSource, szCategory, szEventID,
                    szDate, szTime, szUser, szComputer, evtDesc);
 
    GlobalUnlock(hMem);
 
    /* We succeeded, empty the clipboard and write the data in it */
    EmptyClipboard();
    SetClipboardData(CF_UNICODETEXT, hMem);
 
Quit:
    /* Close the clipboard once we are done with it */
    CloseClipboard();
}

Referenced by EventDetailsCtrl().

CreateEventDetailsCtrl()

HWND CreateEventDetailsCtrl	(	HINSTANCE	hInstance,
		HWND	hParentWnd,
		LPARAM	lParam
	)

Definition at line 954 of file evtdetctl.c.

{
    return CreateDialogParamW(hInstance,
                              MAKEINTRESOURCEW(IDD_EVENTDETAILS_CTRL),
                              hParentWnd, EventDetailsCtrl, lParam);
}

Referenced by EventDetails(), and InitInstance().

CreateMonospaceFont()

static HFONT CreateMonospaceFont ( VOID  )

static

Definition at line 246 of file evtdetctl.c.

{
    LOGFONTW tmpFont = {0};
    HFONT hFont;
    HDC hDC;
 
    hDC = GetDC(NULL);
 
    tmpFont.lfHeight = -MulDiv(8, GetDeviceCaps(hDC, LOGPIXELSY), 72);
    tmpFont.lfWeight = FW_NORMAL;
    wcscpy(tmpFont.lfFaceName, L"Courier New");
 
    hFont = CreateFontIndirectW(&tmpFont);
 
    ReleaseDC(NULL, hDC);
 
    return hFont;
}

Referenced by EventDetailsCtrl().

DisplayEvent()

static VOID DisplayEvent ( _In_ HWND  hDlg, _In_ PDETAILDATA  pDetailData  )

static

Definition at line 43 of file evtdetctl.c.

{
    PEVENTLOGFILTER EventLogFilter = pDetailData->EventLogFilter;
    INT iItem = pDetailData->iEventItem;
    LVITEMW li;
    PEVENTLOGRECORD pevlr;
    BOOL bEventData;
 
    WCHAR szEventType[MAX_PATH];
    WCHAR szTime[MAX_PATH];
    WCHAR szDate[MAX_PATH];
    WCHAR szUser[MAX_PATH];
    WCHAR szComputer[MAX_PATH];
    WCHAR szSource[MAX_PATH];
    WCHAR szCategory[MAX_PATH];
    WCHAR szEventID[MAX_PATH];
    WCHAR szEventText[EVENT_MESSAGE_EVENTTEXT_BUFFER];
 
    li.mask = LVIF_PARAM;
    li.iItem = iItem;
    li.iSubItem = 0;
    ListView_GetItem(hwndListView, &li);
 
    pevlr = (PEVENTLOGRECORD)li.lParam;
 
    ListView_GetItemText(hwndListView, iItem, 0, szEventType, ARRAYSIZE(szEventType));
    ListView_GetItemText(hwndListView, iItem, 1, szDate, ARRAYSIZE(szDate));
    ListView_GetItemText(hwndListView, iItem, 2, szTime, ARRAYSIZE(szTime));
    ListView_GetItemText(hwndListView, iItem, 3, szSource, ARRAYSIZE(szSource));
    ListView_GetItemText(hwndListView, iItem, 4, szCategory, ARRAYSIZE(szCategory));
    ListView_GetItemText(hwndListView, iItem, 5, szEventID, ARRAYSIZE(szEventID));
    ListView_GetItemText(hwndListView, iItem, 6, szUser, ARRAYSIZE(szUser));
    ListView_GetItemText(hwndListView, iItem, 7, szComputer, ARRAYSIZE(szComputer));
 
    SetDlgItemTextW(hDlg, IDC_EVENTDATESTATIC, szDate);
    SetDlgItemTextW(hDlg, IDC_EVENTTIMESTATIC, szTime);
    SetDlgItemTextW(hDlg, IDC_EVENTUSERSTATIC, szUser);
    SetDlgItemTextW(hDlg, IDC_EVENTSOURCESTATIC, szSource);
    SetDlgItemTextW(hDlg, IDC_EVENTCOMPUTERSTATIC, szComputer);
    SetDlgItemTextW(hDlg, IDC_EVENTCATEGORYSTATIC, szCategory);
    SetDlgItemTextW(hDlg, IDC_EVENTIDSTATIC, szEventID);
    SetDlgItemTextW(hDlg, IDC_EVENTTYPESTATIC, szEventType);
 
    bEventData = (pevlr->DataLength > 0);
    EnableDlgItem(hDlg, IDC_BYTESRADIO, bEventData);
    EnableDlgItem(hDlg, IDC_WORDRADIO, bEventData);
 
    // FIXME: At the moment we support only one event log in the filter
    GetEventMessage(EventLogFilter->EventLogs[0]->LogName, szSource, pevlr, szEventText);
    SetDlgItemTextW(hDlg, IDC_EVENTTEXTEDIT, szEventText);
}

Referenced by EventDetailsCtrl().

DisplayEventData()

static VOID DisplayEventData ( _In_ HWND  hDlg, _In_ PDETAILDATA  pDetailData  )

static

Definition at line 178 of file evtdetctl.c.

{
    BOOL bDisplayWords = pDetailData->bDisplayWords;
    INT iItem = pDetailData->iEventItem;
    LVITEMW li;
    PEVENTLOGRECORD pevlr;
 
    LPBYTE pData;
    UINT i, uOffset;
    UINT uBufferSize, uLineLength;
    PWCHAR pTextBuffer, pLine;
 
    li.mask = LVIF_PARAM;
    li.iItem = iItem;
    li.iSubItem = 0;
    ListView_GetItem(hwndListView, &li);
 
    pevlr = (PEVENTLOGRECORD)li.lParam;
    if (pevlr->DataLength == 0)
    {
        SetDlgItemTextW(hDlg, IDC_EVENTDATAEDIT, L"");
        return;
    }
 
    if (bDisplayWords)
        uBufferSize = ((pevlr->DataLength / 8) + 1) * 26 * sizeof(WCHAR);
    else
        uBufferSize = ((pevlr->DataLength / 8) + 1) * 43 * sizeof(WCHAR);
 
    pTextBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, uBufferSize);
    if (!pTextBuffer)
        return;
 
    pLine = pTextBuffer;
    uOffset = 0;
 
    for (i = 0; i < pevlr->DataLength / 8; i++)
    {
        pData = (LPBYTE)((LPBYTE)pevlr + pevlr->DataOffset + uOffset);
 
        if (bDisplayWords)
            uLineLength = PrintWordDataLine(pLine, uOffset, (PULONG)pData, 8);
        else
            uLineLength = PrintByteDataLine(pLine, uOffset, pData, 8);
        pLine = pLine + uLineLength;
 
        uOffset += 8;
    }
 
    if (pevlr->DataLength % 8 != 0)
    {
        pData = (LPBYTE)((LPBYTE)pevlr + pevlr->DataOffset + uOffset);
 
        if (bDisplayWords)
            PrintWordDataLine(pLine, uOffset, (PULONG)pData, pevlr->DataLength % 8);
        else
            PrintByteDataLine(pLine, uOffset, pData, pevlr->DataLength % 8);
    }
 
    SetDlgItemTextW(hDlg, IDC_EVENTDATAEDIT, pTextBuffer);
 
    HeapFree(GetProcessHeap(), 0, pTextBuffer);
}

Referenced by EventDetailsCtrl().

EnableEventDetailsButtons()

VOID EnableEventDetailsButtons	(	HWND	hWnd,
		BOOL	bEnable
	)

Definition at line 964 of file evtdetctl.c.

{
    EnableDlgItem(hWnd, IDC_PREVIOUS, bEnable);
    EnableDlgItem(hWnd, IDC_NEXT, bEnable);
    EnableDlgItem(hWnd, IDC_COPY, bEnable);
}

Referenced by EnumEventsThread().

EventDetailsCtrl()

static INT_PTR CALLBACK EventDetailsCtrl ( HWND  hDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 769 of file evtdetctl.c.

{
    PDETAILDATA pData;
 
    pData = (PDETAILDATA)GetWindowLongPtrW(hDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            RECT rect;
 
            pData = (PDETAILDATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pData));
            if (!pData)
            {
                EndDialog(hDlg, 0);
                return (INT_PTR)TRUE;
            }
            SetWindowLongPtrW(hDlg, DWLP_USER, (LONG_PTR)pData);
 
            if (lParam != 0)
            {
                PEVENTDETAIL_INFO DetailInfo = (PEVENTDETAIL_INFO)lParam;
                pData->EventLogFilter = DetailInfo->EventLogFilter;
                pData->iEventItem     = DetailInfo->iEventItem;
            }
            else
            {
                pData->iEventItem = -1;
            }
 
            pData->bDisplayWords  = FALSE;
            pData->hMonospaceFont = CreateMonospaceFont();
 
            GetClientRect(hDlg, &rect);
            pData->cxOld = pData->cxMin = rect.right - rect.left;
            pData->cyOld = pData->cyMin = rect.bottom - rect.top;
            pData->scPos.x = pData->scPos.y = 0;
 
            InitDetailsDlgCtrl(hDlg, pData);
 
            // OnSize(hDlg, pData, pData->cxOld, pData->cyOld);
            return (INT_PTR)TRUE;
        }
 
        case WM_DESTROY:
            if (pData)
            {
                if (pData->hMonospaceFont)
                    DeleteObject(pData->hMonospaceFont);
                HeapFree(GetProcessHeap(), 0, pData);
            }
            return (INT_PTR)TRUE;
 
        case EVT_SETFILTER:
            pData->EventLogFilter = (PEVENTLOGFILTER)lParam;
            return (INT_PTR)TRUE;
 
        case EVT_DISPLAY:
        {
            pData->iEventItem = (INT)lParam;
            if (pData->EventLogFilter)
            {
                /* Show event info in control */
                DisplayEvent(hDlg, pData);
                DisplayEventData(hDlg, pData);
            }
            return (INT_PTR)TRUE;
        }
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_PREVIOUS:
                case IDC_NEXT:
                {
                    BOOL bPrev = (LOWORD(wParam) == IDC_PREVIOUS);
                    INT iItem, iSel, nItems = ListView_GetItemCount(hwndListView);
                    WCHAR szText[200];
 
                    if (nItems <= 0) /* No items? */
                        break;
 
                    /* Select the previous/next item from our current one */
                    iItem = ListView_GetNextItem(hwndListView, -1, LVNI_ALL | LVNI_SELECTED);
                    iItem = ListView_GetNextItem(hwndListView, iItem,
                                                 (bPrev ? LVNI_ABOVE : LVNI_BELOW));
                    if (iItem < 0 || iItem >= nItems)
                    {
                        LoadStringW(hInst,
                                    (bPrev ? IDS_CONTFROMEND : IDS_CONTFROMBEGINNING),
                                    szText, _countof(szText));
                        if (MessageBoxW(hDlg, szText, szTitle, MB_YESNO | MB_ICONQUESTION) == IDNO)
                            break;
 
                        /* Determine from where to restart */
                        iItem = (bPrev ? (nItems - 1) : 0);
                    }
 
                    /*
                     * Deselect the currently selected items in the list view.
                     * (They may be different from our current one, if multiple
                     * event details are being displayed concurrently!)
                     */
                    iSel = -1;
                    while ((iSel = ListView_GetNextItem(hwndListView, iSel, LVNI_SELECTED)) != -1)
                    {
                        ListView_SetItemState(hwndListView, iSel,
                                              0, LVIS_FOCUSED | LVIS_SELECTED);
                    }
 
                    /* Select the new item */
                    ListView_SetItemState(hwndListView, iItem,
                                          LVIS_FOCUSED | LVIS_SELECTED,
                                          LVIS_FOCUSED | LVIS_SELECTED);
                    ListView_EnsureVisible(hwndListView, iItem, FALSE);
 
                    pData->iEventItem = iItem;
 
                    /* Show event info in control */
                    if (pData->EventLogFilter)
                    {
                        DisplayEvent(hDlg, pData);
                        DisplayEventData(hDlg, pData);
                    }
                    return (INT_PTR)TRUE;
                }
 
                case IDC_COPY:
                    if (pData->EventLogFilter)
                        CopyEventEntry(hDlg);
                    return (INT_PTR)TRUE;
 
                case IDC_BYTESRADIO:
                case IDC_WORDRADIO:
                {
                    if (pData->EventLogFilter)
                    {
                        pData->bDisplayWords = (LOWORD(wParam) == IDC_WORDRADIO);
                        DisplayEventData(hDlg, pData);
                    }
                    return (INT_PTR)TRUE;
                }
 
                default:
                    break;
            }
            break;
 
        case WM_NOTIFY:
        {
            LPNMHDR hdr = (LPNMHDR)lParam;
 
            if (hdr->idFrom == IDC_EVENTTEXTEDIT)
            {
                switch (hdr->code)
                {
                    case EN_LINK:
                        OnLink(hDlg, (ENLINK*)lParam);
                        break;
                }
            }
            break;
        }
 
        case WM_HSCROLL:
        case WM_VSCROLL:
        {
            OnScroll(hDlg, pData,
                     (uMsg == WM_HSCROLL) ? SB_HORZ : SB_VERT,
                     LOWORD(wParam));
            SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, 0);
            return (INT_PTR)TRUE;
        }
 
        case WM_SIZE:
            OnSize(hDlg, pData, LOWORD(lParam), HIWORD(lParam));
            SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, 0);
            return (INT_PTR)TRUE;
    }
 
    return (INT_PTR)FALSE;
}

Referenced by CreateEventDetailsCtrl().

GetEventMessage()

BOOL GetEventMessage	(	IN LPCWSTR	KeyName,
		IN LPCWSTR	SourceName,
		IN PEVENTLOGRECORD	pevlr,
		OUT PWCHAR	EventText
	)

Definition at line 1639 of file eventvwr.c.

{
    BOOL Success = FALSE;
    DWORD i;
    size_t cch;
    WCHAR SourceModuleName[1024];
    WCHAR ParameterModuleName[1024];
    BOOL IsParamModNameCached = FALSE;
    LPWSTR lpMsgBuf = NULL;
    LPWSTR szStringArray, szMessage;
    LPWSTR *szArguments;
 
    /* Get the event string array */
    szStringArray = (LPWSTR)((LPBYTE)pevlr + pevlr->StringOffset);
 
    /* NOTE: GetEventMessageFileDLL can return a comma-separated list of DLLs */
    if (!GetEventMessageFileDLL(KeyName, SourceName, EVENT_MESSAGE_FILE, SourceModuleName))
        goto Quit;
 
    /* Allocate space for insertion strings */
    szArguments = HeapAlloc(GetProcessHeap(), 0, pevlr->NumStrings * sizeof(LPVOID));
    if (!szArguments)
        goto Quit;
 
    if (!IsParamModNameCached)
    {
        /* Now that the parameter file list is loaded, no need to reload it at the next run! */
        IsParamModNameCached = GetEventMessageFileDLL(KeyName, SourceName, EVENT_PARAMETER_MESSAGE_FILE, ParameterModuleName);
        // FIXME: If the string loading failed the first time, no need to retry it just after???
    }
 
    if (IsParamModNameCached)
    {
        /* Not yet support for reading messages from parameter message DLL */
    }
 
    szMessage = szStringArray;
    /*
     * HACK:
     * We do some hackish preformatting of the cached event strings...
     * That's because after we pass the string to FormatMessage
     * (via GetMessageStringFromDllList) with the FORMAT_MESSAGE_ARGUMENT_ARRAY
     * flag, instead of ignoring the insertion parameters and do the formatting
     * by ourselves. Therefore, the resulting string should have the parameter
     * string placeholders starting with a single '%' instead of a mix of one
     * and two '%'.
     */
    /* HACK part 1: Compute the full length of the string array */
    cch = 0;
    for (i = 0; i < pevlr->NumStrings; i++)
    {
        szMessage += wcslen(szMessage) + 1;
    }
    cch = szMessage - szStringArray;
 
    /* HACK part 2: Now do the HACK proper! */
    szMessage = szStringArray;
    for (i = 0; i < pevlr->NumStrings; i++)
    {
        lpMsgBuf = szMessage;
        while ((lpMsgBuf = wcsstr(lpMsgBuf, L"%%")))
        {
            if (iswdigit(lpMsgBuf[2]))
            {
                MoveMemory(lpMsgBuf, lpMsgBuf+1, ((szStringArray + cch) - lpMsgBuf - 1) * sizeof(WCHAR));
            }
        }
 
        szArguments[i] = szMessage;
        szMessage += wcslen(szMessage) + 1;
    }
 
    /* Retrieve the message string without appending extra newlines */
    lpMsgBuf =
    GetMessageStringFromDllList(SourceModuleName,
                                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE |
                                FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_MAX_WIDTH_MASK,
                                pevlr->EventID,
                                0,
                                (va_list*)szArguments);
    if (lpMsgBuf)
    {
        /* Trim the string */
        TrimNulls(lpMsgBuf);
 
        szMessage = NULL;
        Success = (ApplyParameterStringsToMessage(ParameterModuleName,
                                                  TRUE,
                                                  lpMsgBuf,
                                                  &szMessage) == ERROR_SUCCESS);
        if (Success && szMessage)
        {
            /* Free the buffer allocated by FormatMessage */
            LocalFree(lpMsgBuf);
            lpMsgBuf = szMessage;
        }
 
        /* Copy the event text */
        StringCchCopyW(EventText, EVENT_MESSAGE_EVENTTEXT_BUFFER, lpMsgBuf);
 
        /* Free the buffer allocated by FormatMessage */
        LocalFree(lpMsgBuf);
    }
 
    HeapFree(GetProcessHeap(), 0, szArguments);
 
Quit:
    if (!Success)
    {
        /* Get a read-only pointer to the "event-not-found" string */
        lpMsgBuf = HeapAlloc(GetProcessHeap(), 0, EVENT_MESSAGE_EVENTTEXT_BUFFER * sizeof(WCHAR));
        LoadStringW(hInst, IDS_EVENTSTRINGIDNOTFOUND, lpMsgBuf, EVENT_MESSAGE_EVENTTEXT_BUFFER);
        StringCchPrintfW(EventText, EVENT_MESSAGE_EVENTTEXT_BUFFER, lpMsgBuf, (pevlr->EventID & 0xFFFF), SourceName);
 
        /* Append the strings */
        szMessage = szStringArray;
        for (i = 0; i < pevlr->NumStrings; i++)
        {
            StringCchCatW(EventText, EVENT_MESSAGE_EVENTTEXT_BUFFER, szMessage);
            StringCchCatW(EventText, EVENT_MESSAGE_EVENTTEXT_BUFFER, L"\n");
            szMessage += wcslen(szMessage) + 1;
        }
    }
 
    return Success;
}

Referenced by DisplayEvent().

InitDetailsDlgCtrl()

static VOID InitDetailsDlgCtrl ( HWND  hDlg, PDETAILDATA  pData  )

static

Definition at line 733 of file evtdetctl.c.

{
    DWORD dwMask;
 
    HANDLE nextIcon = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_NEXT), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
    HANDLE prevIcon = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_PREV), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
    HANDLE copyIcon = LoadImageW(hInst, MAKEINTRESOURCEW(IDI_COPY), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
 
    SendDlgItemMessageW(hDlg, IDC_NEXT, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)nextIcon);
    SendDlgItemMessageW(hDlg, IDC_PREVIOUS, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)prevIcon);
    SendDlgItemMessageW(hDlg, IDC_COPY, BM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)copyIcon);
 
    /* Set the default read-only RichEdit color */
    SendDlgItemMessageW(hDlg, IDC_EVENTTEXTEDIT, EM_SETBKGNDCOLOR, 0, GetSysColor(COLOR_3DFACE));
 
    /* Enable RichEdit coloured and underlined links */
    dwMask = SendDlgItemMessageW(hDlg, IDC_EVENTTEXTEDIT, EM_GETEVENTMASK, 0, 0);
    SendDlgItemMessageW(hDlg, IDC_EVENTTEXTEDIT, EM_SETEVENTMASK, 0, dwMask | ENM_LINK | ENM_MOUSEEVENTS);
 
    /*
     * Activate automatic URL recognition by the RichEdit control. For more information, see:
     * https://learn.microsoft.com/en-us/archive/blogs/murrays/automatic-richedit-hyperlinks
     * https://learn.microsoft.com/en-us/archive/blogs/murrays/richedit-friendly-name-hyperlinks
     * https://learn.microsoft.com/en-us/windows/win32/controls/em-autourldetect
     */
    SendDlgItemMessageW(hDlg, IDC_EVENTTEXTEDIT, EM_AUTOURLDETECT, AURL_ENABLEURL /* | AURL_ENABLEEAURLS */, 0);
 
    /* Note that the RichEdit control never gets themed under WinXP+; one would have to write code to simulate Edit-control theming */
 
    SendDlgItemMessageW(hDlg, pData->bDisplayWords ? IDC_WORDRADIO : IDC_BYTESRADIO, BM_SETCHECK, BST_CHECKED, 0);
    SendDlgItemMessageW(hDlg, IDC_EVENTDATAEDIT, WM_SETFONT, (WPARAM)pData->hMonospaceFont, (LPARAM)TRUE);
}

Referenced by EventDetailsCtrl().

OnLink()

static VOID OnLink ( HWND  hDlg, ENLINK *  penLink  )

static

Definition at line 335 of file evtdetctl.c.

{
    LPWSTR pLink;
    TEXTRANGE txtRange;
 
    ASSERT(penLink->nmhdr.idFrom == IDC_EVENTTEXTEDIT);
 
    /* Only act on left button up events */
    if (penLink->msg != WM_LBUTTONUP)
        return;
 
    /* If the range is empty, do nothing */
    if (penLink->chrg.cpMin == penLink->chrg.cpMax)
        return;
 
    /* Allocate memory for the text link */
    pLink = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                      (max(penLink->chrg.cpMin, penLink->chrg.cpMax) -
                       min(penLink->chrg.cpMin, penLink->chrg.cpMax) + 1) * sizeof(WCHAR));
    if (!pLink)
    {
        /* Not enough memory, bail out */
        return;
    }
 
    txtRange.chrg = penLink->chrg;
    txtRange.lpstrText = pLink;
    SendDlgItemMessageW(hDlg, IDC_EVENTTEXTEDIT, EM_GETTEXTRANGE, 0, (LPARAM)&txtRange);
 
    /* Open the link */
    ShellExecuteW(hDlg, L"open", pLink, NULL, NULL, SW_SHOWNOACTIVATE);
 
    /* Free the buffer */
    HeapFree(GetProcessHeap(), 0, pLink);
}

Referenced by EventDetailsCtrl().

OnScroll()

static VOID OnScroll ( HWND  hDlg, PDETAILDATA  pData, INT  nBar, WORD  sbCode  )

static

Definition at line 373 of file evtdetctl.c.

{
    RECT rect;
 
    SCROLLINFO sInfo;
    INT oldPos, Maximum;
    PLONG pOriginXY;
 
    ASSERT(nBar == SB_HORZ || nBar == SB_VERT);
 
    GetClientRect(hDlg, &rect);
 
    if (nBar == SB_HORZ)
    {
        Maximum = pData->cxMin - (rect.right-rect.left) /* pData->cxOld */;
        pOriginXY = &pData->scPos.x;
    }
    else // if (nBar == SB_VERT)
    {
        Maximum = pData->cyMin - (rect.bottom-rect.top) /* pData->cyOld */;
        pOriginXY = &pData->scPos.y;
    }
 
    /* Set scrollbar sizes */
    sInfo.cbSize = sizeof(sInfo);
    sInfo.fMask = SIF_RANGE | SIF_POS | SIF_PAGE | SIF_TRACKPOS;
 
    if (!GetScrollInfo(hDlg, nBar, &sInfo))
        return;
 
    oldPos = sInfo.nPos;
 
    switch (sbCode)
    {
        case SB_LINEUP:   // SB_LINELEFT:
            sInfo.nPos--;
            break;
 
        case SB_LINEDOWN: // SB_LINERIGHT:
            sInfo.nPos++;
            break;
 
        case SB_PAGEUP:   // SB_PAGELEFT:
            sInfo.nPos -= sInfo.nPage;
            break;
 
        case SB_PAGEDOWN: // SB_PAGERIGHT:
            sInfo.nPos += sInfo.nPage;
            break;
 
        case SB_THUMBTRACK:
            sInfo.nPos = sInfo.nTrackPos;
            break;
 
        case SB_THUMBPOSITION:
            sInfo.nPos = sInfo.nTrackPos;
            break;
 
        case SB_TOP:    // SB_LEFT:
            sInfo.nPos = sInfo.nMin;
            break;
 
        case SB_BOTTOM: // SB_RIGHT:
            sInfo.nPos = sInfo.nMax;
            break;
 
        default:
            break;
    }
 
    sInfo.nPos = min(max(sInfo.nPos, 0), Maximum);
 
    if (oldPos != sInfo.nPos)
    {
        POINT scOldPos = pData->scPos;
 
        /* We now modify pData->scPos */
        *pOriginXY = sInfo.nPos;
 
        ScrollWindowEx(hDlg,
                       (scOldPos.x - pData->scPos.x),
                       (scOldPos.y - pData->scPos.y),
                       NULL,
                       NULL,
                       NULL,
                       NULL,
                       SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN);
 
        sInfo.fMask = SIF_POS;
        SetScrollInfo(hDlg, nBar, &sInfo, TRUE);
 
        // UpdateWindow(hDlg);
    }
}

Referenced by EventDetailsCtrl().

OnSize()

static VOID OnSize ( HWND  hDlg, PDETAILDATA  pData, INT  cx, INT  cy  )

static

y += (cy - pData->cyOld) / 2 ; // + (cy - pData->cyOld) % 2;

SWP_NOMOVE |

Definition at line 470 of file evtdetctl.c.

{
    LONG_PTR dwStyle;
    INT sbVXSize, sbHYSize;
    SCROLLINFO sInfo;
    POINT scOldPos;
    HDWP hdwp;
    HWND hItemWnd;
    RECT rect;
    INT  y = 0;
 
    if (!pData)
        return;
 
    dwStyle  = GetWindowLongPtrW(hDlg, GWL_STYLE);
    sbVXSize = GetSystemMetrics(SM_CXVSCROLL);
    sbHYSize = GetSystemMetrics(SM_CYHSCROLL);
 
    /* Compensate for existing scroll bars (because lParam values do not accommodate scroll bar) */
    if (dwStyle & WS_HSCROLL) cy += sbHYSize; // Window currently has a horizontal scrollbar
    if (dwStyle & WS_VSCROLL) cx += sbVXSize; // Window currently has a vertical scrollbar
 
    /* Compensate for added scroll bars in window */
    if (cx < pData->cxMin) cy -= sbHYSize; // Window will have a horizontal scroll bar
    if (cy < pData->cyMin) cx -= sbVXSize; // Window will have a vertical scroll bar
 
    /* Set scrollbar sizes */
    sInfo.cbSize = sizeof(sInfo);
 
    sInfo.fMask = SIF_POS;
    if (GetScrollInfo(hDlg, SB_VERT, &sInfo))
        scOldPos.y = sInfo.nPos;
    else
        scOldPos.y = pData->scPos.y;
 
    sInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    sInfo.nMin = 0;
    if (pData->cyMin > cy)
    {
        sInfo.nMax  = pData->cyMin - 1;
        sInfo.nPage = cy;
        sInfo.nPos  = pData->scPos.y;
        SetScrollInfo(hDlg, SB_VERT, &sInfo, TRUE);
 
        /* Display the scrollbar if needed */
        if (!(dwStyle & WS_VSCROLL))
            ShowScrollBar(hDlg, SB_VERT, TRUE);
    }
    else
    {
        scOldPos.y = 0;
 
        sInfo.nMax  = pData->cyMin - 1;
        sInfo.nPage = cy;
        sInfo.nPos  = pData->scPos.y;
        sInfo.nPos  = scOldPos.y;
        SetScrollInfo(hDlg, SB_VERT, &sInfo, TRUE);
 
        ShowScrollBar(hDlg, SB_VERT, FALSE);
 
        rect.left   = cx - sbVXSize;
        rect.right  = cx;
        rect.top    = 0;
        rect.bottom = cy;
        InvalidateRect(hDlg, &rect, TRUE);
    }
 
    sInfo.fMask = SIF_POS;
    if (GetScrollInfo(hDlg, SB_HORZ, &sInfo))
        scOldPos.x = sInfo.nPos;
    else
        scOldPos.x = pData->scPos.x;
 
    sInfo.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
    sInfo.nMin = 0;
    if (pData->cxMin > cx)
    {
        sInfo.nMax  = pData->cxMin - 1;
        sInfo.nPage = cx;
        sInfo.nPos  = pData->scPos.x;
        SetScrollInfo(hDlg, SB_HORZ, &sInfo, TRUE);
 
        /* Display the scrollbar if needed */
        if (!(dwStyle & WS_HSCROLL))
            ShowScrollBar(hDlg, SB_HORZ, TRUE);
    }
    else
    {
        scOldPos.x = 0;
 
        sInfo.nMax  = pData->cxMin - 1;
        sInfo.nPage = cx;
        sInfo.nPos  = pData->scPos.x;
        sInfo.nPos  = scOldPos.x;
        SetScrollInfo(hDlg, SB_HORZ, &sInfo, TRUE);
 
        ShowScrollBar(hDlg, SB_HORZ, FALSE);
 
        rect.left   = 0;
        rect.right  = cx;
        rect.top    = cy - sbHYSize;
        rect.bottom = cy;
        InvalidateRect(hDlg, &rect, TRUE);
    }
 
    if ((scOldPos.x != pData->scPos.x) || (scOldPos.y != pData->scPos.y))
    {
        ScrollWindowEx(hDlg,
                       // (scOldPos.x - pData->scPos.x),
                       (pData->scPos.x - scOldPos.x),
                       // (scOldPos.y - pData->scPos.y),
                       (pData->scPos.y - scOldPos.y),
                       NULL,
                       NULL,
                       NULL,
                       NULL,
                       SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN);
 
        pData->scPos = scOldPos;
    }
 
    // /* Adjust the start of the visible area if we are attempting to show nonexistent areas */
    // if ((pData->cxMin - pData->scPos.x) < cx) pData->scPos.x = pData->cxMin - cx;
    // if ((pData->cyMin - pData->scPos.y) < cy) pData->scPos.y = pData->cyMin - cy;
    // // InvalidateRect(GuiData->hWindow, NULL, TRUE);
 
    /* Forbid resizing the control smaller than its minimal size */
    if (cx < pData->cxMin) cx = pData->cxMin;
    if (cy < pData->cyMin) cy = pData->cyMin;
 
    if ((cx != pData->cxOld) || (cy != pData->cyOld))
    {
        hdwp = BeginDeferWindowPos(8);
 
        /* Move the edit boxes */
 
        GetWindowRect(hDlg, &rect);
 
        hItemWnd = GetDlgItem(hDlg, IDC_EVENTTEXTEDIT);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
        // OffsetRect(&rect, 0, y);
        // y += (cy - pData->cyOld) / 2 ; // + (cy - pData->cyOld) % 2;
        if (cy >= pData->cyOld)
            y += (cy - pData->cyOld) / 2 + (cy - pData->cyOld) % 2;
        else
            y -= (pData->cyOld - cy) / 2 + (pData->cyOld - cy) % 2;
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left, rect.top,
                                  (rect.right - rect.left) + (cx - pData->cxOld),
                                  (rect.bottom - rect.top) + y, SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_DETAILS_STATIC);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
        // OffsetRect(&rect, 0, y);
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left, rect.top + y,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_BYTESRADIO);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
        // OffsetRect(&rect, 0, y);
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left, rect.top + y,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_WORDRADIO);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
        // OffsetRect(&rect, 0, y);
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left, rect.top + y,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_EVENTDATAEDIT);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
        // OffsetRect(&rect, 0, y);
        // // y -= (cy - pData->cyOld) % 2;
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left, rect.top + y,
                                  (rect.right - rect.left) + (cx - pData->cxOld),
                                  (rect.bottom - rect.top) + y,
                                  SWP_NOZORDER | SWP_NOACTIVATE);
 
        /* Move the buttons */
 
        hItemWnd = GetDlgItem(hDlg, IDC_PREVIOUS);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left + (cx - pData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_NEXT);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left + (cx - pData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        hItemWnd = GetDlgItem(hDlg, IDC_COPY);
        GetWindowRect(hItemWnd, &rect);
        MapWindowPoints(HWND_DESKTOP /*NULL*/, hDlg, (LPPOINT)&rect, sizeof(RECT)/sizeof(POINT));
 
        if (hdwp)
            hdwp = DeferWindowPos(hdwp,
                                  hItemWnd,
                                  0,
                                  rect.left + (cx - pData->cxOld),
                                  rect.top,
                                  0, 0,
                                  SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
        if (hdwp)
            EndDeferWindowPos(hdwp);
 
        pData->cxOld = cx;
        pData->cyOld = cy;
    }
}

Referenced by EventDetailsCtrl().

PrintByteDataLine()

static UINT PrintByteDataLine ( PWCHAR  pBuffer, UINT  uOffset, PBYTE  pData, UINT  uLength  )

static

Definition at line 99 of file evtdetctl.c.

{
    PWCHAR p = pBuffer;
    UINT n, i, r = 0;
 
    if (uOffset != 0)
    {
        n = swprintf(p, L"\r\n");
        p += n;
        r += n;
    }
 
    n = swprintf(p, L"%04lx:", uOffset);
    p += n;
    r += n;
 
    for (i = 0; i < uLength; i++)
    {
        n = swprintf(p, L" %02x", pData[i]);
        p += n;
        r += n;
    }
 
    for (i = 0; i < 9 - uLength; i++)
    {
        n = swprintf(p, L"   ");
        p += n;
        r += n;
    }
 
    for (i = 0; i < uLength; i++)
    {
        // NOTE: Normally iswprint should return FALSE for tabs...
        n = swprintf(p, L"%c", (iswprint(pData[i]) && (pData[i] != L'\t')) ? pData[i] : L'.');
        p += n;
        r += n;
    }
 
    return r;
}

Referenced by DisplayEventData().

PrintWordDataLine()

static UINT PrintWordDataLine ( PWCHAR  pBuffer, UINT  uOffset, PULONG  pData, UINT  uLength  )

static

Definition at line 142 of file evtdetctl.c.

{
    PWCHAR p = pBuffer;
    UINT n, i, r = 0;
 
    if (uOffset != 0)
    {
        n = swprintf(p, L"\r\n");
        p += n;
        r += n;
    }
 
    n = swprintf(p, L"%04lx:", uOffset);
    p += n;
    r += n;
 
    for (i = 0; i < uLength / sizeof(ULONG); i++)
    {
        n = swprintf(p, L" %08lx", pData[i]);
        p += n;
        r += n;
    }
 
    /* Display the remaining bytes if uLength was not a multiple of sizeof(ULONG) */
    for (i = (uLength / sizeof(ULONG)) * sizeof(ULONG); i < uLength; i++)
    {
        n = swprintf(p, L" %02x", ((PBYTE)pData)[i]);
        p += n;
        r += n;
    }
 
    return r;
}

Referenced by DisplayEventData().

Variable Documentation

hwndListView

HWND hwndListView

extern

Definition at line 66 of file eventvwr.c.

Referenced by CDesktopBrowser::_Resize(), AddEmptyItem(), AddUserProfile(), AddUserProfiles(), AddValuesToList(), AdvProcDetailsDlgProc(), BrowseRequiredFolder(), ChangeUserProfileType(), CopyUserProfile(), DeleteUserProfile(), DisplayClassCoinstallers(), DisplayClassProperties(), DisplayCsFlags(), DisplayCurrentPowerState(), DisplayDeviceCoinstallers(), DisplayDeviceProperties(), DisplayDevicePropertyText(), DisplayDeviceRelations(), DisplayDevNodeEnumerator(), DisplayDevNodeFlags(), DisplayEvent(), DisplayEventData(), DisplayMatchingDeviceId(), DisplayPowerCapabilities(), DisplayPowerStateMappings(), EditVariableDlgProc(), EnumEventsThread(), EventDetailsCtrl(), GatherDataFromListView(), GetEnvironmentVariables(), GetSelectedListViewItem(), CDesktopBrowser::Initialize(), InitInstance(), MoveListItem(), NtUserSetShellWindowEx(), OnDeleteVariable(), OnEditVariable(), OnGroupsPageInitDialog(), OnInitDialog(), OnInitEnvironmentDialog(), OnNewVariable(), ReleaseListViewItems(), ResizeWnd(), SetAllVars(), SetEnvironmentDialogListViewColumns(), SetGroupsListColumns(), SetListViewColumns(), SetUsersListColumns(), StartStopEnumEventsThread(), UpdateButtonState(), UpdateDetailsDlg(), UpdateGroupsList(), UpdateUsersList(), and WndProc().

szTitle

WCHAR szTitle[]

extern

Definition at line 35 of file magnifier.c.

Referenced by EventDetailsCtrl().