754 lines
19 KiB
C++
754 lines
19 KiB
C++
/*++
|
|
|
|
Copyright (c) 1999-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
status.cpp
|
|
|
|
--*/
|
|
|
|
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
// Adjust the size as necessary.
|
|
// Obviously, if an assert that checks for mem overwrites goes off,
|
|
// don't remove the assert, increase the char array size.
|
|
// |
|
|
// \|/
|
|
#define MAX_TEMP_TXT 100
|
|
|
|
|
|
|
|
//Status Bar : Structure definition
|
|
typedef struct _STATUS
|
|
{
|
|
HWND hwndStatusBar;
|
|
|
|
// The actual text to be displayed for each item
|
|
PTSTR rgszItemText[nMAX_IDX_STATUSBAR];
|
|
|
|
// The line column text is in the following format: Ln 000, Col 000
|
|
// Where "Ln" & "Col" are loaded from the resource and since they could be
|
|
// language dependent. This is why we have to clutter the structure with
|
|
// these 2 additional references.
|
|
PTSTR lpszLinePrefix;
|
|
PTSTR lpszColumnPrefix;
|
|
|
|
// Prefix help the user figure out which is the process & thread displays
|
|
// Proc 000:000
|
|
// Thrd 000:000
|
|
PTSTR lpszProcessPrefix;
|
|
PTSTR lpszThreadPrefix;
|
|
|
|
// Indicates whether the text should be grayed out when displayed.
|
|
// TRUE - grayed out
|
|
// FALSE - normal color
|
|
BOOL rgbGrayItemText[nMAX_IDX_STATUSBAR];
|
|
|
|
// Indicates which ones are OWNER_DRAW. This is done
|
|
// so we can gray things out.
|
|
// TRUE - Owner draw
|
|
// FALSE - Normal, status bar takes care of the drawing.
|
|
int rgbOwnerDrawItem[nMAX_IDX_STATUSBAR];
|
|
|
|
|
|
// TRUE - we are in src code mode
|
|
// FALSE - we are in assembly mode
|
|
BOOL bSrcMode;
|
|
|
|
BOOL bOverType; // Overtype status
|
|
BOOL bCapsLock; // CapsLock status
|
|
BOOL bNumLock; // NumLock status
|
|
} STATUS, * LPSTATUS;
|
|
|
|
static STATUS status;
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// protos
|
|
void RecalcItemWidths_StatusBar(void);
|
|
void Internal_SetItemText_StatusBar(nIDX_STATUSBAR_ITEMS nId, PTSTR lpszNewText);
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Init/term functions
|
|
//
|
|
BOOL
|
|
CreateStatusBar(HWND hwndParent)
|
|
/*++
|
|
Routine Description:
|
|
Creates and initializes the status bar.
|
|
|
|
Arguments:
|
|
hwndParent - Hwnd to the owner of the status bar
|
|
--*/
|
|
{
|
|
TCHAR sz[MAX_MSG_TXT];
|
|
|
|
status.hwndStatusBar = CreateStatusWindow(
|
|
WS_CHILD | WS_BORDER
|
|
| WS_VISIBLE | CCS_BOTTOM, // style
|
|
_T(""), // initial text
|
|
hwndParent, // parent
|
|
IDC_STATUS_BAR); // id
|
|
if (status.hwndStatusBar == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We recalc the sizes even though we know they are 0, because,
|
|
// the status bar needs to know how many parts there will be.
|
|
//
|
|
RecalcItemWidths_StatusBar();
|
|
|
|
//
|
|
// These are the owner draw items.
|
|
//
|
|
status.rgbOwnerDrawItem[nSRCASM_IDX_STATUSBAR] = TRUE;
|
|
status.rgbOwnerDrawItem[nOVRTYPE_IDX_STATUSBAR] = TRUE;
|
|
status.rgbOwnerDrawItem[nCAPSLCK_IDX_STATUSBAR] = TRUE;
|
|
status.rgbOwnerDrawItem[nNUMLCK_IDX_STATUSBAR] = TRUE;
|
|
|
|
//
|
|
// Load the static stuff.
|
|
//
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_ASM, sz, _tsizeof(sz)));
|
|
Internal_SetItemText_StatusBar(nSRCASM_IDX_STATUSBAR, sz);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_OVERTYPE, sz, _tsizeof(sz)));
|
|
Internal_SetItemText_StatusBar(nOVRTYPE_IDX_STATUSBAR, sz);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_CAPSLOCK, sz, _tsizeof(sz)));
|
|
Internal_SetItemText_StatusBar(nCAPSLCK_IDX_STATUSBAR, sz);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_NUMLOCK, sz, _tsizeof(sz)));
|
|
Internal_SetItemText_StatusBar(nNUMLCK_IDX_STATUSBAR, sz);
|
|
|
|
//
|
|
// Preload prefixes
|
|
//
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_CURPROCID, sz, _tsizeof(sz)));
|
|
status.lpszProcessPrefix = _tcsdup(sz);
|
|
Dbg(status.lpszProcessPrefix);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_CURTHRDID, sz, _tsizeof(sz)));
|
|
status.lpszThreadPrefix = _tcsdup(sz);
|
|
Dbg(status.lpszThreadPrefix);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_LINE, sz, _tsizeof(sz)));
|
|
status.lpszLinePrefix = _tcsdup(sz);
|
|
Dbg(status.lpszLinePrefix);
|
|
|
|
Dbg(LoadString(g_hInst, STS_MESSAGE_COLUMN, sz, _tsizeof(sz)));
|
|
status.lpszColumnPrefix = _tcsdup(sz);
|
|
Dbg(status.lpszColumnPrefix);
|
|
|
|
SetLineColumn_StatusBar(0, 0);
|
|
SetPidTid_StatusBar(0, 0, 0, 0);
|
|
SetCapsLock_StatusBar(GetKeyState(VK_CAPITAL) & 0x0001);
|
|
SetNumLock_StatusBar(GetKeyState(VK_NUMLOCK) & 0x0001);
|
|
SetOverType_StatusBar(FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
TerminateStatusBar()
|
|
/*++
|
|
Routine Description:
|
|
Just frees allocated resources.
|
|
--*/
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < nMAX_IDX_STATUSBAR -1; i++)
|
|
{
|
|
if (status.rgszItemText[i])
|
|
{
|
|
free(status.rgszItemText[i]);
|
|
status.rgszItemText[i] = NULL;
|
|
}
|
|
}
|
|
|
|
if (status.lpszLinePrefix)
|
|
{
|
|
free(status.lpszLinePrefix);
|
|
status.lpszLinePrefix = NULL;
|
|
}
|
|
|
|
if (status.lpszColumnPrefix)
|
|
{
|
|
free(status.lpszColumnPrefix);
|
|
status.lpszColumnPrefix = NULL;
|
|
}
|
|
|
|
if (status.lpszProcessPrefix)
|
|
{
|
|
free(status.lpszProcessPrefix);
|
|
status.lpszProcessPrefix = NULL;
|
|
}
|
|
|
|
if (status.lpszThreadPrefix)
|
|
{
|
|
free(status.lpszThreadPrefix);
|
|
status.lpszThreadPrefix = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Operations that affect the entire status bar.
|
|
//
|
|
void
|
|
Show_StatusBar(
|
|
BOOL bShow
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Show/Hide the status bar. Automatically resizes/updates the MDI client.
|
|
|
|
Arguments:
|
|
bShow - TRUE - Show status bar
|
|
FALSE - Hide status bar
|
|
--*/
|
|
{
|
|
RECT rect;
|
|
|
|
// Show/Hide the toolbar
|
|
ShowWindow(status.hwndStatusBar, bShow ? SW_SHOW : SW_HIDE);
|
|
|
|
//Ask the frame to resize, so that everything will be correctly positioned.
|
|
GetWindowRect(g_hwndFrame, &rect);
|
|
|
|
SendMessage(g_hwndFrame, WM_SIZE, SIZE_RESTORED,
|
|
MAKELPARAM(rect.right - rect.left, rect.bottom - rect.top));
|
|
|
|
// Ask the MDIClient to redraw itself and its children.
|
|
// This is done in order to fix a redraw problem where some of the
|
|
// MDIChild window are not correctly redrawn.
|
|
Dbg(RedrawWindow(g_hwndMDIClient, NULL, NULL,
|
|
RDW_UPDATENOW | RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME));
|
|
} // UpdateToolbar()
|
|
|
|
|
|
void
|
|
WM_SIZE_StatusBar(
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Causes the status bar to be resized. This function is meant to be
|
|
called from the parent window, whenever a parent window receives a
|
|
WM_SIZE message, ie:
|
|
|
|
// parent window proc
|
|
switch (uMsg) {
|
|
case WM_SIZE:
|
|
WM_SIZE_StatusBar(wParam, lParam);
|
|
return TRUE;
|
|
...
|
|
...
|
|
...
|
|
}
|
|
|
|
Arguments:
|
|
wParam & lParam - See docs for a desciption of the WM_SIZE message.
|
|
|
|
--*/
|
|
{
|
|
// make the status bar resize.
|
|
SendMessage(status.hwndStatusBar, WM_SIZE, wParam, lParam);
|
|
|
|
// Since it was resized, the widths the text items need to be recalculated.
|
|
// The is because of the way that status bar positions the elements on the
|
|
// screen. See the docs for SB_SETPARTS, for more detail. The SB_SETPARTS
|
|
// docs will enlighten you.
|
|
RecalcItemWidths_StatusBar();
|
|
}
|
|
|
|
|
|
HWND
|
|
GetHwnd_StatusBar()
|
|
// I'm not documenting this function, everyone can figure this one out.
|
|
{
|
|
return status.hwndStatusBar;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Main text display functions
|
|
//
|
|
void
|
|
RecalcItemWidths_StatusBar(void)
|
|
/*++
|
|
Routine description:
|
|
The function will recalculate the width of the text items.
|
|
The calculations don't have to be exact. Status bar is very
|
|
forgiving and pretty much needs a rough estimate.
|
|
--*/
|
|
{
|
|
int rgnItemWidths[nMAX_IDX_STATUSBAR];
|
|
int i, nWidth;
|
|
HDC hdc;
|
|
|
|
hdc = GetDC(status.hwndStatusBar);
|
|
Dbg(hdc);
|
|
|
|
// Get the width of the status bar's client area.
|
|
{
|
|
RECT rcClient;
|
|
GetClientRect(status.hwndStatusBar, &rcClient);
|
|
nWidth = rcClient.right;
|
|
}
|
|
|
|
// Calculate the right edge coordinate for each part, and
|
|
// copy the coordinates to the array.
|
|
for (i = nMAX_IDX_STATUSBAR -1; i >= 0; i--) {
|
|
|
|
rgnItemWidths[i] = nWidth;
|
|
|
|
if (NULL == status.rgszItemText[i]) {
|
|
// We don't have any text, but we need a position anyways.
|
|
nWidth -= 10; // Just any old number
|
|
} else {
|
|
PTSTR lpsz = status.rgszItemText[i];
|
|
SIZE size;
|
|
|
|
// Skip over tabs.
|
|
// 1 tab is centered, 2 is right aligned.
|
|
// See status bar docs for more info.
|
|
if (_T('\t') == *lpsz) {
|
|
lpsz++;
|
|
if (_T('\t') == *lpsz) {
|
|
lpsz++;
|
|
}
|
|
}
|
|
|
|
Dbg(GetTextExtentPoint32(hdc, lpsz, _tcslen(lpsz), &size));
|
|
|
|
nWidth -= size.cx;
|
|
}
|
|
}
|
|
|
|
Dbg(ReleaseDC(status.hwndStatusBar, hdc));
|
|
|
|
// Tell the status window to create the window parts.
|
|
Dbg(SendMessage(status.hwndStatusBar, SB_SETPARTS,
|
|
(WPARAM) nMAX_IDX_STATUSBAR, (LPARAM) rgnItemWidths));
|
|
|
|
// The status bar invalidates the parts that changed. So it is
|
|
// automatically updated.
|
|
}
|
|
|
|
|
|
void
|
|
Internal_SetItemText_StatusBar(
|
|
nIDX_STATUSBAR_ITEMS nId,
|
|
PTSTR lpszNewText
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Set the text for a specified item.
|
|
--*/
|
|
{
|
|
// Leave these sanity checks in here.
|
|
// If they go off, someone did something wrong
|
|
// or changed some important code
|
|
Dbg((0 <= nId));
|
|
Dbg((nId < nMAX_IDX_STATUSBAR));
|
|
Dbg((lpszNewText));
|
|
|
|
// Free any previous text
|
|
if (status.rgszItemText[nId]) {
|
|
free(status.rgszItemText[nId]);
|
|
}
|
|
|
|
// duplicate the text
|
|
status.rgszItemText[nId] = _tcsdup(lpszNewText);
|
|
|
|
// Make sure it was allocated
|
|
Assert(status.rgszItemText[nId]);
|
|
|
|
// Do we have any text to set?
|
|
if (status.rgszItemText[nId]) {
|
|
int nFormat = nId;
|
|
|
|
// Make it owner draw???
|
|
if (status.rgbOwnerDrawItem[nId]) {
|
|
nFormat |= SBT_OWNERDRAW;
|
|
}
|
|
|
|
// Set the text
|
|
Dbg(SendMessage(status.hwndStatusBar, SB_SETTEXT,
|
|
(WPARAM) nFormat, (LPARAM) status.rgszItemText[nId]));
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
InvalidateItem_Statusbar(nIDX_STATUSBAR_ITEMS nIdx)
|
|
/*++
|
|
Routine description:
|
|
Invalidates the item's rect on the status bar, so that an update
|
|
to that region will take place.
|
|
|
|
Arguments:
|
|
nIdx - The status bar item that is to be updated.
|
|
--*/
|
|
{
|
|
RECT rc;
|
|
|
|
Dbg((0 <= nIdx));
|
|
Dbg((nIdx < nMAX_IDX_STATUSBAR));
|
|
|
|
SendMessage(status.hwndStatusBar, SB_GETRECT,
|
|
(WPARAM) nIdx, (LPARAM) &rc);
|
|
|
|
InvalidateRect(status.hwndStatusBar, &rc, FALSE);
|
|
}
|
|
|
|
|
|
void
|
|
OwnerDrawItem_StatusBar(
|
|
LPDRAWITEMSTRUCT lpDrawItem
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Called from the parent window for owner draw text items.
|
|
Draws an actual status bar item onto the status bar.
|
|
Depending the the flags set, it will draw the item grayed out.
|
|
|
|
Arguments:
|
|
See docs for WM_DRAWITEM, and Status bar -> owner draw items.
|
|
--*/
|
|
{
|
|
PTSTR lpszItemText = (PTSTR) lpDrawItem->itemData;
|
|
COLORREF crefOldTextColor = CLR_INVALID;
|
|
COLORREF crefOldBkColor = CLR_INVALID;
|
|
|
|
if (NULL == lpszItemText) {
|
|
// nothing to do
|
|
return;
|
|
}
|
|
|
|
// Set background color and save the old color.
|
|
crefOldBkColor = SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_3DFACE));
|
|
Assert(CLR_INVALID != crefOldBkColor);
|
|
|
|
// should the item be grayed out?
|
|
if (status.rgbGrayItemText[lpDrawItem->itemID]) {
|
|
crefOldTextColor = SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_GRAYTEXT));
|
|
Assert(CLR_INVALID != crefOldTextColor);
|
|
}
|
|
|
|
// draw the color coded text to the screen
|
|
{
|
|
UINT uFormat = DT_NOPREFIX | DT_VCENTER | DT_SINGLELINE;
|
|
|
|
// "\t" is used to center
|
|
// '\t\t" is used to right align.
|
|
// No, I did not make this up, this is the way the status bar works.
|
|
if (_T('\t') == *lpszItemText) {
|
|
lpszItemText++;
|
|
if (_T('\t') == *lpszItemText) {
|
|
// 2 tabs found
|
|
lpszItemText++;
|
|
uFormat |= DT_RIGHT;
|
|
} else {
|
|
// 1 tab found
|
|
uFormat |= DT_CENTER;
|
|
}
|
|
}
|
|
DrawText(lpDrawItem->hDC, lpszItemText, _tcslen(lpszItemText),
|
|
&lpDrawItem->rcItem, uFormat);
|
|
}
|
|
|
|
// Reset the the hDC back to its old state.
|
|
if (CLR_INVALID != crefOldTextColor) {
|
|
Dbg((CLR_INVALID != SetTextColor(lpDrawItem->hDC, crefOldTextColor)));
|
|
}
|
|
|
|
if (CLR_INVALID != crefOldBkColor) {
|
|
Dbg((CLR_INVALID != SetBkColor(lpDrawItem->hDC, crefOldBkColor)));
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
SetItemText_StatusBar(
|
|
nIDX_STATUSBAR_ITEMS nId,
|
|
PTSTR lpszNewText
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
nId -
|
|
lpszNewText
|
|
--*/
|
|
{
|
|
Internal_SetItemText_StatusBar(nId, lpszNewText);
|
|
// If nId is 0, the we don't have to recalc the widths, because this
|
|
// is the only one that doesn't affect the rest.
|
|
if (nId > 0) {
|
|
RecalcItemWidths_StatusBar();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Set/get specialized items on the status bar.
|
|
//
|
|
// All of the Get????_StatusBar retrieve the current value.
|
|
//
|
|
// All of the Set????_StatusBar set the new value and return the
|
|
// previous value.
|
|
// TRUE - Item is enabled.
|
|
// FALSE - Item is disabled.
|
|
|
|
//
|
|
// Src/Asm mode
|
|
BOOL
|
|
GetSrcMode_StatusBar()
|
|
{
|
|
return status.bSrcMode;
|
|
}
|
|
|
|
BOOL
|
|
SetSrcMode_StatusBar(
|
|
BOOL bNewValue
|
|
)
|
|
{
|
|
BOOL b = status.bSrcMode;
|
|
|
|
status.bSrcMode = bNewValue;
|
|
status.rgbGrayItemText[nSRCASM_IDX_STATUSBAR] = bNewValue;
|
|
|
|
InvalidateItem_Statusbar(nSRCASM_IDX_STATUSBAR);
|
|
|
|
// Reflect the change to the menu
|
|
InitializeMenu(GetMenu(g_hwndFrame));
|
|
|
|
/*
|
|
// Old code that was move in here.
|
|
if ( (FALSE == bNewValue) && (NULL == GetDisasmHwnd()) ) {
|
|
OpenDebugWindow(DISASM_WINDOW, TRUE); // User activated
|
|
}
|
|
*/
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
//
|
|
// Insert/Overtype mode
|
|
BOOL
|
|
GetOverType_StatusBar()
|
|
{
|
|
return status.bOverType;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SetOverType_StatusBar(BOOL bNewValue)
|
|
{
|
|
BOOL b = status.bOverType;
|
|
|
|
status.bOverType = bNewValue;
|
|
status.rgbGrayItemText[nOVRTYPE_IDX_STATUSBAR] = !bNewValue;
|
|
|
|
InvalidateItem_Statusbar(nOVRTYPE_IDX_STATUSBAR);
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
//
|
|
// Num lock mode
|
|
BOOL
|
|
GetNumLock_StatusBar()
|
|
{
|
|
return status.bNumLock;
|
|
}
|
|
|
|
BOOL
|
|
SetNumLock_StatusBar(BOOL bNewValue)
|
|
{
|
|
BOOL b = status.bNumLock;
|
|
|
|
status.bNumLock = bNewValue;
|
|
status.rgbGrayItemText[nNUMLCK_IDX_STATUSBAR] = !bNewValue;
|
|
|
|
InvalidateItem_Statusbar(nNUMLCK_IDX_STATUSBAR);
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
//
|
|
// Caps mode
|
|
BOOL
|
|
GetCapsLock_StatusBar()
|
|
{
|
|
return status.bCapsLock;
|
|
}
|
|
|
|
BOOL
|
|
SetCapsLock_StatusBar(BOOL bNewValue)
|
|
{
|
|
BOOL b = status.bCapsLock;
|
|
|
|
status.bCapsLock = bNewValue;
|
|
status.rgbGrayItemText[nCAPSLCK_IDX_STATUSBAR] = !bNewValue;
|
|
|
|
InvalidateItem_Statusbar(nCAPSLCK_IDX_STATUSBAR);
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Specialized text display functions
|
|
|
|
void
|
|
SetMessageText_StatusBar(UINT StringId)
|
|
{
|
|
TCHAR Str[MAX_TEMP_TXT];
|
|
|
|
// load format string from resource file
|
|
if (LoadString(g_hInst, StringId, Str, sizeof(Str)) == 0)
|
|
{
|
|
Str[0] = 0;
|
|
}
|
|
SetItemText_StatusBar(nMESSAGE_IDX_STATUSBAR, Str);
|
|
}
|
|
|
|
void
|
|
SetLineColumn_StatusBar(
|
|
int nNewLine,
|
|
int nNewColumn
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
Used to display the line and column values in text edit controls.
|
|
Loads the prefixs "Ln" & "Col" from the string resource section.
|
|
|
|
Arguments:
|
|
nNewLine - Line number in edit controls.
|
|
nNewColumn - Column number in edit controls.
|
|
--*/
|
|
{
|
|
TCHAR sz[MAX_TEMP_TXT];
|
|
|
|
_stprintf(sz, _T("%s %d, %s %d"), status.lpszLinePrefix, nNewLine,
|
|
status.lpszColumnPrefix, nNewColumn);
|
|
|
|
Dbg((_tcslen(sz) < _tsizeof(sz)));
|
|
|
|
SetItemText_StatusBar(nSRCLIN_IDX_STATUSBAR, sz);
|
|
}
|
|
|
|
|
|
void
|
|
SetPidTid_StatusBar(
|
|
ULONG ProcessId,
|
|
ULONG ProcessSysId,
|
|
ULONG ThreadId,
|
|
ULONG ThreadSysId
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Display the Process ID and Task ID in the status bar.
|
|
|
|
Display format:
|
|
|
|
Internal Process number:OS Process ID Internal Task number:OS Task ID
|
|
000:000 000:000
|
|
|
|
If the OS ID is greater than 3 digits, then it is displayed in hex
|
|
000:0xFFFFFFFF 000:0xFFFFFFFF
|
|
|
|
--*/
|
|
{
|
|
TCHAR sz[MAX_TEMP_TXT];
|
|
|
|
_stprintf(sz, _T("%s %03d:%x"), status.lpszProcessPrefix,
|
|
ProcessId, ProcessSysId);
|
|
|
|
// Sanity check, should never occur.
|
|
// Mem overwrite?
|
|
Assert(_tcslen(sz) < _tsizeof(sz));
|
|
|
|
SetItemText_StatusBar(nPROCID_IDX_STATUSBAR, sz);
|
|
|
|
_stprintf(sz, _T("%s %03d:%x"), status.lpszThreadPrefix,
|
|
ThreadId, ThreadSysId);
|
|
|
|
// Sanity check, should never occur.
|
|
// Mem overwrite?
|
|
Assert(_tcslen(sz) < _tsizeof(sz));
|
|
|
|
SetItemText_StatusBar(nTHRDID_IDX_STATUSBAR, sz);
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Misc helper routines
|
|
//
|
|
/****************************************************************************
|
|
|
|
FUNCTION: KeyboardHook
|
|
|
|
PURPOSE: Check if keyboard hit is NUMLOCK, CAPSLOCK or INSERT
|
|
|
|
****************************************************************************/
|
|
LRESULT
|
|
KeyboardHook(
|
|
int iCode,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
if (iCode == HC_ACTION) {
|
|
if (wParam == VK_NUMLOCK
|
|
&& HIWORD(lParam) & 0x8000 // Key up
|
|
&& GetKeyState(VK_CONTROL) >= 0) { //No Ctrl
|
|
|
|
// CAPSLOCK has been hit, refresh status
|
|
SetNumLock_StatusBar(GetKeyState(VK_NUMLOCK) & 0x0001);
|
|
|
|
} else if (wParam == VK_CAPITAL
|
|
&& HIWORD(lParam) & 0x8000 //Key up
|
|
&& GetKeyState(VK_CONTROL) >= 0) { //No Ctrl
|
|
|
|
// CAPSLOCK has been hit, refresh status
|
|
SetCapsLock_StatusBar(GetKeyState(VK_CAPITAL) & 0x0001);
|
|
|
|
} else if (wParam == VK_INSERT
|
|
&& ((HIWORD(lParam) & 0xE000) == 0x0000) //Key down was up before and No Alt
|
|
&& GetKeyState(VK_SHIFT) >= 0 //No Shift
|
|
&& GetKeyState(VK_CONTROL) >= 0) { //No Ctrl
|
|
|
|
// INSERT has been hit and refresh status if so
|
|
// We can't use the up down state, since there is no indicator light
|
|
// as a referene to the user. We simple have to toggle it.
|
|
SetOverType_StatusBar(!GetOverType_StatusBar());
|
|
}
|
|
}
|
|
|
|
return CallNextHookEx( hKeyHook, iCode, wParam, lParam );
|
|
} /* KeyboardHook() */
|