mirror of https://github.com/lianthony/NT4.0
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.
770 lines
21 KiB
770 lines
21 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
violvb.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the Vio LVB routines
|
|
|
|
Author:
|
|
|
|
Michael Jarus (mjarus) 28-Apr-1992
|
|
|
|
Environment:
|
|
|
|
User Mode Only
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#define WIN32_ONLY
|
|
#include "os2ses.h"
|
|
#include "trans.h"
|
|
#include "vio.h"
|
|
#include "os2win.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <memory.h>
|
|
|
|
|
|
#define GET_LVB_PTR( row, col ) &LVBBuffer[((row) * SesGrp->ScreenColNum + (col)) << SesGrp->VioLength2CellShift]
|
|
#define GET_LVB_ATT_PTR( row, col ) &LVBBuffer[(((row) * SesGrp->ScreenColNum + (col)) << SesGrp->VioLength2CellShift) + 1]
|
|
|
|
typedef struct _attr_3_bytes
|
|
{
|
|
UCHAR Attr[3];
|
|
} ATTR_3_BYTES, *PATTR_3_BYTES;
|
|
|
|
#if DBG
|
|
//#define TEST_VIO_LVB 1
|
|
BOOL Ow2VioLvbIgnoreTest = FALSE;
|
|
#endif
|
|
|
|
PUCHAR Ow2VioLvbTestBuff = NULL;
|
|
|
|
DWORD
|
|
VioLVBInit()
|
|
{
|
|
#if DBG
|
|
#if TEST_VIO_LVB
|
|
|
|
if((Ow2VioLvbTestBuff = HeapAlloc(HandleHeap, 0, SesGrp->MaxLVBsize)) == NULL)
|
|
{
|
|
ASSERT1( "VioLVBInit: unable to allocate from heap to test VIO-LVB", FALSE );
|
|
return(1L);
|
|
}
|
|
#endif
|
|
#endif
|
|
return(0L);
|
|
}
|
|
|
|
|
|
VOID
|
|
VioLVBInitForSession()
|
|
{
|
|
#if DBG
|
|
#if TEST_VIO_LVB
|
|
ULONG Length = (ULONG)SesGrp->LVBsize;
|
|
|
|
Ow2VioGetLVBBuf(&Length);
|
|
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
DWORD
|
|
Ow2VioGetLVBBuf(
|
|
IN PULONG Length
|
|
)
|
|
{
|
|
#if DBG
|
|
if ((*Length >> SesGrp->VioLength2CellShift) != SesGrp->ScreenSize)
|
|
KdPrint(("OS2SES(VioLVB-VioGetBuf): partial length %lu form %lu\n",
|
|
*Length >> SesGrp->VioLength2CellShift, SesGrp->ScreenSize));
|
|
#endif
|
|
|
|
SesGrp->LVBOn = TRUE; // start echo to LVB buffer
|
|
return(Ow2VioReadCellStr(
|
|
Length,
|
|
0,
|
|
0,
|
|
LVBBuffer
|
|
));
|
|
}
|
|
|
|
|
|
DWORD
|
|
Ow2LvbUpdateLVBBuffer()
|
|
{
|
|
if (SesGrp->LVBOn)
|
|
{
|
|
IN ULONG Length = SesGrp->LVBsize;
|
|
|
|
return(Ow2VioGetLVBBuf(&Length));
|
|
}
|
|
|
|
return(NO_ERROR);
|
|
}
|
|
|
|
|
|
DWORD
|
|
Ow2VioShowLVBBuf(
|
|
IN ULONG Length,
|
|
IN ULONG Offset
|
|
)
|
|
{
|
|
DWORD Rc;
|
|
ULONG VioMask = ~(ULONG)SesGrp->VioLengthMask;
|
|
|
|
if ( Offset & VioMask )
|
|
{
|
|
Length += Offset & VioMask;
|
|
Offset = Offset & (ULONG)SesGrp->VioLengthMask;
|
|
}
|
|
|
|
if ( Length & VioMask )
|
|
{
|
|
Length = (Length + SesGrp->BytesPerCell) & SesGrp->VioLengthMask;
|
|
}
|
|
|
|
if (( Length + Offset) > (ULONG)SesGrp->LVBsize)
|
|
{
|
|
Length = SesGrp->LVBsize - Offset;
|
|
}
|
|
|
|
Rc = Ow2VioWriteCellStr(
|
|
Length,
|
|
((Offset >> SesGrp->VioLength2CellShift) / SesGrp->ScreenColNum),
|
|
((Offset >> SesGrp->VioLength2CellShift) % SesGrp->ScreenColNum),
|
|
((PBYTE)LVBBuffer) + Offset
|
|
);
|
|
return(Rc);
|
|
}
|
|
|
|
|
|
#if DBG
|
|
VOID
|
|
VioLVBTestBuff(IN PVOID DestBuffer)
|
|
{
|
|
#if TEST_VIO_LVB
|
|
if(!Ow2VioLvbIgnoreTest &&
|
|
memcmp( DestBuffer, LVBBuffer, SesGrp->LVBsize))
|
|
{
|
|
KdPrint(("Ow2VioReadCellStr: diff buffer\n"));
|
|
memmove( LVBBuffer, DestBuffer, SesGrp->LVBsize);
|
|
}
|
|
#else
|
|
UNREFERENCED_PARAMETER(DestBuffer);
|
|
#endif
|
|
}
|
|
|
|
|
|
VOID
|
|
VioLVBTestScroll()
|
|
{
|
|
#if TEST_VIO_LVB
|
|
ULONG Length = SesGrp->ScreenSize << SesGrp->VioLength2CellShift;
|
|
ULONG LineLength = SesGrp->ScreenColNum << SesGrp->VioLength2CellShift;
|
|
UCHAR *Buffer = &Ow2VioLvbTestBuff[0], *Ptr, *Ptr1, *Offset;
|
|
ULONG i, j, k;
|
|
|
|
if (Ow2VioLvbTestBuff)
|
|
{
|
|
Ow2VioLvbIgnoreTest = TRUE;
|
|
Ow2VioReadCellStr(
|
|
&Length,
|
|
0,
|
|
0,
|
|
Ow2VioLvbTestBuff
|
|
);
|
|
Ow2VioLvbIgnoreTest = FALSE;
|
|
|
|
for ( i = 0, Offset = &LVBBuffer[0] ;
|
|
i < (ULONG)SesGrp->ScreenRowNum ;
|
|
i++, Buffer += LineLength, Offset += LineLength )
|
|
{
|
|
if(memcmp( Buffer, Offset, LineLength))
|
|
{
|
|
Ptr = Buffer;
|
|
Ptr1 = Offset;
|
|
for (j = 0 ; j < LineLength ; j++ )
|
|
{
|
|
if (Ptr[j] != Ptr1[j])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
KdPrint(("VioScroll: diff buffer line %d, Pos %d\n", i, j));
|
|
KdPrint((" LVB: %2.2x%2.2x%2.2x%2.2x, ... %2.2x; Screen: %2.2x%2.2x%2.2x%2.2x, ... %2.2x\n",
|
|
Ptr1[0], Ptr1[1], Ptr1[2], Ptr1[3], Ptr1[j],
|
|
Ptr[0], Ptr[1], Ptr[2], Ptr[3], Ptr[j]));
|
|
|
|
for ( j = 0, k = 0 ; j < 5 ; j++, k += 0x20 )
|
|
{
|
|
Ptr = Offset + k;
|
|
KdPrint((" LVB-%d: %2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x\n", j,
|
|
Ptr[0], Ptr[1], Ptr[2], Ptr[3], Ptr[4], Ptr[5], Ptr[6], Ptr[7], Ptr[8], Ptr[9],
|
|
Ptr[10], Ptr[11], Ptr[12], Ptr[13], Ptr[14], Ptr[15], Ptr[16], Ptr[17], Ptr[18], Ptr[19],
|
|
Ptr[20], Ptr[21], Ptr[22], Ptr[23], Ptr[24], Ptr[25], Ptr[26], Ptr[27], Ptr[28], Ptr[29],
|
|
Ptr[30], Ptr[31]));
|
|
Ptr = Buffer + k;
|
|
KdPrint((" Scr-%d: %2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x,%2.2x%2.2x%2.2x%2.2x\n", j,
|
|
Ptr[0], Ptr[1], Ptr[2], Ptr[3], Ptr[4], Ptr[5], Ptr[6], Ptr[7], Ptr[8], Ptr[9],
|
|
Ptr[10], Ptr[11], Ptr[12], Ptr[13], Ptr[14], Ptr[15], Ptr[16], Ptr[17], Ptr[18], Ptr[19],
|
|
Ptr[20], Ptr[21], Ptr[22], Ptr[23], Ptr[24], Ptr[25], Ptr[26], Ptr[27], Ptr[28], Ptr[29],
|
|
Ptr[30], Ptr[31]));
|
|
}
|
|
|
|
memmove( Offset, Buffer, LineLength);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
|
|
VOID
|
|
VioLVBCopyStr( IN PUCHAR Sour,
|
|
IN COORD Coord,
|
|
IN ULONG Length)
|
|
{
|
|
|
|
if(SesGrp->LVBOn && Length)
|
|
{
|
|
register UCHAR *Ptr;
|
|
register ULONG Offset = (ULONG)SesGrp->BytesPerCell;
|
|
register ULONG Len = Length;
|
|
register PUCHAR Sou = Sour;
|
|
|
|
Ptr = GET_LVB_PTR( Coord.Y, Coord.X );
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.13.1993 V-AkihiS
|
|
if (Offset == 2)
|
|
{
|
|
for (;Len-- ; )
|
|
{
|
|
*Ptr = *Sou++;
|
|
Ptr += Offset;
|
|
}
|
|
} else
|
|
{
|
|
for (;Len-- ; )
|
|
{
|
|
*Ptr = *Sou; // copy character to lvb
|
|
Ptr += Offset-1; // skip to 3rd byte attr
|
|
if (Ow2NlsIsDBCSLeadByte(*Sou++, SesGrp->VioCP))
|
|
{
|
|
*Ptr++ = OS2_COMMON_LVB_LEADING_BYTE;
|
|
if (Len)
|
|
{
|
|
//
|
|
// Copy trailing byte charater, and mark
|
|
// this char as trailing byte
|
|
//
|
|
*Ptr = *Sou++;
|
|
Ptr += Offset-1; // skip to 3rd byte attr
|
|
*Ptr++ = OS2_COMMON_LVB_TRAILING_BYTE;
|
|
Len--;
|
|
} else
|
|
{
|
|
//
|
|
// If last written character was a lead byte,
|
|
// erase it.
|
|
//
|
|
*(Ptr-Offset) = ' ';
|
|
*(Ptr-1) = OS2_COMMON_LVB_SBCS;
|
|
}
|
|
} else
|
|
{
|
|
//
|
|
// Copy SBCS charater, and mark this char
|
|
// as SBCS
|
|
//
|
|
*Ptr++ = OS2_COMMON_LVB_SBCS;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
for (;Len-- ; )
|
|
{
|
|
*Ptr = *Sou++;
|
|
Ptr += Offset;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
VioLVBCopyCellStr( IN PUCHAR Sour,
|
|
IN COORD Coord,
|
|
IN ULONG LengthInCell)
|
|
{
|
|
if(SesGrp->LVBOn && LengthInCell)
|
|
{
|
|
#ifdef DBCS
|
|
// MSKK Oct.13.1993 V-AkihiS
|
|
if (SesGrp->BytesPerCell == 2)
|
|
{
|
|
memmove(
|
|
GET_LVB_PTR( Coord.Y, Coord.X ),
|
|
Sour,
|
|
LengthInCell << SesGrp->VioLength2CellShift);
|
|
} else
|
|
{
|
|
register UCHAR *Ptr;
|
|
register ULONG Len = LengthInCell;
|
|
register PUCHAR Sou = Sour;
|
|
|
|
Ptr = GET_LVB_PTR( Coord.Y, Coord.X );
|
|
|
|
for (;Len-- ; )
|
|
{
|
|
if (Ow2NlsIsDBCSLeadByte(*Sou, SesGrp->VioCP))
|
|
{
|
|
//
|
|
// Copy leading byte charater, 1st attr and 2nd attr
|
|
// and put leading byte attr to 3rd attr
|
|
//
|
|
*Ptr++ = *Sou++; *Ptr++ = *Sou++; *Ptr++ = *Sou++;
|
|
*Ptr++ = OS2_COMMON_LVB_LEADING_BYTE;
|
|
Sou++; // skip source 3rd attr.
|
|
if (Len)
|
|
{
|
|
//
|
|
// Copy trailing byte charater, and mark
|
|
// this char as trailing byte
|
|
//
|
|
*Ptr++ = *Sou++; *Ptr++ = *Sou++; *Ptr++ = *Sou++;
|
|
*Ptr++ = OS2_COMMON_LVB_TRAILING_BYTE;
|
|
Sou++; // skip source 3rd attr.
|
|
Len--;
|
|
} else
|
|
{
|
|
//
|
|
// If last written chell was a lead byte,
|
|
// erase it.
|
|
//
|
|
*(Ptr-4) = ' ';
|
|
*(Ptr-1) = OS2_COMMON_LVB_SBCS;
|
|
}
|
|
} else
|
|
{
|
|
//
|
|
// Copy SBCS charater, and mark this char
|
|
// as SBCS
|
|
//
|
|
*Ptr++ = *Sou++; *Ptr++ = *Sou++; *Ptr++ = *Sou++;
|
|
*Ptr++ = OS2_COMMON_LVB_SBCS;
|
|
Sou++; // skip source 3rd attr.
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
memmove(
|
|
GET_LVB_PTR( Coord.Y, Coord.X ),
|
|
Sour,
|
|
LengthInCell << SesGrp->VioLength2CellShift);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.13.1993 V-AkihiS
|
|
VOID VioLVBFillChar(IN PBYTE pChar,
|
|
IN COORD Coord,
|
|
IN ULONG LengthInCell)
|
|
{
|
|
if(SesGrp->LVBOn && LengthInCell)
|
|
{
|
|
register UCHAR *Ptr;
|
|
register ULONG Offset = (ULONG)SesGrp->BytesPerCell;
|
|
register ULONG Len = LengthInCell;
|
|
register PBYTE pCha = pChar;
|
|
|
|
Ptr = GET_LVB_PTR( Coord.Y, Coord.X );
|
|
|
|
if (Offset == 2)
|
|
{
|
|
if (Ow2NlsIsDBCSLeadByte(*pCha, SesGrp->VioCP))
|
|
{
|
|
Len /= 2;
|
|
for ( ;Len-- ; )
|
|
{
|
|
*Ptr = *pCha;
|
|
Ptr += Offset;
|
|
*Ptr = *(pCha+1);
|
|
Ptr += Offset;
|
|
}
|
|
} else
|
|
{
|
|
for ( ;Len-- ; )
|
|
{
|
|
*Ptr = *pCha;
|
|
Ptr += Offset;
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
if (Ow2NlsIsDBCSLeadByte(*pCha, SesGrp->VioCP))
|
|
{
|
|
Len /= 2;
|
|
for ( ;Len--; )
|
|
{
|
|
*Ptr = *pCha;
|
|
Ptr += Offset-1;
|
|
*Ptr++ = OS2_COMMON_LVB_LEADING_BYTE;
|
|
*Ptr = *(pCha+1);
|
|
Ptr += Offset-1;
|
|
*Ptr++ = OS2_COMMON_LVB_TRAILING_BYTE;
|
|
}
|
|
} else
|
|
{
|
|
for ( ;Len-- ; )
|
|
{
|
|
*Ptr = *pCha;
|
|
Ptr += Offset -1;
|
|
*Ptr++ = OS2_COMMON_LVB_SBCS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
VOID VioLVBFillChar(IN BYTE Char,
|
|
IN COORD Coord,
|
|
IN ULONG LengthInCell)
|
|
{
|
|
if(SesGrp->LVBOn && LengthInCell)
|
|
{
|
|
register UCHAR *Ptr;
|
|
register ULONG Offset = (ULONG)SesGrp->BytesPerCell;
|
|
register ULONG Len = LengthInCell;
|
|
register BYTE Cha = Char;
|
|
|
|
Ptr = GET_LVB_PTR( Coord.Y, Coord.X );
|
|
|
|
for ( ;Len-- ; )
|
|
{
|
|
*Ptr = Cha;
|
|
Ptr += Offset;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
VOID VioLVBFillAtt( IN PBYTE pAttr,
|
|
IN COORD Coord,
|
|
IN ULONG LengthInCell)
|
|
{
|
|
if(SesGrp->LVBOn && LengthInCell)
|
|
{
|
|
if ( SesGrp->BytesPerCell == 2 )
|
|
{
|
|
register PUCHAR Ptr;
|
|
register ULONG Offset = (ULONG)SesGrp->BytesPerCell;
|
|
register ULONG Len = LengthInCell;
|
|
register BYTE Att = *pAttr;
|
|
|
|
Ptr = GET_LVB_ATT_PTR( Coord.Y, Coord.X );
|
|
|
|
for ( ;Len-- ; )
|
|
{
|
|
*Ptr = Att;
|
|
Ptr += Offset;
|
|
}
|
|
} else
|
|
{
|
|
register PATTR_3_BYTES Ptr;
|
|
register ULONG Offset = (ULONG)SesGrp->BytesPerCell;
|
|
register ULONG Len = LengthInCell;
|
|
register ATTR_3_BYTES Att = *(PATTR_3_BYTES)pAttr;
|
|
|
|
Ptr = (PATTR_3_BYTES)GET_LVB_ATT_PTR( Coord.Y, Coord.X );
|
|
|
|
for ( ;Len-- ; )
|
|
{
|
|
#ifdef DBCS
|
|
// MSKK Jun.28.1992 KazuM
|
|
// MSKK Oct.13.1993 V-AkihiS
|
|
//
|
|
// retain char type attribute in 3rd byte attriute.
|
|
//
|
|
Att.Attr[2] = Ptr->Attr[2];
|
|
*Ptr = Att;
|
|
Ptr = (PATTR_3_BYTES)((PUCHAR)Ptr + Offset);
|
|
#else
|
|
*Ptr = Att;
|
|
Ptr += Offset;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID VioLVBFillCell(IN PBYTE pCell,
|
|
IN COORD Coord,
|
|
IN ULONG LengthInCell)
|
|
{
|
|
UCHAR *Ptr;
|
|
ULONG Pattern;
|
|
|
|
if(SesGrp->LVBOn && LengthInCell)
|
|
{
|
|
Ptr = GET_LVB_PTR( Coord.Y, Coord.X );
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.14.1993 V-AkihiS
|
|
if ( SesGrp->BytesPerCell == 4 )
|
|
{
|
|
if (Ow2NlsIsDBCSLeadByte(pCell[0], SesGrp->VioCP))
|
|
{
|
|
register ATTR_3_BYTES LeadAttr = *(PATTR_3_BYTES)(&pCell[1]);
|
|
register ATTR_3_BYTES TrailAttr = *(PATTR_3_BYTES)(&pCell[5]);
|
|
register ULONG Len = LengthInCell / 2;
|
|
|
|
LeadAttr.Attr[2] = OS2_COMMON_LVB_LEADING_BYTE;
|
|
TrailAttr.Attr[2] = OS2_COMMON_LVB_TRAILING_BYTE;
|
|
for ( ; Len-- ; ) {
|
|
//
|
|
// Put leading byte cell
|
|
//
|
|
*Ptr++ = pCell[0];
|
|
*(PATTR_3_BYTES)Ptr = LeadAttr;
|
|
Ptr += 3;
|
|
|
|
//
|
|
// Put trailing byte cell
|
|
//
|
|
*Ptr++ = pCell[4];
|
|
*(PATTR_3_BYTES)Ptr = TrailAttr;
|
|
Ptr += 3;
|
|
}
|
|
} else
|
|
{
|
|
Pattern = (ULONG)((pCell[3] << 24) |
|
|
(pCell[2] << 16) |
|
|
(pCell[1] << 8) |
|
|
(pCell[0]));
|
|
|
|
RtlFillMemoryUlong(
|
|
Ptr,
|
|
LengthInCell << SesGrp->VioLength2CellShift,
|
|
Pattern);
|
|
|
|
}
|
|
} else {
|
|
if (Ow2NlsIsDBCSLeadByte(pCell[0], SesGrp->VioCP))
|
|
{
|
|
Pattern = (ULONG)((pCell[3] << 24) |
|
|
(pCell[2] << 16) |
|
|
(pCell[1] << 8) |
|
|
(pCell[0]));
|
|
} else
|
|
{
|
|
Pattern = (ULONG)((pCell[1] << 24) |
|
|
(pCell[0] << 16) |
|
|
(pCell[1] << 8) |
|
|
(pCell[0]));
|
|
|
|
if (LengthInCell & 1)
|
|
{
|
|
*(Ptr++) = pCell[0];
|
|
*(Ptr++) = pCell[1];
|
|
LengthInCell-- ;
|
|
}
|
|
}
|
|
|
|
RtlFillMemoryUlong(
|
|
Ptr,
|
|
LengthInCell << SesGrp->VioLength2CellShift,
|
|
Pattern);
|
|
|
|
}
|
|
#else
|
|
// for (;Length-- ; )
|
|
// {
|
|
// *(Ptr++) = pCell[0];
|
|
// *(Ptr++) = pCell[1];
|
|
// }
|
|
|
|
if ( SesGrp->BytesPerCell == 4 )
|
|
{
|
|
Pattern = (ULONG)((pCell[3] << 24) |
|
|
(pCell[2] << 16) |
|
|
(pCell[1] << 8) |
|
|
(pCell[0]));
|
|
} else
|
|
{
|
|
Pattern = (ULONG)((pCell[1] << 24) |
|
|
(pCell[0] << 16) |
|
|
(pCell[1] << 8) |
|
|
(pCell[0]));
|
|
|
|
if ((ULONG)Ptr & 3) {
|
|
LengthInCell--;
|
|
*(Ptr++) = pCell[0];
|
|
*(Ptr++) = pCell[1];
|
|
}
|
|
|
|
if (LengthInCell & 1)
|
|
{
|
|
LengthInCell-- ;
|
|
*(Ptr + (LengthInCell << 1)) = pCell[0];
|
|
*(Ptr + (LengthInCell << 1) + 1) = pCell[1];
|
|
}
|
|
}
|
|
|
|
RtlFillMemoryUlong(
|
|
Ptr,
|
|
LengthInCell << SesGrp->VioLength2CellShift,
|
|
Pattern);
|
|
#endif
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
VioLVBScrollBuff(IN DWORD LineNum)
|
|
{
|
|
DWORD Size;
|
|
ULONG Pattern;
|
|
|
|
if (SesGrp->LVBOn && LineNum)
|
|
{
|
|
if ( LineNum > (DWORD)SesGrp->ScreenRowNum )
|
|
{
|
|
LineNum = SesGrp->ScreenRowNum;
|
|
}
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.20.1993 V-AkihiS
|
|
Size = SesGrp->BytesPerCell * SesGrp->ScreenColNum * LineNum;
|
|
if (SesGrp->BytesPerCell == 2)
|
|
{
|
|
Pattern = (ULONG)((SesGrp->AnsiCellAttr[0] << 24) |
|
|
(' ' << 16) |
|
|
(SesGrp->AnsiCellAttr[0] << 8) |
|
|
(' '));
|
|
} else
|
|
{
|
|
Pattern = (ULONG)((SesGrp->AnsiCellAttr[2] << 24) |
|
|
(SesGrp->AnsiCellAttr[1] << 16) |
|
|
(SesGrp->AnsiCellAttr[0] << 8) |
|
|
(' '));
|
|
}
|
|
#else
|
|
Size = 2 * SesGrp->ScreenColNum * LineNum;
|
|
Pattern = (ULONG)((SesGrp->AnsiCellAttr[0] << 24) |
|
|
(' ' << 16) |
|
|
(SesGrp->AnsiCellAttr[0] << 8) |
|
|
(' '));
|
|
#endif
|
|
|
|
RtlMoveMemory(LVBBuffer,
|
|
LVBBuffer + Size,
|
|
SesGrp->LVBsize - Size);
|
|
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.20.1993 V-AkihiS
|
|
if (SesGrp->BytesPerCell == 4)
|
|
{
|
|
Size = SesGrp->ScreenColNum * LineNum;
|
|
}
|
|
#endif
|
|
RtlFillMemoryUlong(LVBBuffer + SesGrp->LVBsize - Size,
|
|
Size,
|
|
Pattern);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
PUCHAR
|
|
Ow2LvbGetPtr(
|
|
IN COORD Coord
|
|
)
|
|
{
|
|
return(GET_LVB_PTR( Coord.Y, Coord.X));
|
|
}
|
|
|
|
|
|
VOID
|
|
LVBUpdateTTYCharWithAttrAndCurPos(
|
|
IN CHAR c,
|
|
IN PCHAR * LVBPtr
|
|
)
|
|
{
|
|
PCHAR Ptr = *LVBPtr;
|
|
USHORT i;
|
|
|
|
if(SesGrp->LVBOn)
|
|
{
|
|
*Ptr++ = c;
|
|
|
|
for ( i = 1 ; i < SesGrp->BytesPerCell ; i++ )
|
|
{
|
|
*Ptr++ = SesGrp->AnsiCellAttr[i - 1];
|
|
}
|
|
|
|
*LVBPtr = Ptr;
|
|
}
|
|
}
|
|
|
|
#ifdef DBCS
|
|
// MSKK Oct.13.1993 V-AkihiS
|
|
/* states of the finite state machine */
|
|
|
|
#define NOCMD 1 /* type of crt state - most chars will go onto screen */
|
|
#define ESCED 2 /* we've seen an ESC, waiting for rest of CSI */
|
|
#define EQCMD 3 /* if '=' goto MODPARAMS else PARAMS */
|
|
#define PARAMS 4 /* we're building the parameter list for ansicmd */
|
|
#define MODPARAMS 5 /* we're building the parameter list for MODCMD */
|
|
#define MODCMD 6 /* we've seen "ESC[=Num" waiting for #h or #l (# in {0..7}) */
|
|
#define MODDBCS 7 /* we've seen DBCS lead-in char */
|
|
|
|
VOID
|
|
LVBUpdateTTYCharWithAttrAndCurPosDBCS(
|
|
IN CHAR c,
|
|
IN PCHAR * LVBPtr,
|
|
IN USHORT State
|
|
)
|
|
{
|
|
PUCHAR Ptr = *LVBPtr;
|
|
|
|
if(SesGrp->LVBOn)
|
|
{
|
|
*Ptr++ = c;
|
|
|
|
if (SesGrp->BytesPerCell == 2)
|
|
{
|
|
*Ptr++ = SesGrp->AnsiCellAttr[0];
|
|
} else {
|
|
*Ptr++ = SesGrp->AnsiCellAttr[0];
|
|
*Ptr++ = SesGrp->AnsiCellAttr[1];
|
|
if (State == MODDBCS)
|
|
{
|
|
*Ptr++ = OS2_COMMON_LVB_TRAILING_BYTE;
|
|
} else
|
|
{
|
|
*Ptr++ = OS2_COMMON_LVB_LEADING_BYTE;
|
|
}
|
|
}
|
|
|
|
*LVBPtr = Ptr;
|
|
}
|
|
}
|
|
#endif
|