static void PutString(char *pszStr, int bCR)
{
int rval;
char *pszBS;
if (g_bRedirected)
{
rval = (bCR ? puts(pszStr) : fputs(pszStr, stdout));
if (rval)
{
fputs("\nCannot write to stdout.\n", stderr);
exit(-1);
}
}
else
{
pszBS = strchr(pszStr, '\b');
while (pszBS)
{
*pszBS = '\0';
OutText(pszStr);
fputchar('\b');
pszStr = pszBS + 1;
pszBS = strchr(pszStr, '\b');
}
OutText(pszStr);
if (bCR)
OutText("\r\n");
}
}
void ShowStat(dword AvgFPS)
{
char Buf[64];
dword L = CNumericConverter().DwordToString(AvgFPS, Buf);
DrawRect(m_SurfID, 1, 1, 256-2, 16-1, 0xFFFFFFFF);
OutText(m_SurfID, 2, 1, 0xFF000000, Buf, L);
}
void OutPercent(dword X, dword Y, dword PercentHex, dword Color, bool UsePercentSign = false)
{
dword PercentDec = (PercentHex * 10000) / 65536;
char Buf[8] = " 0.00%";
if (!UsePercentSign)
Buf[6] = 0;
dword Ofs = 2;
Buf[5] += PercentDec % 10;
PercentDec /= 10;
Buf[4] += PercentDec % 10;
PercentDec /= 10;
Buf[2] += PercentDec % 10;
PercentDec /= 10;
if (PercentDec != 0)
{
Buf[1] = '0' + PercentDec % 10;
PercentDec /= 10;
Ofs = 1;
}
if (PercentDec != 0)
{
Buf[0] = '0' + PercentDec % 10;
Ofs = 0;
}
OutText(m_SurfaceID, X + m_DigitW * Ofs, Y, Color, Buf + Ofs);
}
bool MyApp::OnCmdLineParsed(wxCmdLineParser& parser)
{
s_bDoVerbose = parser.Found(_T("v"));
if (!parser.Found(_T("f"), &m_sOutFile))
{
ReportError(_T("A filename must be specified with -f"));
return false;
}
if (!parser.Found(_T("x"), &m_sXMLFile))
{
ReportError(_T("An XML filename must be specified with -x"));
return false;
}
if (!parser.Found(_T("i")) && !parser.Found(_T("e")))
{
ReportError(_T("An action must be specified with -i or -e"));
return false;
}
m_bDoExport = parser.Found(_T("e"));
// Open the output file for writing
wxFileOutputStream OutFile(m_sXMLFile);
if (!OutFile.Ok())
{
ReportError(_T("Failed to open output XML file."));
// Set an appropriate error here
return false;
}
wxTextOutputStream OutText(OutFile);
OutText << _T("<XPFilterConfig>\n");
OutText << _T("<Private ");
m_bCancelled = false;
if (m_bDoExport) {
SVGExportDialog *dlg = new SVGExportDialog(NULL);
if (dlg->ShowModal() != wxID_OK) {
// user cancelled export
m_bCancelled = true;
} else {
// output exporter settings
if (dlg->m_SVGVersionComboBox->GetSelection() == 0)
OutText << _T("version=\"1.1\" ");
else
OutText << _T("version=\"1.2\" ");
if (dlg->m_VerboseCheckBox->IsChecked())
OutText << _T("verbose=\"1\" ");
else
OutText << _T("verbose=\"0\" ");
}
dlg->Destroy();
}
OutText << _T("/>\n");
OutText << _T("</XPFilterConfig>\n");
return true;
}
static int ShowTextAndPause(char *szMsg)
{
int ch;
short sCol;
unsigned rcSave;
if (g_bRedirected)
return(0);
rcSave = GetCursorPos();
sCol = (short)((g_nScreenCols - strlen(szMsg))/2);
SetCursorPos(g_nScreenLines, sCol);
OutText(szMsg);
while (!khit());
ch = inkey();
SetCursorPos(g_nScreenLines, sCol);
OutText(g_szBlanks);
SetCursorPos(-1, rcSave);
return(ch);
}
void OutDecimal(dword RightX, dword Y, dword Val, dword Color)
{
dword TVal = Val;
char Buf[11] = " 0";
dword Ofs = 9;
Buf[9] += TVal % 10;
TVal /= 10;
while (TVal != 0)
{
Buf[Ofs - 1] = '0' + TVal % 10;
TVal /= 10;
Ofs--;
}
OutText(m_SurfaceID, RightX - m_DigitW * (10 - Ofs), Y, Color, Buf + Ofs);
}
/*********************************************************************
* Function: WORD WndDraw(WINDOW *pW)
*
* Overview: draws window
*
********************************************************************/
WORD WndDraw(WINDOW *pW){
typedef enum {
WND_REMOVE,
WND_TITLE_BAR_DRAW,
WND_TITLE_BAR_BITMAP,
WND_TITLE_BAR_TEXT,
WND_TITLE_BAR_TEXT_DRAW,
WND_CLIENT,
WND_CLIENT_DRAW
} WND_DRAW_STATES;
SHORT temp;
static WND_DRAW_STATES state = WND_REMOVE;
while(1){
if(IsDeviceBusy())
return 0;
switch(state){
case WND_REMOVE:
if(GetState(pW,WND_HIDE)){
SetColor(pW->hdr.pGolScheme->CommonBkColor);
Bar(pW->hdr.left,pW->hdr.top,pW->hdr.right,pW->hdr.bottom);
return 1;
}
if(GetState(pW,WND_DRAW_CLIENT)){
state = WND_CLIENT;
break;
case WND_CLIENT:
GOLPanelDraw(pW->hdr.left,pW->hdr.top,pW->hdr.right,pW->hdr.bottom, 0,
pW->hdr.pGolScheme->CommonBkColor,
pW->hdr.pGolScheme->EmbossLtColor,
pW->hdr.pGolScheme->EmbossDkColor,
NULL,
GOL_EMBOSS_SIZE);
state = WND_CLIENT_DRAW;
case WND_CLIENT_DRAW:
if(!GOLPanelDrawTsk())
return 0;
}
state = WND_TITLE_BAR_DRAW;
break;
case WND_TITLE_BAR_DRAW:
if(!GetState(pW,WND_DISABLED)){
if(GetState(pW,WND_FOCUSED)){
SetColor(pW->hdr.pGolScheme->Color1);
}else{
SetColor(pW->hdr.pGolScheme->Color0);
}
}else{
SetColor(pW->hdr.pGolScheme->ColorDisabled);
}
Bar(pW->hdr.left+GOL_EMBOSS_SIZE, pW->hdr.top+GOL_EMBOSS_SIZE,
pW->hdr.right-GOL_EMBOSS_SIZE, pW->hdr.top+GOL_EMBOSS_SIZE+WND_TITLE_HEIGHT);
state = WND_TITLE_BAR_BITMAP;
break;
case WND_TITLE_BAR_BITMAP:
if (pW->pBitmap != NULL){
PutImage(pW->hdr.left+GOL_EMBOSS_SIZE,
pW->hdr.top+GOL_EMBOSS_SIZE+((WND_TITLE_HEIGHT-GetImageHeight(pW->pBitmap))>>1),
pW->pBitmap,IMAGE_NORMAL);
}
if (pW->pText != NULL){
state = WND_TITLE_BAR_TEXT;
break;
case WND_TITLE_BAR_TEXT:
SetFont(pW->hdr.pGolScheme->pFont);
if(!GetState(pW,WND_DISABLED)){
if (GetState(pW,WND_FOCUSED)){
SetColor(pW->hdr.pGolScheme->TextColor1);
}else{
SetColor(pW->hdr.pGolScheme->TextColor0);
}
}else{
SetColor(pW->hdr.pGolScheme->TextColorDisabled);
}
temp = pW->hdr.left+GOL_EMBOSS_SIZE+WND_INDENT;
if(pW->pBitmap != NULL){
temp += GetImageWidth(pW->pBitmap);
}
MoveTo(temp, pW->hdr.top+GOL_EMBOSS_SIZE+((WND_TITLE_HEIGHT-pW->textHeight)>>1));
state = WND_TITLE_BAR_TEXT_DRAW;
case WND_TITLE_BAR_TEXT_DRAW:
if(!OutText(pW->pText))
return 0;
}
state = WND_REMOVE;
return 1;
}//end of switch
/*********************************************************************
* Function: WORD BtnDraw(BUTTON *pB)
*
*
* Notes: This is the state machine to draw the button.
*
********************************************************************/
WORD BtnDraw(BUTTON *pB)
{
typedef enum {
REMOVE,
BEVEL_DRAW,
RNDBUTTON_DRAW,
TEXT_DRAW,
TEXT_DRAW_RUN,
FOCUS_DRAW,
} BTN_DRAW_STATES;
static BTN_DRAW_STATES state = REMOVE;
static SHORT width, height, radius;
WORD faceClr, embossLtClr, embossDkClr, xText, yText;
if(IsDeviceBusy())
return 0;
switch(state){
case REMOVE:
if(IsDeviceBusy())
return 0;
if (GetState(pB,BTN_HIDE)) { // Hide the button (remove from screen)
SetColor(pB->hdr.pGolScheme->CommonBkColor);
Bar(pB->hdr.left, pB->hdr.top, pB->hdr.right, pB->hdr.bottom);
return 1;
}
/* Note: that width and height adjustment considers the following assumptions:
1. if circular width = height = radius*2
2. if vertical capsule width = radius*2
3. if horizontal capsule height = radius*2
4. radius must be less than or equal to width if height is greater than width
5. radius must be less than or equal to height if width is greater than height
6. if button is cornered, radius must be zero
*/
radius = pB->radius; // get radius
width = (pB->hdr.right - pB->hdr.left) - (radius*2); // get width
height = (pB->hdr.bottom - pB->hdr.top) - (radius*2); // get height
state = BEVEL_DRAW;
case BEVEL_DRAW:
if(!GetState(pB,BTN_DISABLED)){
if(GetState(pB,BTN_PRESSED)){
embossDkClr = pB->hdr.pGolScheme->EmbossLtColor;
embossLtClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->Color1;
} else {
embossLtClr = pB->hdr.pGolScheme->EmbossLtColor;
embossDkClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->Color0;
}
}else{
embossLtClr = pB->hdr.pGolScheme->EmbossLtColor;
embossDkClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->ColorDisabled;
}
SetLineThickness(NORMAL_LINE);
SetLineType(SOLID_LINE);
GOLPanelDraw(pB->hdr.left+radius, pB->hdr.top+radius, pB->hdr.right-radius,
pB->hdr.bottom-radius, radius, faceClr, embossLtClr, embossDkClr,
pB->pBitmap, GOL_EMBOSS_SIZE);
state = RNDBUTTON_DRAW;
case RNDBUTTON_DRAW:
if(!GOLPanelDrawTsk()){
return 0;
}
state = TEXT_DRAW;
case TEXT_DRAW:
if (pB->pText != NULL){
if (!GetState(pB,BTN_DISABLED)){
if (GetState(pB,BTN_PRESSED)){
SetColor(pB->hdr.pGolScheme->TextColor1);
}else{
SetColor(pB->hdr.pGolScheme->TextColor0);
}
}
else{
SetColor(pB->hdr.pGolScheme->TextColorDisabled);
}
SetFont(pB->hdr.pGolScheme->pFont);
// check text alignment
if (GetState(pB, BTN_TEXTRIGHT))
xText = pB->hdr.right-(pB->textWidth+GOL_EMBOSS_SIZE+2);
else if (GetState(pB, BTN_TEXTLEFT))
xText = pB->hdr.left+GOL_EMBOSS_SIZE+2;
else
xText = (pB->hdr.left+pB->hdr.right-pB->textWidth)>>1;
if (GetState(pB, BTN_TEXTTOP))
yText = pB->hdr.top+GOL_EMBOSS_SIZE+2;
else if (GetState(pB, BTN_TEXTBOTTOM))
yText = pB->hdr.bottom-(pB->textHeight+GOL_EMBOSS_SIZE);
else
yText = (pB->hdr.bottom+pB->hdr.top-pB->textHeight)>>1;
MoveTo(xText, yText);
state = TEXT_DRAW_RUN;
}else {
state = FOCUS_DRAW;
goto rnd_button_draw_focus;
}
case TEXT_DRAW_RUN:
if(!OutText(pB->pText))
return 0;
state = FOCUS_DRAW;
case FOCUS_DRAW:
rnd_button_draw_focus:
if(IsDeviceBusy())
return 0;
if(GetState(pB,BTN_FOCUSED)){
SetLineType(FOCUS_LINE);
if(GetState(pB,BTN_PRESSED)) {
SetColor(pB->hdr.pGolScheme->TextColor1);
} else {
SetColor(pB->hdr.pGolScheme->TextColor0);
}
// check if the object has rounded corners or not
if (!pB->radius) {
Rectangle( pB->hdr.left+GOL_EMBOSS_SIZE+2 , pB->hdr.top+GOL_EMBOSS_SIZE+2,
pB->hdr.right-GOL_EMBOSS_SIZE-2, pB->hdr.bottom-GOL_EMBOSS_SIZE-2);
}
else {
// original center is still the same, but radius is reduced
Bevel( pB->hdr.left+radius, pB->hdr.top+radius, \
pB->hdr.right-radius, pB->hdr.bottom-radius, \
radius - 2 - GOL_EMBOSS_SIZE);
}
SetLineType(SOLID_LINE);
}
state = REMOVE;
return 1;
}
/*********************************************************************
* Function: WORD CbDraw(CHECKBOX *pCb)
*
* Output: returns the status of the drawing
* 0 - not complete
* 1 - done
*
* Overview: Draws check box.
*
********************************************************************/
WORD CbDraw(CHECKBOX *pCb)
{
typedef enum {
REMOVE,
BOX_DRAW,
RUN_DRAW,
TEXT_DRAW,
TEXT_DRAW_RUN,
CHECK_DRAW,
FOCUS_DRAW
} CB_DRAW_STATES;
static CB_DRAW_STATES state = REMOVE;
SHORT checkIndent;
if(IsDeviceBusy())
return 0;
switch(state) {
case REMOVE:
if(GetState(pCb,CB_HIDE|CB_DRAW)) {
if(IsDeviceBusy())
return 0;
SetColor(pCb->hdr.pGolScheme->CommonBkColor);
Bar(pCb->hdr.left,pCb->hdr.top,pCb->hdr.right,pCb->hdr.bottom);
if(GetState(pCb,CB_HIDE))
return 1;
}
state = BOX_DRAW;
case BOX_DRAW:
if(GetState(pCb,CB_DRAW)) {
if(!GetState(pCb,CB_DISABLED)) {
GOLPanelDraw(pCb->hdr.left+CB_INDENT,pCb->hdr.top+CB_INDENT,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-CB_INDENT,
pCb->hdr.bottom-CB_INDENT, 0,
pCb->hdr.pGolScheme->Color0,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL, GOL_EMBOSS_SIZE);
} else {
GOLPanelDraw(pCb->hdr.left+CB_INDENT,pCb->hdr.top+CB_INDENT,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-CB_INDENT,
pCb->hdr.bottom-CB_INDENT, 0,
pCb->hdr.pGolScheme->ColorDisabled,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL, GOL_EMBOSS_SIZE);
}
state = RUN_DRAW;
case RUN_DRAW:
if(!GOLPanelDrawTsk())
return 0;
state = TEXT_DRAW;
case TEXT_DRAW:
if(pCb->pText != NULL) {
SetFont(pCb->hdr.pGolScheme->pFont);
if (!GetState(pCb,CB_DISABLED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->TextColorDisabled);
}
MoveTo(pCb->hdr.left+pCb->hdr.bottom-pCb->hdr.top+CB_INDENT,
(pCb->hdr.bottom+pCb->hdr.top-pCb->textHeight)>>1);
state = TEXT_DRAW_RUN;
case TEXT_DRAW_RUN:
if(!OutText(pCb->pText))
return 0;
}
}
state = CHECK_DRAW;
case CHECK_DRAW:
if(GetState(pCb,CB_DRAW|CB_DRAW_CHECK)) {
if(IsDeviceBusy())
return 0;
if(!GetState(pCb,CB_DISABLED)) {
if(GetState(pCb,CB_CHECKED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->Color0);
}
} else {
if(GetState(pCb,CB_CHECKED)) {
SetColor(pCb->hdr.pGolScheme->TextColorDisabled);
} else {
SetColor(pCb->hdr.pGolScheme->ColorDisabled);
}
}
checkIndent = (pCb->hdr.bottom-pCb->hdr.top)>>2;
Bar(pCb->hdr.left+checkIndent+GOL_EMBOSS_SIZE,
pCb->hdr.top+checkIndent+GOL_EMBOSS_SIZE,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-checkIndent-GOL_EMBOSS_SIZE,
pCb->hdr.bottom-checkIndent-GOL_EMBOSS_SIZE);
}
state = FOCUS_DRAW;
case FOCUS_DRAW:
if(GetState(pCb,CB_DRAW|CB_DRAW_FOCUS)) {
if(IsDeviceBusy())
return 0;
if(GetState(pCb,CB_FOCUSED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->CommonBkColor);
}
SetLineType(FOCUS_LINE);
Rectangle(pCb->hdr.left, pCb->hdr.top,
pCb->hdr.right, pCb->hdr.bottom);
SetLineType(SOLID_LINE);
}
state = REMOVE;
return 1;
}
CProcInfo()
{
KeWaitForSymbol(Sm_InitStage2);
m_TickCount = 0;
m_KernelTime = 0;
m_VisualProgressIndex = 6;
m_SurfaceActivated = true;
m_X = 20;
m_Y = 20;
m_Width = 236;
m_Height = m_Margin * 4 + (m_VisibleProcCount + 4) * m_FontH;
char Digit = '0';
KeRequestCall(ClFont_GetTextWidth, PB(&Digit), 1, PB(&m_DigitW), 4);
m_SurfaceID = CreateSurface(m_X, m_Y, m_Width, m_Height);
DrawActiveBorder();
DrawRect(m_SurfaceID, 1, 1, m_Width - 2, m_Margin * 3 + m_FontH * 4 - 1, m_BGColor);
OutText(m_SurfaceID, m_Margin, m_Margin + m_FontH * 0, 0xFFA020A0, "Page Usage:");
OutText(m_SurfaceID, m_Margin, m_Margin + m_FontH * 1, 0xFFA020A0, "Heap Usage:");
OutText(m_SurfaceID, m_Margin, m_Margin + m_FontH * 2, 0xFFA020A0, "Kernel Time:");
OutText(m_SurfaceID, m_Margin+4, m_Margin*2 + m_FontH * 3, 0xFF2020A0, "ID");
OutText(m_SurfaceID, m_Margin+18, m_Margin*2 + m_FontH * 3, 0xFF20A020, "Mem");
OutText(m_SurfaceID, m_Margin+52, m_Margin*2 + m_FontH * 3, 0xFFA0A020, "Nf");
OutText(m_SurfaceID, m_Margin+74, m_Margin*2 + m_FontH * 3, 0xFF20A0A0, "Usr");
OutText(m_SurfaceID, m_Margin+104, m_Margin*2 + m_FontH * 3, 0xFF20A0A0, "Krn");
OutText(m_SurfaceID, m_Margin+128, m_Margin*2 + m_FontH * 3, 0xFFA02020, "Name");
KeEnableNotification(NfKe_TimerTick);
KeEnableNotification(Nf_SurfaceActivated);
KeEnableNotification(NfKe_TerminateProcess);
CNotification<4> N;
for (;;)
{
KeWaitFor(1);
N.Recv();
if (N.GetID() == Nf_SurfaceActivated)
{
dword activatedSurfaceID = N.GetDword(0);
if (activatedSurfaceID == m_SurfaceID)
{
if (!m_SurfaceActivated)
{
m_SurfaceActivated = true;
DrawActiveBorder();
}
}
else
{
if (m_SurfaceActivated)
{
m_SurfaceActivated = false;
DrawActiveBorder();
}
}
}
else if (N.GetID() == NfKe_TimerTick)
{
if (m_TickCount % 144 == 0)
{
m_ProcList.Clear();
CProcData PD;
char Name[128];
dword PrevPID = 0;
for (;;)
{
dword PID = KeGetNextProcessInfo(PrevPID,
PD.m_UsedPageCount, PD.m_NotificationCount,
PD.m_UserPerfData, PD.m_KernelPerfData, Name);
if (PID == 0xFFFFFFFF)
break;
PD.m_PID = PID;
PD.m_Name = CStringA(Name);
m_ProcList.PushBack(PD);
PrevPID = PID;
}
qword UserTotalG = 0;
qword KernelTotalG = 0;
for (dword i = 0; i < m_ProcList.Size(); i++)
{
qword UserTotalL = 0;
qword KernelTotalL = 0;
for (dword j = 0; j < 128; j++)
{
UserTotalL += m_ProcList[i].m_UserPerfData[j];
KernelTotalL += m_ProcList[i].m_KernelPerfData[j];
}
m_ProcList[i].m_UserTotal = UserTotalL;
m_ProcList[i].m_KernelTotal = KernelTotalL;
UserTotalG += UserTotalL;
KernelTotalG += KernelTotalL;
}
for (dword i = 0; i < m_ProcList.Size(); i++)
{
m_ProcList[i].m_UserPercent = (m_ProcList[i].m_UserTotal << 16) / UserTotalG;
m_ProcList[i].m_KernelPercent = (m_ProcList[i].m_KernelTotal << 16) / KernelTotalG;
}
m_KernelTime = (KernelTotalG << 16) / (KernelTotalG + UserTotalG);
DrawRect(m_SurfaceID, 1, m_Margin * 3 + m_FontH * 4,
m_Width - 2, m_Height - (m_Margin * 3 + m_FontH * 4) - 1, m_BGColor);
dword VisibleProcCount = m_ProcList.Size();
if (VisibleProcCount > m_VisibleProcCount)
VisibleProcCount = m_VisibleProcCount;
for (dword i = 0; i < VisibleProcCount; i++)
{
char CharBuf[5] = {0};
dword XOffset = m_Margin + 14;
dword YOffset = m_Margin * 3 + m_FontH * (4 + i);
OutDecimal(XOffset, YOffset, m_ProcList[i].m_PID, 0xFF2020A0);
XOffset += 24;
OutDecimal(XOffset, YOffset, m_ProcList[i].m_UsedPageCount, 0xFF20A020);
XOffset += 22;
OutDecimal(XOffset, YOffset, m_ProcList[i].m_NotificationCount, 0xFFA0A020);
XOffset += 0;
OutPercent(XOffset, YOffset, m_ProcList[i].m_UserPercent, 0xFF20A0A0);
XOffset += 32;
OutPercent(XOffset, YOffset, m_ProcList[i].m_KernelPercent, 0xFF20A0A0);
XOffset += 36;
OutText(m_SurfaceID, XOffset, YOffset, 0xFFA02020, m_ProcList[i].m_Name._ptr());
}
}
if (m_TickCount % 24 == 0)
{
dword HeapUsed;
dword HeapTotal;
dword PageUsed;
dword PageTotal;
KeGetMemInfo(HeapUsed, HeapTotal, PageUsed, PageTotal);
dword PageUsage = dword((qword(PageUsed) * 0x10000) / PageTotal);
dword HeapUsage = dword((qword(HeapUsed) * 0x10000) / HeapTotal);
dword KernelTime = 0;
dword HeapColor = 0xFF20A0A0;
if (HeapUsage > 0x9999)
HeapColor = 0xFFF8BF16;
if (HeapUsage > 0xB333)
HeapColor = 0xFFFA5914;
DrawRect(m_SurfaceID, m_Margin + 74, m_Margin, 48, m_FontH * 3, m_BGColor);
OutPercent(m_Margin + 74, m_Margin + m_FontH * 0, PageUsage, 0xFF20A0A0, true);
OutPercent(m_Margin + 74, m_Margin + m_FontH * 1, HeapUsage, HeapColor, true);
OutPercent(m_Margin + 74, m_Margin + m_FontH * 2, m_KernelTime, 0xFF20A0A0, true);
dword PrevVP = m_VisualProgressIndex;
m_VisualProgressIndex++;
if (m_VisualProgressIndex >= 6)
m_VisualProgressIndex = 0;
dword C1 = 0xFFB0B8FF;
dword C2 = 0xFFD0D4FF;
if (m_VisualProgressIndex == 0)
{
C1 = 0xFFFFA393;
C2 = 0xFFFFCCC4;
}
DrawRect(m_SurfaceID, 140 + PrevVP * 12,
m_FontH + m_Margin + 4, 8, 8, m_BGColor);
DrawRect(m_SurfaceID, 140 + m_VisualProgressIndex * 12,
m_FontH + m_Margin + 4, 8, 8, C1);
DrawRect(m_SurfaceID, 140 + m_VisualProgressIndex * 12 + 1,
m_FontH + m_Margin + 4 + 1, 6, 6, C2);
}
if (m_TickCount == 0)
{
ShowSurface(m_SurfaceID);
}
m_TickCount++;
}
else if (N.GetID() == NfKe_TerminateProcess)
{
return;
}
}
}
