archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/base/mvdm/wow16/user/wmsyserr.c

1263 lines
38 KiB
Raw Permalink Blame History

/*++
*
* WOW v1.0
*
* Copyright (c) 1991, Microsoft Corporation
*
* WMSYSERR.C
* WOW16 system error box handling services
*
* History:
*
* Created 28-May-1991 by Jeff Parsons (jeffpar)
* Copied from WIN31 and edited (as little as possible) for WOW16.
* At this time, all we want is DrawFrame(), which the edit controls use.
--*/
/****************************************************************************/
/* */
/* WMSYSERR.C */
/* */
/* System error box handling routine */
/* */
/****************************************************************************/
#include "user.h"
#ifndef WOW
VOID FAR PASCAL GetbackFocusFromWinOldAp(void);
/* Private export from GDI for user. */
HFONT FAR PASCAL GetCurLogFont(HDC);
/* This array contins the state information for the three possible buttons in
* a SysErrorBox.
*/
SEBBTN rgbtn[3];
/* The following arrays are used to map SEB_values to their respective
* accelerator keys and text strings.
*/
#define BTNTYPECOUNT 7
static int rgStyles[BTNTYPECOUNT] =
{ SEB_OK, SEB_CANCEL, SEB_YES, SEB_NO, SEB_RETRY,
SEB_ABORT, SEB_IGNORE };
/* The following array is properly initialised by reading STR_ACCELERATORS
* string at LoadWindows time, which contains the accelerator keys
* corresponding to each button in the message box; Localizers must modify
* this string also. Because, this array will be filled by loading a
* string we must have one more space for the null terminator.
*/
char rgAccel[BTNTYPECOUNT+1];
extern WORD wDefButton;
int FAR PASCAL SoftModalMessageBox(HWND, LPSTR, LPSTR, WORD);
/*--------------------------------------------------------------------------*/
/* */
/* BltColor() - */
/* */
/* Modification done by SANKAR on 08-03-89: */
/* The parameter hbm was used as a boolean only to determine whether to */
/* use hdcBits or hdcGrey; Now hbm is replaced with hdcSrce, the source*/
/* device context because, now hdcBits contains color bitmaps and */
/* hdcMonoBits contains monochrome bitmaps; If hdcSrce is NULL, then */
/* hdcGrey will be used, else whatever is passed thro hdcSrce will be */
/* used as the source device context; */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL BltColor(hdc, hbr, hdcSrce, xO, yO, cx, cy, xO1, yO1, fInvert)
register HDC hdc;
register HBRUSH hbr;
HDC hdcSrce;
int xO, yO;
int cx, cy;
int xO1, yO1;
BOOL fInvert;
{
HBRUSH hbrSave;
DWORD textColorSave;
DWORD bkColorSave;
#ifdef DEBUG
if (!hdcGray && !hdcSrce) /* Only test hdcGray if it will be used */
FatalExit(RIP_BADDCGRAY);
#endif
if (hbr == (HBRUSH)NULL)
hbr = sysClrObjects.hbrWindowText;
/*
* Set the Text and Background colors so that bltColor handles the
* background of buttons (and other bitmaps) properly.
* Save the HDC's old Text and Background colors. This causes problems with
* Omega (and probably other apps) when calling GrayString which uses this
* routine...
*/
textColorSave = SetTextColor(hdc, 0x00000000L);
bkColorSave = SetBkColor(hdc, 0x00FFFFFFL);
hbrSave = SelectObject(hdc, hbr);
BitBlt(hdc, xO, yO, cx, cy, hdcSrce ? hdcSrce : hdcGray, xO1, yO1,
(fInvert ? 0x00B8074AL : 0x00E20746L));
SelectObject(hdc, hbrSave);
/* Restore saved colors */
SetTextColor(hdc, textColorSave);
SetBkColor(hdc, bkColorSave);
}
#endif // WOW
/*--------------------------------------------------------------------------*/
/* */
/* DrawFrame() - */
/* */
/*--------------------------------------------------------------------------*/
#define DF_SHIFTMASK (DF_SHIFT0 | DF_SHIFT1 | DF_SHIFT2 | DF_SHIFT3)
#define DF_ROPMASK (DF_PATCOPY | DF_PATINVERT)
#define DF_HBRMASK ~(DF_SHIFTMASK | DF_ROPMASK)
/* Command bits:
* 0000 0011 - (0-3): Shift count for cxBorder and cyBorder
* 0000 0100 - 0: PATCOPY, 1: PATINVERT
* 1111 1000 - (0-x): Brushes as they correspond to the COLOR_*
* indexes, with hbrGray thrown on last.
*/
void USERENTRY DrawFrame(hdc, lprc, clFrame, cmd)
HDC hdc;
LPRECT lprc;
int clFrame;
int cmd;
{
register int x;
register int y;
int cx;
int cy;
int cxWidth;
int cyWidth;
int ibr;
HBRUSH hbrSave;
LONG rop;
#ifdef WOW
DWORD rgbTemp;
static DWORD rgbPrev;
static HBRUSH hbrPrev;
#endif
x = lprc->left;
y = lprc->top;
cxWidth = GetSystemMetrics(SM_CXBORDER) * clFrame;
cyWidth = GetSystemMetrics(SM_CYBORDER) * clFrame;
if (cmd == DF_ACTIVEBORDER || cmd == DF_INACTIVEBORDER)
{
/* We are drawing the inside colored part of a sizing border. We
* subtract 1 from the width and height because we come back and draw
* another frame around the inside. This avoids a lot of flicker when
* redrawing a frame that already exists.
*/
cxWidth--;
cyWidth--;
}
cx = lprc->right - x - cxWidth;
cy = lprc->bottom - y - cyWidth;
rop = ((cmd & DF_ROPMASK) ? PATINVERT : PATCOPY);
ibr = (cmd & DF_HBRMASK) >> 3;
#ifndef WOW
if (ibr == (DF_GRAY >> 3))
{
hbrSave = hbrGray;
}
else
{
hbrSave = ((HBRUSH *)&sysClrObjects)[ibr];
}
#else
rgbTemp = GetSysColor(ibr);
if (!(hbrSave = hbrPrev) || rgbTemp != rgbPrev) {
/* Save time and space with black and white objects. */
if (rgbTemp == 0L)
hbrSave = GetStockObject(BLACK_BRUSH);
else if (rgbTemp == 0xFFFFFFL)
hbrSave = GetStockObject(WHITE_BRUSH);
else
hbrSave = CreateSolidBrush(rgbTemp);
if (hbrPrev)
DeleteObject(hbrPrev);
hbrPrev = hbrSave;
rgbPrev = rgbTemp;
}
#endif
// We need to unrealize the object in order to ensure it gets realigned.
//
UnrealizeObject(hbrSave);
hbrSave = SelectObject(hdc, hbrSave);
/* Time to call the new driver supported fast draw frame stuff. */
if (lprc->top >= lprc->bottom ||
!FastWindowFrame(hdc, lprc, cxWidth, cyWidth, rop))
{
/* The driver can't do it so we have to. */
PatBlt(hdc, x, y, cxWidth, cy, rop); /* Left */
PatBlt(hdc, x + cxWidth, y, cx, cyWidth, rop); /* Top */
PatBlt(hdc, x, y + cy, cx, cyWidth, rop); /* Bottom */
PatBlt(hdc, x + cx, y + cyWidth, cxWidth, cy, rop); /* Right */
}
if (hbrSave)
SelectObject(hdc, hbrSave);
}
#ifndef WOW
/*--------------------------------------------------------------------------*/
/* DrawPushButton() - */
/* */
/* lprc : The rectangle of the button */
/* style : Style of the push button */
/* fInvert : FALSE if pushbutton is in NORMAL state */
/* TRUE if it is to be drawn in the "down" or inverse state */
/* hbrBtn : The brush with which the background is to be wiped out. */
/* hwnd : NULL if no text is to be drawn in the button; */
/* Contains window handle, if text and focus is to be drawn; */
/* */
/*--------------------------------------------------------------------------*/
void FAR PASCAL DrawPushButton(hdc, lprc, style, fInvert, hbrBtn, hwnd)
register HDC hdc;
RECT FAR *lprc;
WORD style;
BOOL fInvert;
HBRUSH hbrBtn;
HWND hwnd;
{
RECT rcInside;
HBRUSH hbrSave;
HBRUSH hbrShade = 0;
HBRUSH hbrFace = 0;
int iBorderWidth;
int i;
int dxShadow;
int cxShadow;
int cyShadow;
if (style == LOWORD(BS_DEFPUSHBUTTON))
iBorderWidth = 2;
else
iBorderWidth = 1;
hbrSave = SelectObject(hdc, hbrBtn);
CopyRect((LPRECT)&rcInside, lprc);
InflateRect((LPRECT)&rcInside, -iBorderWidth*cxBorder,
-iBorderWidth*cyBorder);
/* Draw a frame */
DrawFrame(hdc, lprc, iBorderWidth, (COLOR_WINDOWFRAME << 3));
/* Notch the corners (except don't do this for scroll bar thumb (-1) or
for combo box buttons (-2)) */
if (style != -1 && style != -2)
{
/* Cut four notches at the four corners */
/* Top left corner */
PatBlt(hdc, lprc->left, lprc->top, cxBorder, cyBorder, PATCOPY);
/* Top right corner */
PatBlt(hdc, lprc->right - cxBorder, lprc->top, cxBorder, cyBorder,
PATCOPY);
/* bottom left corner */
PatBlt(hdc, lprc->left, lprc->bottom - cyBorder, cxBorder, cyBorder,
PATCOPY);
/* bottom right corner */
PatBlt(hdc, lprc->right - cxBorder, lprc->bottom - cyBorder, cxBorder,
cyBorder, PATCOPY);
}
/* Draw the shades */
if (sysColors.clrBtnShadow != 0x00ffffff)
{
hbrShade = sysClrObjects.hbrBtnShadow;
if (fInvert)
{
/* Use shadow color */
SelectObject(hdc, hbrShade);
dxShadow = 1;
}
else
{
/* Use white */
SelectObject(hdc, GetStockObject(WHITE_BRUSH));
dxShadow = (style == -1 ? 1 : 2);
}
cxShadow = cxBorder * dxShadow;
cyShadow = cyBorder * dxShadow;
/* Draw the shadow/highlight in the left and top edges */
PatBlt(hdc, rcInside.left, rcInside.top, cxShadow,
(rcInside.bottom - rcInside.top), PATCOPY);
PatBlt(hdc, rcInside.left, rcInside.top,
(rcInside.right - rcInside.left), cyShadow, PATCOPY);
if (!fInvert)
{
/* Use shadow color */
SelectObject(hdc, hbrShade);
/* Draw the shade in the bottom and right edges */
rcInside.bottom -= cyBorder;
rcInside.right -= cxBorder;
for(i = 0; i <= dxShadow; i++)
{
PatBlt(hdc, rcInside.left, rcInside.bottom,
rcInside.right - rcInside.left + cxBorder, cyBorder,
PATCOPY);
PatBlt(hdc, rcInside.right, rcInside.top, cxBorder,
rcInside.bottom - rcInside.top, PATCOPY);
if (i == 0)
InflateRect((LPRECT)&rcInside, -cxBorder, -cyBorder);
}
}
}
else
{
/* Don't move text down if no shadows */
fInvert = FALSE;
/* The following are added as a fix for Bug #2784; Without these
* two lines, cxShadow and cyShadow will be un-initialised when
* running under a CGA resulting in this bug;
* Bug #2784 -- 07-24-89 -- SANKAR
*/
cxShadow = cxBorder;
cyShadow = cyBorder;
}
/* Draw the button face color pad. If no clrBtnFace, use white to clear
it. */
/* if fInvert we don't subtract 1 otherwise we do because up above we
do an inflate rect if not inverting for the shadow along the bottom*/
rcInside.left += cxShadow - (fInvert ? 0 : cxBorder);
rcInside.top += cyShadow - (fInvert ? 0 : cyBorder);
if (sysColors.clrBtnFace != 0x00ffffff)
hbrFace = sysClrObjects.hbrBtnFace;
else
hbrFace = GetStockObject(WHITE_BRUSH);
SelectObject(hdc, hbrFace);
PatBlt(hdc, rcInside.left, rcInside.top, rcInside.right - rcInside.left,
rcInside.bottom - rcInside.top, PATCOPY);
if (hbrSave)
SelectObject(hdc, hbrSave);
}
/*
*---------------------------------------------------------------------------
* SEB_InitBtnInfo() -
* This function fills in the button info structure (SEBBTN) for the
* specified button.
*---------------------------------------------------------------------------
*/
void NEAR PASCAL SEB_InitBtnInfo(
HDC hdc, /* DC to be used in dispplaying the button */
unsigned int style, /* one of the SEB_* styles */
int xBtn,
int yBtn, /* center the button on this (x, y) pixel */
int cxBtn,
int cyBtn, /* make the button this size */
int index) /* index of the rgbtn entry to initialize */
{
long Extent;
int i;
int temp1, temp2;
#ifdef DEBUG
BOOL fFound = FALSE;
#endif
rgbtn[index].finvert = FALSE;
if ((rgbtn[index].style = style) == NULL)
return;
/* Calc the button text and accelerator */
for (i = 0; i < MAX_MB_STRINGS; i++)
{
if (rgStyles[i] == (style & ~SEB_DEFBUTTON))
{
rgbtn[index].psztext = AllMBbtnStrings[i];
rgbtn[index].chaccel = rgAccel[i];
#ifdef DEBUG
fFound = TRUE;
#endif
break;
}
}
#ifdef DEBUG
if (!fFound)
{
/* RIP city */
return;
}
#endif
/* Calc the button rectangle */
SetRect((LPRECT)&rgbtn[index].rcbtn,
(temp1 = xBtn - (cxBtn >> 1)),
(temp2 = yBtn - (cyBtn >> 1)),
temp1 + cxBtn,
temp2 + cyBtn);
/* Calc the text position */
Extent = PSMGetTextExtent(hdc,
(LPSTR)rgbtn[index].psztext,
lstrlen((LPSTR)rgbtn[index].psztext));
rgbtn[index].pttext.x = xBtn - (LOWORD(Extent) >> 1);
rgbtn[index].pttext.y = yBtn - (HIWORD(Extent) >> 1);
/* rgbtn[index].pttext.y = yBtn - (cySysFontAscent >> 1);*/
}
/*
*---------------------------------------------------------------------------
* SEB_DrawFocusRect() -
* This function draws the Focus frame.
*---------------------------------------------------------------------------
*/
void NEAR PASCAL SEB_DrawFocusRect(HDC hdc,
LPRECT lprcBtn,
LPSTR lpszBtnStr,
int iLen,
BOOL fPressed)
{
DWORD dwExtents;
RECT rc;
dwExtents = PSMGetTextExtent(hdc, (LPSTR)lpszBtnStr, iLen);
rc.left = lprcBtn->left + ((lprcBtn->right - lprcBtn->left - LOWORD(dwExtents)) >> 1) - (cxBorder << 1);
rc.right = rc.left + (cxBorder << 2) + LOWORD(dwExtents);
rc.top = lprcBtn->top + ((lprcBtn->bottom - lprcBtn->top - HIWORD(dwExtents)) >> 1) - cyBorder;
rc.bottom = rc.top + (cyBorder << 1) + HIWORD(dwExtents) + cyBorder;
if(fPressed)
OffsetRect(&rc, 1, 1);
/* NOTE: I know you will be tempted to use DrawFocusRect(); But this
* uses PatBlt() with PATINVERT! This causes instant death in int24
* SysErrBoxes! So, I am calling FrameRect() which calls PatBlt() with
* PATCOPY. This works fine in int24 cases also!
* --SANKAR--
*/
FrameRect(hdc, (LPRECT)&rc, hbrGray);
}
/*
*---------------------------------------------------------------------------
* SEB_DrawButton() -
* This function draws the button specified. The pbtninfo parameter is
* a pointer to a structure of type SEBBTN.
*---------------------------------------------------------------------------
*/
void NEAR PASCAL SEB_DrawButton(HDC hdc, /* HDC to use for drawing */
int i) /* index of the rgbtn to draw */
{
DWORD colorSave;
int iLen;
if (rgbtn[i].style == NULL)
return;
/* DrawPushButton() wipes out the background also */
DrawPushButton(hdc,
(LPRECT)&rgbtn[i].rcbtn,
(WORD)((rgbtn[i].style & SEB_DEFBUTTON) ? BS_DEFPUSHBUTTON:
BS_PUSHBUTTON),
rgbtn[i].finvert,
GetStockObject(WHITE_BRUSH),
(HWND)NULL);
colorSave = SetTextColor(hdc, sysColors.clrBtnText);
SetBkMode(hdc, TRANSPARENT);
/* Preserve the button color for vga systems */
PSMTextOut(hdc,
rgbtn[i].pttext.x + (rgbtn[i].finvert ? 1 : 0),
rgbtn[i].pttext.y + (rgbtn[i].finvert ? 1 : 0),
(LPSTR)rgbtn[i].psztext,
(iLen = lstrlen((LPSTR)rgbtn[i].psztext)));
/* Only the default button can have the focus frame */
if(rgbtn[i].style & SEB_DEFBUTTON)
SEB_DrawFocusRect(hdc,
(LPRECT)&rgbtn[i].rcbtn,
(LPSTR)rgbtn[i].psztext,
iLen,
rgbtn[i].finvert);
SetTextColor(hdc, colorSave);
SetBkMode(hdc, OPAQUE);
}
/*
*---------------------------------------------------------------------------
* SEB_BtnHit(pt)
* Return the index of the rgbtn that the point is in. If not in any button
* then return -1.
*---------------------------------------------------------------------------
*/
int NEAR SEB_BtnHit(int x, int y)
{
POINT pt;
register int i;
pt.x = x;
pt.y = y;
for (i = 0; i <= 2; i++)
{
if (rgbtn[i].style != NULL)
if (PtInRect((LPRECT)&rgbtn[i].rcbtn, pt))
return(i);
}
return(-1);
}
/*
*---------------------------------------------------------------------------
* SysErrorBox()
*
* This function is used to display a system error type message box. No
* system resources (other than the stack) is used to display this box.
* Also, it is guarenteed that all code needed to complete this function
* will be memory at all times. This will allow the calling of this
* funtion by the INT24 handler.
*
* Paramerers:
* lpszText Text string of the message itself. This message is
* assumed to be only one line in length and short enough
* to fit in the box. The box will size itself horizontally
* to center the string, but will not be sized beyond the
* size of the physical screen.
*
* lpszCaption Text of the caption of the box. This caption will be
* displayed at the top of the box, centered. The same
* restrictions apply.
*
* Btn1
* Btn2
* Btn3 One of the following:
* NULL No button in this position.
* SEB_OK Button with "OK".
* SEB_CANCEL Button with "Cancel"
* SEB_YES Button with "Yes"
* SEB_NO Button with "No"
* SEB_RETRY Button with "Retry"
* SEB_ABORT Button with "Abort"
* SEB_IGNORE Button with "Ignore"
*
* Also, one of the parameters may have the value
* SEB_DEFBUTTON
* OR'ed with any of the SEB_* valued above. This draws
* this button as the default button and sets the initial
* "focus" to this button. Only one button should have
* this style. If no buttons have this style, the first
* button whose value is not NULL will be the default button.
*
* Return Value:
* This funtion returns one of the following values:
*
* SEB_BTN1 Button 1 was selected
* SEB_BTN2 Button 2 was selected
* SEB_BTN3 Button 3 was selected
*
*---------------------------------------------------------------------------
*/
/* Maximum number of lines allowed in a system error box.
*/
#define MAXSYSERRLINES 3
/* Struct allocated on stack for max lines.
*/
typedef struct tagSysErr
{
int iStart;
int cch;
int cxText;
} SYSERRSTRUCT;
int USERENTRY SysErrorBox(lpszText, lpszCaption, btn1, btn2, btn3)
LPSTR lpszText;
LPSTR lpszCaption;
unsigned int btn1, btn2, btn3;
{
register int cx, cy;
SYSERRSTRUCT sysErr[MAXSYSERRLINES];
int temp;
int cchCaption;
int cxText, cxCaption, cxButtons;
int cxCenter, cxQuarter;
int cxBtn, cyBtn;
int xBtn, yBtn;
int iTextLines;
HDC hdc;
RECT rcBox, rcTemp;
HRGN hrgn;
int far *pbtn;
int i;
MSG msg;
BOOL fBtnDown;
BOOL fKeyBtnDown = FALSE;
int BtnReturn;
int btnhit;
int defbtn;
HWND hwndFocusSave;
BOOL fMessageBoxGlobalOld = fMessageBox;
BOOL fOldHWInput;
HWND hwndSysModalBoxOld;
LPSTR lptemp;
RECT rcInvalidDesktop; /* Keep union of invalid desktop rects */
/* We have to determine if we are running Win386 in PMODE
* at the time of bringing up this SysErrBox. In this case we
* have to call Win386 to Set the screen focus to us so that
* the user can see the SYSMODAL error message that we display;
* Fix for Bug #5272 --SANKAR-- 10-12-89
*/
if ((WinFlags & WF_WIN386) && (WinFlags & WF_PMODE))
GetbackFocusFromWinOldAp();
/* Set this global so that we don't over write our globals when kernel calls
* this routine directly. We need to save and restore the state of the
* fMessageBox flag. If SysErrorBox is called via HardSysModal, then this
* flag is set and we do proper processing in the message loop. However, if
* Kernel calls syserrorbox directly, then this flag wasn't being set and we
* could break...
*/
fMessageBox = TRUE;
/* Save off the guy who was the old sys modal dialog box in case the int24
* box is put up when a sys modal box is up.
*/
hwndSysModalBoxOld = hwndSysModal;
/* Clear this global so that if the mouse is down on an NC area we don't
* drop into the move/size code when we return. If we do, it thinks the
* mouse is down when it really isn't
*/
fInt24 = TRUE;
/* Initialise the Global structure */
LFillStruct((LPSTR)rgbtn, 3*sizeof(SEBBTN), '\0');
/* Change the hq for the desktop to be the current task hq */
if (NEEDSPAINT(hwndDesktop))
DecPaintCount(hwndDesktop);
hwndDesktop->hq = HqCurrent();
if (NEEDSPAINT(hwndDesktop))
IncPaintCount(hwndDesktop);
hdc = GetScreenDC();
/*
* Calculate the extents of the error box. Then set the rectangle that
* we will use for drawing.
*
* The x extent of the box is the maximin of the the folowing items:
* - The text for the box (padded with 3 chars on each end).
* - The caption for the box (also padded).
* - 3 maximum sized buttons (szCANCEL).
*
* The y extent is 10 times the height of the system font.
*
*/
cy = cySysFontChar * 10;
/* How many lines in the box text and their extents etc?
*/
iTextLines = 0;
sysErr[0].iStart = 0;
sysErr[0].cch = 0;
sysErr[0].cxText = 0;
lptemp=lpszText;
cxText = 0; /* Max text length
*/
while (lptemp)
{
if (*lptemp == '\n' || *lptemp==0)
{
sysErr[iTextLines].cxText = LOWORD(GetTextExtent(hdc,
(LPSTR)(lpszText+sysErr[iTextLines].iStart),
sysErr[iTextLines].cch));
/* Keep track of length of longest line
*/
cxText = max(sysErr[iTextLines].cxText,cxText);
if (*lptemp && *(lptemp+1)!=0 && iTextLines < MAXSYSERRLINES)
{
/* Another line exists
*/
iTextLines++;
sysErr[iTextLines].iStart = sysErr[iTextLines-1].iStart +
sysErr[iTextLines-1].cch+1;
sysErr[iTextLines].cch = 0;
sysErr[iTextLines].cxText = 0;
lptemp++;
}
else
break;
}
else
{
sysErr[iTextLines].cch++;
lptemp++;
}
}
cx = cxText + (6 * cxSysFontChar);
/* Get the extent of the box caption
*/
cxCaption = LOWORD(GetTextExtent(hdc,
(LPSTR)lpszCaption,
(cchCaption = lstrlen(lpszCaption))));
temp = cxCaption + (6 * cxSysFontChar);
if (cx < temp)
cx = temp;
/* Get the extent of 3 maximum sized buttons */
cxBtn = wMaxBtnSize + (cySysFontChar << 1);
cxButtons = (cxBtn + (cySysFontChar << 2)) * 3;
if (cx < cxButtons)
cx = cxButtons;
/* Center the box on the screen. Bound to left edge if too big. */
rcBox.top = (cyScreen >> 1) - (cy >> 1);
rcBox.bottom = rcBox.top + cy;
rcBox.left = (cxScreen >> 1) - (cx >> 1);
if (rcBox.left < 0)
rcBox.left = 0;
rcBox.right = rcBox.left + cx;
cxCenter = (rcBox.left + rcBox.right) >> 1;
PatBlt(hdc, rcBox.left, rcBox.top, cx, cy, WHITENESS);
rcTemp = rcBox;
DrawFrame(hdc, &rcTemp, 1, DF_WINDOWFRAME);
InflateRect(&rcTemp, -(cxBorder * (CLDLGFRAMEWHITE + 1)),
-(cyBorder * (CLDLGFRAMEWHITE + 1)));
DrawFrame(hdc, &rcTemp, CLDLGFRAME, DF_ACTIVECAPTION);
TextOut(hdc,
cxCenter - (cxCaption >> 1),
rcBox.top + cySysFontChar,
(LPSTR)lpszCaption,
cchCaption);
i=0;
/* First line of text starts at what y offset ?
*/
if (iTextLines == 0)
temp = (cySysFontChar << 2);
else
temp = (cySysFontChar << 1)+(cySysFontChar * (MAXSYSERRLINES-iTextLines));
while (i<=iTextLines)
{
TextOut(hdc,
/* cxCenter - (cxText >> 1),*/
cxCenter - (sysErr[i].cxText >> 1),
rcBox.top + temp+(i*cySysFontChar),
(LPSTR)lpszText+sysErr[i].iStart,
sysErr[i].cch);
i++;
}
pbtn = &btn1;
xBtn = (cxQuarter = cx >> 2) + rcBox.left;
yBtn = rcBox.bottom - (cySysFontChar << 1);
cyBtn = cySysFontChar << 1;
for (i=0; i <= 2; i++, pbtn--)
{
SEB_InitBtnInfo(hdc, *pbtn, xBtn, yBtn, cxBtn, cyBtn, i);
SEB_DrawButton(hdc, i);
xBtn += cxQuarter;
}
Capture(hwndDesktop, CLIENT_CAPTURE);
SetSysModalWindow(hwndDesktop);
/*hCursOld =*/ SetCursor(hCursNormal);
/* Why are we doing this???? This is causing us to hit the disk to load some
* cursor resource during interrupt time... davidds
*/
/* CallOEMCursor();*/
hwndFocusSave = hwndFocus;
hwndFocus = hwndDesktop;
fBtnDown = FALSE;
BtnReturn = 0;
btnhit = -1; /* -1 if not on a button, else index into rgbtn[] */
defbtn = -1;
for (i = 0; i <= 2; i++)
if (rgbtn[i].style & SEB_DEFBUTTON)
{
defbtn = i;
break;
}
/* Prevent other tasks from running because this is SysModal */
if (!fEndSession)
LockMyTask(TRUE);
/* Insure that hardware input is enabled */
fOldHWInput = EnableHardwareInput(TRUE);
/* Initially, only invalidate desktop where the sys error box was.
*/
rcInvalidDesktop = rcBox;
while (BtnReturn == 0)
{
if (!PeekMessage((LPMSG)&msg, hwndDesktop, 0, 0, PM_REMOVE | PM_NOYIELD))
continue;
#ifdef NEVER
********* TranslateMessage() calls ToAscii() which refers to some tables
in a LoadOnCall segment; So, this is commented out here; We can not
look for WM_CHAR messages, but we still get WM_KEYDOWN messages!
--Sankar, April 17, 1989--
TranslateMessage((LPMSG)&msg);
*********
#endif
if (msg.hwnd == hwndDesktop)
{
switch (msg.message)
{
case WM_LBUTTONDOWN:
fBtnDown = TRUE;
if ((btnhit = SEB_BtnHit(LOWORD(msg.lParam),
HIWORD(msg.lParam))) != -1)
{
/* Move the default button to the next button.
*/
if ((defbtn != -1) && (btnhit != defbtn))
{
/* Draw the current def button as not default.
*/
rgbtn[defbtn].style &= ~SEB_DEFBUTTON;
SEB_DrawButton(hdc, defbtn);
/* Draw the new button as default.
*/
defbtn = btnhit;
rgbtn[btnhit].style |= SEB_DEFBUTTON;
}
rgbtn[btnhit].finvert = TRUE;
SEB_DrawButton(hdc, btnhit);
}
break;
case WM_LBUTTONUP:
fBtnDown = FALSE;
/* Was the mouse hitting on a button? If so, terminate the
* loop and return the button index.
*/
if (btnhit != -1)
BtnReturn = btnhit + 1;
break;
case WM_MOUSEMOVE:
/* Only look at mouse moves if the button is down.
*/
if (fBtnDown)
{
/* Hitting on a button?
*/
if ((i = SEB_BtnHit(LOWORD(msg.lParam), HIWORD(msg.lParam))) != -1)
{
/* Mouse moved and we are on a button. First test
* to see if we are on the same button as before.
*/
if ((i != btnhit) && (btnhit != -1))
{
rgbtn[btnhit].finvert = FALSE;
SEB_DrawButton(hdc, btnhit);
}
/* Verify that the new button is
* inverted and that btnhit is current.
*/
btnhit = i;
if (rgbtn[btnhit].finvert == FALSE)
{
rgbtn[btnhit].finvert = TRUE;
SEB_DrawButton(hdc, btnhit);
}
} else {
/* button down, but not hitting on a button. Check
* for drag off a button.
*/
if (btnhit != -1)
{
rgbtn[btnhit].finvert = FALSE;
SEB_DrawButton(hdc, btnhit);
btnhit = -1;
}
}
}
break;
case WM_KEYUP:
if(fKeyBtnDown)
{
switch(msg.wParam)
{
case VERYBIGINTEGER:
/* Because this code gets moved into himem, we can't use jump
* tables; This VERYBIGINTEGER prevents C6.0 from using a jump
* table in the translation of Switch Statements;
*/
break;
case VK_SPACE:
case VK_RETURN:
/* Select the current default button and return.
*/
if (defbtn != -1)
BtnReturn = defbtn + 1;
break;
}
}
break;
case WM_PAINT:
GetUpdateRect(msg.hwnd, &rcTemp, FALSE);
ValidateRect(msg.hwnd, NULL);
UnionRect(&rcInvalidDesktop, &rcInvalidDesktop, &rcTemp);
break;
case WM_SYSKEYDOWN:
/* Look for accelerator keys
*/
for (i = 0; i <= 2; i++)
{
/* Convert to lower case and test for a match */
if (((BYTE)msg.wParam | 0x20) == rgbtn[i].chaccel)
{
BtnReturn = i + 1;
break;
}
}
break;
case WM_KEYDOWN:
switch (msg.wParam)
{
case VK_SPACE:
case VK_RETURN:
/* Just keep the button pressed */
/* If already pressed, ignore the rest sothat we
* won't flicker horribly
*/
if((defbtn != -1) && (!fKeyBtnDown))
{
fKeyBtnDown = TRUE;
rgbtn[defbtn].finvert = TRUE;
SEB_DrawButton(hdc, defbtn);
}
break;
case VK_TAB:
/* Move the default button to the next button.
*/
if (defbtn != -1)
{
/* Draw the current def button as not default.
*/
rgbtn[defbtn].style &= ~SEB_DEFBUTTON;
SEB_DrawButton(hdc, defbtn);
/* Calc the next def button. Inc defbtn, but
* wrap from btn 3 to btn 1. Also, don't stop
* on a button that isn't defined.
*/
if (defbtn == 2)
defbtn = 0;
else
++defbtn;
while (rgbtn[defbtn].style == NULL)
{
if (++defbtn > 2)
defbtn = 0;
}
/* Draw the new default button as default.
*/
rgbtn[defbtn].style |= SEB_DEFBUTTON;
SEB_DrawButton(hdc, defbtn);
}
break;
case VK_ESCAPE:
/* See if there is a button with SEB_CANCEL. If there
* is, return it's id.
*/
for (i = 0; i <= 2; i++)
{
if ((rgbtn[i].style & ~SEB_DEFBUTTON)
== SEB_CANCEL)
{
BtnReturn = ++i;
break;
}
}
break;
}
break;
}
}
}
fMessageBox=fMessageBoxGlobalOld;
/* Insure that hardware input is put back the way it was */
EnableHardwareInput(fOldHWInput);
/* Allow other tasks to run. */
LockMyTask(FALSE);
/* Set sys modal box back to the guy who was up */
SetSysModalWindow(hwndSysModalBoxOld);
Capture(NULL, NO_CAP_CLIENT);
#if 0
The old cursor may have been paged out. We can't do this.
SetCursor(hCursOld);
#endif
#if causetrouble
if (iLevelCursor < 0)
OEMSetCursor((LPSTR)NULL);
#endif
hwndFocus = hwndFocusSave;
/* Set this flag indicating that another window was activate so that if we
* were in menu mode when the sys error box came up, we know we should get
* out because the actual mouse button/keyboard state may be different than
* what the menu state thinks it is.
*/
fActivatedWindow = TRUE;
InternalReleaseDC(hdc);
/* Invalidate the invalid portions of the desktop.
*/
InvalidateRect(hwndDesktop, &rcInvalidDesktop, FALSE);
hrgn = CreateRectRgn(rcInvalidDesktop.left, rcInvalidDesktop.top,
rcInvalidDesktop.right,rcInvalidDesktop.bottom);
InternalInvalidate(hwndDesktop, (hrgn ? hrgn : (HRGN) 1),
RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
if (hrgn)
DeleteObject(hrgn);
// RedrawScreen();
return(BtnReturn);
}
int NEAR PASCAL HardSysModalMessageBox(LPSTR lpszText,
LPSTR lpszCaption,
WORD wBtnCnt,
WORD wType)
{
WORD wBegBtn;
int iCurIndex;
int iCurButton;
WORD iButtonNo;
int iRetVal;
WORD wTemp;
struct
{
unsigned int InVal;
char RetVal;
}Param[3];
/* If we're trying to bring up a hard sys modal message box
* while another one is up, wait till the first one is through.
* This protects our static save globals. I'm not actually
* sure this can ever happen (at least under DOS 3).
*/
if (fMessageBox)
Yield();
fMessageBox = TRUE;
wBegBtn = mpTypeIich[wType]; /* Index of Begining button */
Param[0].InVal = Param[1].InVal = Param[2].InVal = 0;
iCurIndex = 0;
for(iButtonNo = 0; iButtonNo < wBtnCnt; iButtonNo++)
{
iCurButton = iCurIndex;
switch(wBtnCnt)
{
case 1: /* One button; Put it in Param[1] */
Param[1].InVal = SEBbuttons[wBegBtn];
Param[1].RetVal = rgReturn[wBegBtn];
iCurButton = 1;
break;
case 2: /* 2 Buttons; Put them in Param[0] and Param[2] */
Param[iCurIndex].InVal = SEBbuttons[wTemp = wBegBtn + iButtonNo];
Param[iCurIndex].RetVal = rgReturn[wTemp];
iCurIndex += 2;
break;
case 3: /* 3 Buttons; Put them in Param[0], [1] and [2] */
Param[iCurIndex].InVal = SEBbuttons[wTemp = wBegBtn + iButtonNo];
Param[iCurIndex].RetVal = rgReturn[wTemp];
iCurIndex++;
break;
}
/* Check for the default button */
if(wDefButton == iButtonNo)
Param[iCurButton].InVal |= SEB_DEFBUTTON;
}
iRetVal = SysErrorBox(lpszText, lpszCaption, Param[0].InVal,
Param[1].InVal, Param[2].InVal);
fMessageBox = FALSE;
return((int)Param[iRetVal - SEB_BTN1].RetVal);
}
/*--------------------------------------------------------------------------*/
/* */
/* MessageBox() - */
/* */
/*--------------------------------------------------------------------------*/
int USERENTRY MessageBox(hwndOwner, lpszText, lpszCaption, wStyle)
HWND hwndOwner;
LPSTR lpszText;
LPSTR lpszCaption;
WORD wStyle;
{
WORD wBtnCnt;
WORD wType;
WORD wIcon;
#ifdef DEBUG
if (!GetTaskQueue(GetCurrentTask()))
{
/* There is no task queue. Not put up message boxes.
*/
UserFatalExitSz(RIP_MESSAGEBOXWITHNOQUEUE,
"\n\rMessageBox failed - no message queue has been initialized yet. MessageBox not allowed.",
0);
}
#endif
/* If lpszCaption is NULL, then use "Error!" string as the caption
string */
if(!lpszCaption)
lpszCaption = (LPSTR)szERROR;
wBtnCnt = mpTypeCcmd[(wType = wStyle & MB_TYPEMASK)];
/* Set the default button value */
wDefButton = (wStyle & MB_DEFMASK) / (MB_DEFMASK & (MB_DEFMASK >> 3));
if(wDefButton >= wBtnCnt) /* Check if valid */
wDefButton = 0; /* Set the first button if error */
/* Check if this is a hard sys modal message box */
wIcon = wStyle & MB_ICONMASK;
if(((wStyle & MB_MODEMASK) == MB_SYSTEMMODAL) &&
((wIcon == NULL) || (wIcon == MB_ICONHAND)))
{
/* It is a hard sys modal message box */
return(HardSysModalMessageBox(lpszText, lpszCaption, wBtnCnt, wType));
}
else
return(SoftModalMessageBox(hwndOwner, lpszText, lpszCaption, wStyle));
}
BOOL FAR PASCAL IsSystemFont(hdc)
register HDC hdc;
/* effects: Returns TRUE if font selected into DC is the system font else
returns false. This is called by interrupt time code so it needs to be
in the fixed code segment. */
{
return(GetCurLogFont(hdc) == GetStockObject(SYSTEM_FONT));
}
BOOL FAR PASCAL IsSysFontAndDefaultMode(hdc)
register HDC hdc;
/* effects: Returns TRUE if font selected into DC is the system font AND
the current mapping mode of the DC is MM_TEXT (Default mode); else
returns false. This is called by interrupt time code so it needs to be
in the fixed code segment. */
/* This function is the fix for Bug #8717 --02-01-90-- SANKAR */
{
return(IsSystemFont(hdc) && (GetMapMode(hdc) == MM_TEXT));
}
int USERENTRY WEP(int i)
{
return(1);
}
#endif // WOW