/*++ 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() */