able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/textmode/winnt/dndispjp.c

1406 lines
27 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
dndispjp.c
Abstract:
DOS-based NT setup program video display routines for DOS/V.
Author:
Ted Miller (tedm) 30-March-1992
Revision History:
Originally dndisp.c.
Modified 18-Feb-1995 (tedm) for DOS/V support, based on NT-J team's
adaptation.
--*/
#ifdef JAPAN
#ifdef DOS_V
#include "winnt.h"
#include <string.h>
#define SCREEN_WIDTH 80
#define SCREEN_HEIGHT 25
#define STATUS_HEIGHT 1
#define STATUS_LEFT_MARGIN 2
#define HEADER_HEIGHT 3
#define CHARACTER_MAX 256
#if NEC_98
extern
VOID
RestoreBootcode(VOID);
VOID
Screen_Buffer_Attr(
SHORT x,
SHORT y,
UCHAR attr
);
extern CursorOnFlag; // For Cursor OFF
#endif // NEC_98
//
// Display attributes
//
#if NEC_988
#define ATT_FG_RED (0x40 | 0x01)
#define ATT_FG_GREEN (0x80 | 0x01)
#define ATT_FG_BLUE (0x20 | 0x01)
#define ATT_FG_CYAN (ATT_FG_BLUE | ATT_FG_GREEN)
#define ATT_FG_MAGENTA (ATT_FG_RED | ATT_FG_BLUE)
#define ATT_FG_YELLOW (ATT_FG_RED | ATT_FG_GREEN)
#define ATT_FG_WHITE (ATT_FG_RED | ATT_FG_GREEN | ATT_FG_BLUE)
#define ATT_FG_BLACK (0x00 | 0x01)
#define ATT_REVERSE 0x05
#define ATT_BRINK 0x03
#define ATT_BG_RED 0x00
#define ATT_BG_GREEN 0x00
#define ATT_BG_BLUE 0x00
#define ATT_BG_CYAN 0x00
#define ATT_BG_MAGENTA 0x00
#define ATT_BG_YELLOW 0x00
#define ATT_BG_WHITE 0x00
#define ATT_BG_BLACK 0x00
#define ATT_FG_INTENSE 0x00
#define ATT_BG_INTENSE 0x00
#define DEFAULT_ATTRIBUTE (ATT_FG_CYAN | ATT_REVERSE)
#define STATUS_ATTRIBUTE (ATT_FG_WHITE | ATT_REVERSE)
#define EDIT_ATTRIBUTE (ATT_FG_WHITE | ATT_REVERSE)
#define EXITDLG_ATTRIBUTE (ATT_FG_WHITE | ATT_REVERSE)
#define GAUGE_ATTRIBUTE (ATT_FG_YELLOW | ATT_REVERSE)
#else // NEC_98
#define ATT_FG_BLACK 0
#define ATT_FG_BLUE 1
#define ATT_FG_GREEN 2
#define ATT_FG_CYAN 3
#define ATT_FG_RED 4
#define ATT_FG_MAGENTA 5
#define ATT_FG_YELLOW 6
#define ATT_FG_WHITE 7
#define ATT_BG_BLACK (ATT_FG_BLACK << 4)
#define ATT_BG_BLUE (ATT_FG_BLUE << 4)
#define ATT_BG_GREEN (ATT_FG_GREEN << 4)
#define ATT_BG_CYAN (ATT_FG_CYAN << 4)
#define ATT_BG_RED (ATT_FG_RED << 4)
#define ATT_BG_MAGENTA (ATT_FG_MAGENTA << 4)
#define ATT_BG_YELLOW (ATT_FG_YELLOW << 4)
#define ATT_BG_WHITE (ATT_FG_WHITE << 4)
#define ATT_FG_INTENSE 8
#define ATT_BG_INTENSE (ATT_FG_INTENSE << 4)
#define DEFAULT_ATTRIBUTE (ATT_FG_WHITE | ATT_BG_BLUE)
#define STATUS_ATTRIBUTE (ATT_FG_BLACK | ATT_BG_WHITE)
#define EDIT_ATTRIBUTE (ATT_FG_BLACK | ATT_BG_WHITE)
#define EXITDLG_ATTRIBUTE (ATT_FG_RED | ATT_BG_WHITE)
#if NEC_98
#define GAUGE_ATTRIBUTE (ATT_BG_YELLOW)
#else
#define GAUGE_ATTRIBUTE (ATT_BG_BLUE | ATT_FG_YELLOW | ATT_FG_INTENSE)
#endif // NEC_98
#endif // NEC_98
//
// This value gets initialized in DnInitializeDisplay.
//
#if NEC_98
#define SCREEN_BUFFER ((UCHAR _far *)0xa0000000) // Normal Mode Text Vram
#define SCREEN_BUFFER_CHR1(x,y) *((SCREEN_BUFFER + (2*((x)+(SCREEN_WIDTH*(y)))))+0)
#define SCREEN_BUFFER_CHR2(x,y) *((SCREEN_BUFFER + (2*((x)+(SCREEN_WIDTH*(y)))))+1)
UCHAR SCREEN_BUFFER_ATTRB[80][25];
BOOLEAN CursorIsActuallyOn;
#define IsANK(c) (!((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfe)))
#else // NEC_98
UCHAR _far *ScreenAddress;
#define SCREEN_BUFFER (ScreenAddress)
#define SCREEN_BUFFER_CHR(x,y) *(SCREEN_BUFFER + (2*((x)+(SCREEN_WIDTH*(y)))))
#define SCREEN_BUFFER_ATT(x,y) *(SCREEN_BUFFER + (2*((x)+(SCREEN_WIDTH*(y))))+1)
//
// Macro to update a char location from the Pseudo text RAM to the display.
//
#define UPDATE_SCREEN_BUFFER(x,y,z) DnpUpdateBuffer(&SCREEN_BUFFER_CHR(x,y),z)
BOOLEAN CursorIsActuallyOn;
//
// DBCS support
//
BOOLEAN DbcsTable[CHARACTER_MAX];
#define ISDBCS(chr) DbcsTable[(chr)]
#endif // NEC_98
#if NEC_98
#else // NEC_98
VOID
DnpInitializeDbcsTable(
VOID
);
#endif // NEC_98
//
// Make these near because they are used in _asm blocks
//
UCHAR _near CurrentAttribute;
UCHAR _near ScreenX;
UCHAR _near ScreenY;
BOOLEAN CursorOn;
#if NEC_98
#else // NEC_98
UCHAR _far *
DnpGetVideoAddress(
VOID
);
VOID
DnpUpdateBuffer(
UCHAR _far *VideoAddress,
int CharNum
);
#endif // NEC_98
VOID
DnpBlankScreenArea(
IN UCHAR Attribute,
IN UCHAR Left,
IN UCHAR Right,
IN UCHAR Top,
IN UCHAR Bottom
);
VOID
DnInitializeDisplay(
VOID
)
/*++
Routine Description:
Put the display in a known state (80x25 standard text mode) and
initialize the display package.
Arguments:
None.
Return Value:
None.
--*/
{
#if NEC_98
#else // NEC_98
ScreenAddress = DnpGetVideoAddress();
DnpInitializeDbcsTable();
#endif // NEC_98
CurrentAttribute = DEFAULT_ATTRIBUTE;
CursorOn = FALSE;
//
// Set the display to standard 80x25 mode
//
#if NEC_98
_asm {
mov ax,0a00h // set CRT mode to 80 x 25
int 18h
push ds
push cx
push bx
mov ax,0a800h
mov ds,ax
mov cx,3fffh
blp:
mov bx,cx
mov ds:[bx],0
loop blp
mov ax,0b000h
mov ds,ax
mov cx,3fffh
rlp:
mov bx,cx
mov ds:[bx],0
loop rlp
mov ax,0b800h
mov ds,ax
mov cx,3fffh
glp:
mov bx,cx
mov ds:[bx],0
loop glp
mov ax,0e000h
mov ds,ax
mov cx,3fffh
ilp:
mov bx,cx
mov ds:[bx],0
loop ilp
mov ah,042h
mov ch,0c0h
int 18h
mov ax,8
out 68h,al
mov ax,1
out 6ah,al
mov ax,41h
out 6ah,al
mov ax,0dh
out 0a2h,al
pop bx
pop cx
pop ds
}
#else // NEC_98
_asm {
mov ax,3 // set video mode to 3
int 10h
}
#endif // NEC_98
//
// Clear the entire screen
//
DnpBlankScreenArea(CurrentAttribute,0,SCREEN_WIDTH-1,0,SCREEN_HEIGHT-1);
DnPositionCursor(0,0);
//
// Shut the cursor off.
//
#if NEC_98
_asm {
mov ah,12h // function -- cursor off
int 18h
}
#else // NEC_98
_asm {
mov ah,2 // function -- position cursor
mov bh,0 // display page
mov dh,SCREEN_HEIGHT
mov dl,0
int 10h
}
#endif // NEC_98
CursorIsActuallyOn = FALSE;
}
VOID
DnClearClientArea(
VOID
)
/*++
Routine Description:
Clear the client area of the screen, ie, the area between the header
and status line.
Arguments:
None.
Return Value:
None.
--*/
{
DnpBlankScreenArea( CurrentAttribute,
0,
SCREEN_WIDTH-1,
HEADER_HEIGHT,
SCREEN_HEIGHT - STATUS_HEIGHT - 1
);
DnPositionCursor(0,HEADER_HEIGHT);
}
VOID
DnSetGaugeAttribute(
IN BOOLEAN Set
)
/*++
Routine Description:
Prepare for drawing the thermometer portion of a gas gauge.
Arguments:
Set - if TRUE, prepare for drawing the thermometer. If FALSE, restore
the state for normal drawing.
Return Value:
None.
--*/
{
static UCHAR SavedAttribute = 0;
if(Set) {
if(!SavedAttribute) {
SavedAttribute = CurrentAttribute;
CurrentAttribute = GAUGE_ATTRIBUTE;
}
} else {
if(SavedAttribute) {
CurrentAttribute = SavedAttribute;
SavedAttribute = 0;
}
}
}
VOID
DnPositionCursor(
IN UCHAR X,
IN UCHAR Y
)
/*++
Routine Description:
Position the cursor.
Arguments:
X,Y - cursor coords
Return Value:
None.
--*/
{
#if NEC_98
USHORT Cursor;
#endif // NEC_98
if(X >= SCREEN_WIDTH) {
X = 0;
Y++;
}
if(Y >= SCREEN_HEIGHT) {
Y = HEADER_HEIGHT;
}
ScreenX = X;
ScreenY = Y;
//
// Invoke BIOS
//
#if NEC_98
Cursor = ((ScreenX + (SCREEN_WIDTH * ScreenY)) * 2 + (USHORT)SCREEN_BUFFER);
if(CursorOnFlag) {
_asm {
mov ah,13h // function -- position cursor
mov dx,Cursor
int 18h
mov ah,11h // function -- cursor on
int 18h
}
CursorIsActuallyOn = TRUE;
} else {
_asm {
mov ah,13h // function -- position cursor
mov dx,Cursor
int 18h
mov ah,12h // function -- cursor off
int 18h
}
CursorIsActuallyOn = FALSE;
}
#else // NEC_98
_asm {
mov ah,2 // function -- position cursor
mov bh,0 // display page
mov dh,ScreenY
mov dl,ScreenX
int 10h
}
CursorIsActuallyOn = TRUE;
#endif // NEC_98
}
VOID
DnWriteChar(
IN CHAR chr
)
/*++
Routine Description:
Write a character in the current attribute at the current position.
Arguments:
chr - Character to write
Return Value:
None.
--*/
{
if(chr == '\n') {
ScreenX = 0;
ScreenY++;
return;
}
#if NEC_98
if ( ( ScreenX < SCREEN_WIDTH ) && ( ScreenY < SCREEN_HEIGHT ) ) {
SCREEN_BUFFER_CHR1(ScreenX,ScreenY) = chr;
SCREEN_BUFFER_CHR2(ScreenX,ScreenY) = 0x00;
Screen_Buffer_Attr(ScreenX,ScreenY, CurrentAttribute);
}
if(!CursorOn && CursorIsActuallyOn) {
CursorIsActuallyOn = FALSE;
_asm {
mov ah,12h // function -- cursor off
int 18h
}
}
#else // NEC_98
if ( ( ScreenX < SCREEN_WIDTH ) && ( ScreenY < SCREEN_HEIGHT ) ) {
SCREEN_BUFFER_CHR(ScreenX,ScreenY) = chr;
SCREEN_BUFFER_ATT(ScreenX,ScreenY) = CurrentAttribute;
UPDATE_SCREEN_BUFFER(ScreenX, ScreenY,1);
}
//
// shut cursor off if necessary
//
if(!CursorOn && CursorIsActuallyOn) {
CursorIsActuallyOn = FALSE;
_asm {
mov ah,2 // function -- position cursor
mov bh,0 // display page
mov dh,SCREEN_HEIGHT
mov dl,0
int 10h
}
}
#endif // NEC_98
}
VOID
DnWriteWChar(
#if NEC_98
IN PUCHAR chr
#else // NEC_98
IN PCHAR chr
#endif // NEC_98
)
/*++
Routine Description:
Write a DBCS character in the current attribute at the current position.
Arguments:
wchr - DBCS Character to write
Return Value:
None.
--*/
{
#if NEC_98
PUCHAR code = chr;
UCHAR moji_1st,moji_2nd;
USHORT sjis;
moji_1st = *code;
code++;
moji_2nd = *code;
code++;
// Make Shift JIS
sjis = (USHORT)moji_1st;
sjis = (sjis << 8) + (USHORT)moji_2nd;
// Shift JIS -> JIS code exchange
moji_1st -= ((moji_1st <= 0x9f) ? 0x71 : 0xb1);
moji_1st = (UCHAR)(moji_1st * 2 + 1);
if (moji_2nd > 0x7f){ moji_2nd--; }
if (moji_2nd >= 0x9e){ moji_2nd -= 0x7d; moji_1st++; }
else { moji_2nd -= 0x1f; }
// Create custom JIS code
moji_1st += 0x60;
// Grpah Mode Check
if (memcmp(&sjis,"\340\340",2) == 0){
SCREEN_BUFFER_CHR1(ScreenX,ScreenY) = (UCHAR)(sjis >> 8);
SCREEN_BUFFER_CHR2(ScreenX,ScreenY) = 0x00;
Screen_Buffer_Attr(ScreenX,ScreenY, CurrentAttribute);
SCREEN_BUFFER_CHR1(ScreenX+1,ScreenY) = (UCHAR)(sjis & 0xff);
SCREEN_BUFFER_CHR2(ScreenX+1,ScreenY) = 0x00;
Screen_Buffer_Attr(ScreenX+1,ScreenY, CurrentAttribute);
}
else {
SCREEN_BUFFER_CHR1(ScreenX,ScreenY) = moji_1st;
SCREEN_BUFFER_CHR2(ScreenX,ScreenY) = moji_2nd;
Screen_Buffer_Attr(ScreenX,ScreenY, CurrentAttribute);
SCREEN_BUFFER_CHR1(ScreenX+1,ScreenY) = (UCHAR)(moji_1st - 0x80);
SCREEN_BUFFER_CHR2(ScreenX+1,ScreenY) = moji_2nd;
Screen_Buffer_Attr(ScreenX+1,ScreenY, CurrentAttribute);
}
//
// shut cursor off if necessary
//
if(!CursorOn && CursorIsActuallyOn) {
CursorIsActuallyOn = FALSE;
_asm {
mov ah,12h // function -- cursor off
int 18h
}
}
#else // NEC_98
SCREEN_BUFFER_CHR(ScreenX,ScreenY) = *chr;
SCREEN_BUFFER_ATT(ScreenX,ScreenY) = CurrentAttribute;
SCREEN_BUFFER_CHR(ScreenX+1,ScreenY) = *(chr+1);
SCREEN_BUFFER_ATT(ScreenX+1,ScreenY) = CurrentAttribute;
UPDATE_SCREEN_BUFFER(ScreenX,ScreenY,2);
//
// shut cursor off if necessary
//
if(!CursorOn && CursorIsActuallyOn) {
CursorIsActuallyOn = FALSE;
_asm {
mov ah,2 // function -- position cursor
mov bh,0 // display page
mov dh,SCREEN_HEIGHT // screen height
mov dl,0
int 10h
}
}
#endif // NEC_98
}
VOID
DnWriteString(
IN PCHAR String
)
/*++
Routine Description:
Write a string on the client area in the current position and
adjust the current position. The string is written in the current
attribute.
Arguments:
String - null terminated string to write.
Return Value:
None.
--*/
{
PCHAR p;
#if NEC_98
for(p=String; *p; p++) {
if(!IsANK((UCHAR)*p)) {
DnWriteWChar((PUCHAR)p);
p++ ;
ScreenX += 2 ;
} else {
DnWriteChar(*p);
if(*p != '\n') {
ScreenX++;
}
}
}
#else // NEC_98
for(p=String; *p; p++) {
if(ISDBCS((UCHAR)*p)) {
DnWriteWChar(p);
p++;
ScreenX += 2;
} else {
DnWriteChar(*p);
if(*p != '\n') {
ScreenX++;
}
}
}
#endif // NEC_98
}
VOID
DnWriteStatusText(
IN PCHAR FormatString OPTIONAL,
...
)
/*++
Routine Description:
Update the status area
Arguments:
FormatString - if present, supplies a printf format string for the
rest of the arguments. Otherwise the status area is cleared out.
Return Value:
None.
--*/
{
va_list arglist;
static CHAR String[SCREEN_WIDTH+1];
int StringLength;
UCHAR SavedAttribute;
//
// First, clear out the status area.
//
DnpBlankScreenArea( STATUS_ATTRIBUTE,
0,
SCREEN_WIDTH-1,
SCREEN_HEIGHT-STATUS_HEIGHT,
SCREEN_HEIGHT-1
);
if(FormatString) {
va_start(arglist,FormatString);
StringLength = vsnprintf(String,sizeof(String),FormatString,arglist);
String[sizeof(String)-1] = '\0';
SavedAttribute = CurrentAttribute;
CurrentAttribute = STATUS_ATTRIBUTE;
DnPositionCursor(STATUS_LEFT_MARGIN,SCREEN_HEIGHT - STATUS_HEIGHT);
DnWriteString(String);
CurrentAttribute = SavedAttribute;
}
}
VOID
DnSetCopyStatusText(
IN PCHAR Caption,
IN PCHAR Filename
)
/*++
Routine Description:
Write or erase a copying message in the lower right part of the screen.
Arguments:
Filename - name of file currently being copied. If NULL, erases the
copy status area.
Return Value:
None.
--*/
{
unsigned CopyStatusAreaLen;
CHAR StatusText[100];
//
// The 13 is for 8.3 and a space
//
CopyStatusAreaLen = strlen(Caption) + 13;
//
// First erase the status area.
//
DnpBlankScreenArea( STATUS_ATTRIBUTE,
(UCHAR)(SCREEN_WIDTH - CopyStatusAreaLen),
SCREEN_WIDTH - 1,
SCREEN_HEIGHT - STATUS_HEIGHT,
SCREEN_HEIGHT - 1
);
if(Filename) {
UCHAR SavedAttribute;
UCHAR SavedX,SavedY;
SavedAttribute = CurrentAttribute;
SavedX = ScreenX;
SavedY = ScreenY;
CurrentAttribute = STATUS_ATTRIBUTE;
DnPositionCursor((UCHAR)(SCREEN_WIDTH-CopyStatusAreaLen),SCREEN_HEIGHT-1);
memset(StatusText,0,sizeof(StatusText));
strcpy(StatusText,Caption);
strncpy(StatusText + strlen(StatusText),Filename,12);
DnWriteString(StatusText);
CurrentAttribute = SavedAttribute;
ScreenX = SavedX;
ScreenY = SavedY;
}
}
VOID
DnStartEditField(
IN BOOLEAN CreateField,
IN UCHAR X,
IN UCHAR Y,
IN UCHAR W
)
/*++
Routine Description:
Sets up the display package to start handling an edit field.
Arguments:
CreateField - if TRUE, caller is starting an edit field interaction.
If FALSE, he is ending one.
X,Y,W - supply coords and width in chars of the edit field.
Return Value:
None.
--*/
{
static UCHAR SavedAttribute = 255;
CursorOn = CreateField;
if(CreateField) {
if(SavedAttribute == 255) {
SavedAttribute = CurrentAttribute;
CurrentAttribute = EDIT_ATTRIBUTE;
}
DnpBlankScreenArea(EDIT_ATTRIBUTE,X,(UCHAR)(X+W-1),Y,Y);
} else {
if(SavedAttribute != 255) {
CurrentAttribute = SavedAttribute;
SavedAttribute = 255;
}
}
}
VOID
DnExitDialog(
VOID
)
{
unsigned W,H,X,Y,i;
PUCHAR CharSave;
PUCHAR AttSave;
ULONG Key,ValidKeys[3] = { ASCI_CR,DN_KEY_F3,0 };
UCHAR SavedX,SavedY,SavedAttribute;
BOOLEAN SavedCursorState = CursorOn;
SavedAttribute = CurrentAttribute;
CurrentAttribute = EXITDLG_ATTRIBUTE;
SavedX = ScreenX;
SavedY = ScreenY;
//
// Shut the cursor off.
//
CursorIsActuallyOn = FALSE;
CursorOn = FALSE;
#if NEC_98
_asm {
mov ah,12h // function -- cursor off
int 18h
}
#else // NEC_98
_asm {
mov ah,2 // function -- position cursor
mov bh,0 // display page
mov dh,SCREEN_HEIGHT
mov dl,0
int 10h
}
#endif // NEC_98
//
// Count lines in the dialog and determine its width.
//
for(H=0; DnsExitDialog.Strings[H]; H++);
W = strlen(DnsExitDialog.Strings[0]);
#if NEC_98
W += 2;
#endif // NEC_98
//
// allocate two buffers for character save and attribute save
//
#if NEC_98
CharSave = MALLOC((W*H+2)*2,TRUE);
AttSave = MALLOC((W*H+2)*2,TRUE);
#else // NEC_98
CharSave = MALLOC(W*H,TRUE);
AttSave = MALLOC(W*H,TRUE);
#endif // NEC_98
//
// save the screen patch
//
#if NEC_98
for(Y=0; Y<H; Y++) {
for(X=0; X < (W+2) ;X++) {
UCHAR attr,chr1,chr2;
UCHAR x,y;
x = (UCHAR)(X + (DnsExitDialog.X - 1));
y = (UCHAR)(Y + DnsExitDialog.Y);
chr1 = SCREEN_BUFFER_CHR1(x,y);
chr2 = SCREEN_BUFFER_CHR2(x,y);
attr = SCREEN_BUFFER_ATTRB[x][y];
CharSave[(Y*W*2)+(X*2)] = chr1;
CharSave[(Y*W*2)+(X*2+1)] = chr2;
AttSave [(Y*W*2)+(X*2)] = attr;
if((X == 0) && (chr2 != 0)){
SCREEN_BUFFER_CHR1(x,y) = ' ';
SCREEN_BUFFER_CHR2(x,y) = 0x00;
}
if((X == (W-1)) && (chr2 != 0)){
if(((CharSave[(Y*W*2)+((X-1)*2+0)] - (UCHAR)0x80) == chr1) &&
( CharSave[(Y*W*2)+((X-1)*2+1)] == chr2)){
SCREEN_BUFFER_CHR1(x,y) = ' ';
SCREEN_BUFFER_CHR2(x,y) = 0x00;
}
}
}
}
#else // NEC_98
for(Y=0; Y<H; Y++) {
for(X=0; X<W; X++) {
UCHAR att,chr;
UCHAR x,y;
x = (UCHAR)(X + DnsExitDialog.X);
y = (UCHAR)(Y + DnsExitDialog.Y);
chr = SCREEN_BUFFER_CHR(x,y);
att = SCREEN_BUFFER_ATT(x,y);
CharSave[Y*W+X] = chr;
AttSave[Y*W+X] = att;
}
}
#endif // NEC_98
//
// Put up the dialog
//
for(i=0; i<H; i++) {
DnPositionCursor(DnsExitDialog.X,(UCHAR)(DnsExitDialog.Y+i));
DnWriteString(DnsExitDialog.Strings[i]);
}
CurrentAttribute = SavedAttribute;
//
// Wait for a valid keypress
//
Key = DnGetValidKey(ValidKeys);
if(Key == DN_KEY_F3) {
#if NEC_98
//
// On floppyless setup if user have canceled setup or setup be stopped
// by error occurred,previous OS can't boot to be written boot code
// and boot loader.
//
RestoreBootcode();
#endif // NEC_98
DnExit(1);
}
//
// Restore the patch
//
#if NEC_98
for(Y=0; Y<H; Y++) {
for(X=0; X < (W+2); X++) {
UCHAR attr,chr1,chr2;
UCHAR x,y;
x = (UCHAR)(X + (DnsExitDialog.X - 1));
y = (UCHAR)(Y + DnsExitDialog.Y);
chr1 = CharSave[(Y*W*2)+(X*2)];
chr2 = CharSave[(Y*W*2)+(X*2+1)];
attr = AttSave [(Y*W*2)+(X*2)];
SCREEN_BUFFER_CHR1(x,y) = chr1;
SCREEN_BUFFER_CHR2(x,y) = chr2;
Screen_Buffer_Attr(x,y, attr);
}
}
#else // NEC_98
for(Y=0; Y<H; Y++) {
for(X=0; X<W; X++) {
UCHAR att,chr;
UCHAR x,y;
x = (UCHAR)(X + DnsExitDialog.X);
y = (UCHAR)(Y + DnsExitDialog.Y);
chr = CharSave[Y*W+X];
att = AttSave[Y*W+X];
SCREEN_BUFFER_CHR(x,y) = chr;
SCREEN_BUFFER_ATT(x,y) = att;
if((0 == X) && ISDBCS((UCHAR)SCREEN_BUFFER_CHR(x-1,y))) {
UPDATE_SCREEN_BUFFER(x-1,y,2);
} else if (ISDBCS((UCHAR)chr)) {
X++ ;
x = (UCHAR)(X + DnsExitDialog.X);
y = (UCHAR)(Y + DnsExitDialog.Y);
chr = CharSave[Y*W+X];
att = AttSave[Y*W+X];
SCREEN_BUFFER_CHR(x,y) = chr;
SCREEN_BUFFER_ATT(x,y) = att;
UPDATE_SCREEN_BUFFER(x-1,y,2);
} else {
UPDATE_SCREEN_BUFFER(x,y,1);
}
}
}
#endif // NEC_98
FREE(CharSave);
FREE(AttSave);
CursorOn = SavedCursorState;
if(CursorOn) {
DnPositionCursor(SavedX,SavedY);
} else {
ScreenX = SavedX;
ScreenY = SavedY;
#if NEC_98
_asm {
mov ah,12h // function -- cursor off
int 18h
}
#else // NEC_98
_asm {
mov ah,2
mov bh,0
mov dh,SCREEN_HEIGHT;
mov dl,0
int 10h
}
#endif // NEC_98
CursorIsActuallyOn = FALSE;
}
}
//
// Internal support routines
//
VOID
DnpBlankScreenArea(
IN UCHAR Attribute,
IN UCHAR Left,
IN UCHAR Right,
IN UCHAR Top,
IN UCHAR Bottom
)
/*++
Routine Description:
Invoke the BIOS to blank a region of the screen.
Arguments:
Attribute - screen attribute to use to blank the region
Left,Right,Top,Bottom - coords of region to blank
Return Value:
None.
--*/
{
UCHAR x,y;
#if NEC_98
for(y=Top; y<=Bottom; y++) {
for(x=Left; x<=Right; x++) {
SCREEN_BUFFER_CHR1(x,y) = ' ';
SCREEN_BUFFER_CHR2(x,y) = 0x00;
Screen_Buffer_Attr(x,y, Attribute);
}
}
#else // NEC_98
for(y=Top; y<=Bottom; y++) {
for(x=Left; x<=Right; x++) {
SCREEN_BUFFER_CHR(x,y) = ' ';
SCREEN_BUFFER_ATT(x,y) = Attribute;
UPDATE_SCREEN_BUFFER(x,y,1);
}
}
#endif // NEC_98
}
#if NEC_98
#else // NEC_98
//
// Disable 4035 warning - no return value, since
// the register state is set correctly with the
// required return value
//
#pragma warning( disable : 4035 )
UCHAR _far *
DnpGetVideoAddress(
VOID
)
/*++
Routine Description:
This function retrieves the location of the Video Text Ram if one exists,
else will retrieve the location of the Pseudo (virtual) Text Ram.
Arguments:
None.
Return Value:
Either the Video Text RAM or Pseudo Text RAM address.
--*/
{
_asm {
push es
push di
mov ax, 0b800h
mov es, ax
xor di, di
mov ax, 0fe00h
int 10h
mov dx, es
mov ax, di
pop di
pop es
}
}
UCHAR _far *
DnpGetDbcsTable(
VOID
)
{
_asm {
push ds
push si
mov ax, 06300h
int 21h
mov dx, ds
mov ax, si
pop si
pop ds
}
}
//
// Reset the 4035 warning state back to the
// default state
//
#pragma warning( default : 4035 )
VOID
DnpUpdateBuffer(
UCHAR _far *VideoAddress,
int CharNum
)
/*++
Routine Description:
Updates one character in the Pseudo Text RAM to the display. This
function will have NO effect if the address points to the actual
text RAM, usually B800:0000H+ in US mode.
Arguments:
The address location of where the character is in the text RAM.
Return Value:
None.
--*/
{
_asm {
push es
push di
mov ax, word ptr 6[bp]
mov es, ax
mov di, word ptr 4[bp]
mov cx, CharNum
mov ax, 0ff00h
int 10h
pop di
pop es
}
}
VOID
DnpInitializeDbcsTable(
VOID
)
{
UCHAR _far *p;
UCHAR _far *Table;
int i;
Table = DnpGetDbcsTable();
for(p=Table; *p; p+=2) {
for(i = (int)*p; i<=(int)*(p+1); i++) {
DbcsTable[i] = TRUE;
}
}
}
#endif // NEC_98
int
DnGetGaugeChar(
VOID
)
{
#if NEC_98
return(0x20);
#else // NEC_98
return(0x14); //shaded square in cp932
#endif // NEC_98
}
#if NEC_98
VOID
Screen_Buffer_Attr(
SHORT x,
SHORT y,
UCHAR attr
)
{
UCHAR _far *pfgc;
SHORT fgc;
SHORT pc98col[] = { 0x5, 0x25, 0x85, 0x0a5, 0x045, 0x65, 0x0c5, 0x0e5};
SCREEN_BUFFER_ATTRB[x][y] = attr;
*((SCREEN_BUFFER + (2*((x)+(SCREEN_WIDTH*(y)))))+0x2000) = pc98col[((attr & 0x70) >> 4)];
pfgc = y * 80 * 16 + x;
fgc = attr & 0x0f;
_asm {
push ds
push cx
push bx
mov ax, 0a800h
mov ds,ax
mov cx,16
mov bx, pfgc
mov ax, fgc
and ax, 1;
mov al, 0
jz bfil
mov al,0ffh
bfil:
mov ds:[bx],al
add bx, 80
loop bfil
mov ax, 0b800h
mov ds,ax
mov cx,16
mov bx, pfgc
mov ax, fgc
and ax, 2;
mov al,0
jz gfil
mov al,0ffh
gfil:
mov ds:[bx],al
add bx, 80
loop gfil
mov ax, 0b000h
mov ds,ax
mov cx,16
mov bx, pfgc
mov ax, fgc
and ax, 4
mov al,0
jz rfil
mov al,0ffh
rfil:
mov ds:[bx],al
add bx, 80
loop rfil
mov ax, 0e000h
mov ds,ax
mov cx,16
mov bx, pfgc
mov ax, fgc
and ax, 8
mov al,0
jz ifil
mov al,0ffh
ifil:
mov ds:[bx],0ffh
add bx, 80
loop ifil
pop bx
pop cx
pop ds
}
}
int
WriteBackGrounf(
SHORT color
)
{
return(0);
}
#endif // NEC_98
#else
//
// Not compiling for DOS/V (ie, we're building the Japanese
// version of the 'standard' winnt.exe)
//
#include ".\dndisp.c"
#endif // def DOS_V
#else
#error Trying to use Japanese display routines but not compiling Japanese version!
#endif // def JAPAN
Reference in a new issue Copy permalink